A software engineer opens a chat window, pastes a stack trace, and waits for a suggested fix. A marketing manager types “write a product launch email” and copies the output into a draft. A data analyst asks for a SQL query, runs it, and comes back with a follow-up question. Three people, three different tasks, one interaction pattern: type a prompt, receive text, decide what to do with it.
This pattern works. It works well enough that most organizations have adopted it without much friction. It also leaves most of the potential value on the table.
The chat window treats every interaction as a standalone transaction. It holds no memory of what happened before, tracks no progress toward a larger goal, and carries no accountability for the outcome. The human on the other side absorbs all of that overhead: remembering context, managing workflow, evaluating quality, deciding next steps. The AI contributes text. The human contributes everything else.
A different arrangement is possible, one where the division of labor shifts along a cleaner line. Humans supply judgment. AI supplies execution. The boundary between the two is where the interesting engineering problems live.
The Execution Gap
Execution, in the context of knowledge work, means something specific. It means taking a defined objective and carrying it through to a deliverable. Research a competitor and produce a comparison matrix. Draft a proposal based on meeting notes and send it for review. Monitor a data pipeline and escalate anomalies.
Each of these tasks involves multiple steps, decision points, tool interactions, and intermediate outputs. A chat-based AI can assist with individual steps. It can draft a paragraph, write a query, summarize a document. The orchestration of steps remains the human’s responsibility.
The gap between step-level assistance and task-level execution is larger than it appears. Orchestration requires context: what has already been done, what the final deliverable looks like, who will review it, what standards apply. A stateless chat session holds none of this information. The human carries it in their head and re-supplies it with every new prompt.
When the task grows complex enough, the orchestration burden becomes its own form of work. The human spends more time managing the AI than doing the actual task. The tool has become a dependency rather than a lever.
Closing this gap requires agents that operate at the task level rather
than the step level. An agent that accepts an objective, maintains context across steps, invokes tools as needed, and produces a deliverable rather than a text fragment. The human’s role shifts from orchestrating steps to defining objectives and evaluating outcomes.
We are building Octo as a workspace designed around this shift. Not a chat interface with extra features, but a system where agents receive assignments, maintain work context, and deliver results for human review.
Identity as Infrastructure
An agent that executes tasks needs an identity. This is not a cosmetic concern.
In organizational settings, identity determines trust boundaries. A human employee has a name, a role, a set of permissions, and a work history.
These attributes determine what information they can access, what decisions they can make, and who is accountable for their output. An agent operating within an organization needs equivalent attributes to function within existing governance structures.
An anonymous agent cannot be assigned a task with clear accountability. It cannot be granted access to sensitive information through existing permission systems. Its output cannot be traced back to a responsible party for audit purposes. These are not edge cases. They are baseline requirements for any agent that handles real work in a real organization.
The identity model also shapes how humans interact with agents. A named agent with a defined role and visible track record gets treated as a collaborator. An anonymous chat window gets treated as a tool. The difference matters for adoption. People build working relationships with collaborators. They use tools and discard them.
Each Bot in Octo carries an AgentCard: a profile containing its role definition, capability set, and delivery history. A Bot is created by a specific person, operates on that person’s behalf, and inherits a subset of the creator’s permissions. The Bot becomes a digital proxy, an extension of its creator’s capacity rather than a free-floating assistant.
This proxy model has implications for delegation. A manager can create a Bot to handle routine approvals. An analyst can create a Bot to run recurring reports. The Bot acts within boundaries defined by its creator, and the creator retains accountability. Delegation without accountability is just automation. Delegation with accountability is a structural change in how work gets distributed.
The Judgment Layer
Execution without judgment produces output. Execution guided by judgment produces work product. The distinction matters.
An agent can draft a report based on available data. Whether that report is adequate depends on factors that sit outside the execution process: does the analysis address the right questions, are the sources credible, does the framing match the audience’s expectations, is the level of detail appropriate for the decision it supports. These are judgment calls. They require domain expertise, situational awareness, and an understanding of stakeholder expectations.
The human role in a human-agent collaboration centers on these judgment calls. Humans define what good looks like. They evaluate whether the output meets that standard. They provide corrections when it falls short. This is not a peripheral activity to be minimized. It is the core contribution that makes agent execution valuable.
Judgment also evolves over time. A reviewer who has evaluated fifty reports from a particular agent develops a sense of its tendencies: where it typically excels, where it commonly misses the mark, what kinds of instructions produce better results. This accumulated assessment constitutes a form of knowledge that should feed back into the agent’s behavior.
The Taste system in Octo captures this feedback loop. When a human reviews a Bot’s deliverable, the review generates preference signals: acceptances, rejections, modification notes, style corrections. These signals accumulate as preference cards that the Bot references in subsequent tasks. The Bot’s output adapts over time to reflect the reviewer’s standards and preferences.
A new Bot and a Bot that has worked with the same reviewer for three months should produce noticeably different output quality. If they don’t, the feedback mechanism isn’t working. The goal is not a static tool that performs the same way every time, but a collaborator that improves through accumulated judgment.
Multi-Agent Coordination
Most work involves more than one agent, especially once agents can handle task-level execution. A research task might benefit from one agent gathering information while another synthesizes findings. A content pipeline might involve separate agents for drafting, editing, and formatting. A complex analysis might require agents with different domain specializations working in parallel.
Coordination between agents introduces its own set of requirements. Agents need shared context: a common understanding of the overall objective, visibility into each other’s progress, and access to intermediate outputs. They need communication protocols: rules for when to hand off work, how to signal completion or blocking, and where to deposit results. They need conflict resolution: mechanisms for handling cases where two agents produce contradictory outputs or competing recommendations.
The coordination topology should match the work structure. Sequential tasks call for pipeline patterns where each agent receives input from the previous one. Exploratory tasks benefit from discussion patterns where agents exchange perspectives and refine ideas. Independent subtasks suit parallel execution with a final aggregation step. Forcing all coordination through a single pattern creates friction.
Octo supports six coordination modes. Solo handles single-agent work.
Roundtable enables multi-agent discussion with turn-taking. Critic pairs a producer with a reviewer. Pipeline chains agents in sequence. Split distributes subtasks for parallel processing. Swarm allows agents to self-organize around a shared objective. Each mode defines different communication rules, context-sharing boundaries, and control flows.
The human’s role in multi-agent coordination varies by mode. In Pipeline, the human might only intervene at the final review stage. In Roundtable, the human might participate as an equal voice or observe and intervene when needed. In Swarm, the human sets the objective and reviews the aggregate output. The level of human involvement scales with the complexity and risk of the coordination pattern.
Specialized agents also participate in these coordination patterns. Mano-P, a GUI-VLA agent built for edge devices, handles visual interface operations on local machines. It runs entirely on-device with no data leaving the host environment. The 72B model achieves 58.2% success rate on OSWorld benchmarks, while a 4B quantized version operates with just 4.3GB of memory at 76 tokens per second. Agents like Mano-P contribute specific execution capabilities that slot into larger coordination patterns managed by the workspace.
Organizational Memory
Individual preferences and task histories accumulate quickly. Across a team, the volume of accumulated knowledge becomes substantial: reviewer preferences, project contexts, client requirements, recurring task patterns, institutional standards. Most of this knowledge exists informally, stored in people’s heads or scattered across documents and email threads.
An agent-based workspace captures this knowledge as a byproduct of normal operation. Every review generates preference data. Every completed task produces context that might apply to future tasks. Every successful workflow demonstrates a pattern that could be reused. The system doesn’t need a separate knowledge management initiative. It accumulates knowledge through use.
Three categories of organizational knowledge emerge from this process. Context captures project-specific information, client backgrounds, and situational details that agents need to produce relevant output. Taste encodes quality standards, style preferences, and evaluation criteria that shape how agents approach their work. Skill packages recurring task patterns as reusable procedures that new agents can inherit.
Together, these three categories form an organizational asset that compounds over time. A team that has used the workspace for six months has accumulated a knowledge base that would take a new team months to build from scratch. This knowledge transfers across team members: a new hire inherits the accumulated context, taste, and skills without having to develop them personally.
The asset also creates switching costs, though of a healthy kind. The accumulated knowledge makes the workspace more valuable the longer it is used, which is the intended incentive structure. Teams invest in building their knowledge base and benefit from that investment over time.
Data Sovereignty
None of the above works if the data lives on someone else’s servers.
Work product contains sensitive information: strategic plans, financial projections, client data, internal communications, proprietary analysis. Organizations cannot route this information through third-party infrastructure without accepting risks they are often unwilling to accept. Regulatory requirements in many industries explicitly prohibit it.
Private deployment is not a premium feature. It is a prerequisite for any agent system that handles real organizational work. A system that requires data to leave the organization’s infrastructure limits itself to low-sensitivity use cases, which are also the lowest-value use cases.
Octo deploys on the organization’s own infrastructure. All data, all agent interactions, all accumulated knowledge stays within the organization’s environment. The system does not phone home, does not share telemetry, and does not require external API access for core functionality.
Access Points
Work happens in multiple contexts. A person might start a task at their desk, check progress from a phone during a meeting, review output while browsing the web, and trigger a follow-up from a terminal. An agent workspace that only exists in one interface creates friction every time the human switches contexts.
Four access points cover the common scenarios: a web application for full-featured interaction, a mobile interface for monitoring and quick decisions, a browser extension for context-aware interventions during web browsing, and a command-line interface for developers and automation workflows. Each interface provides access to the same underlying workspace, with the same context, the same agent relationships, and the same accumulated knowledge.
The goal is not omnichannel presence for its own sake. It is ensuring that the human can exercise judgment from whatever context they happen to be in, without having to switch to a dedicated interface to review output or provide direction.
The Shift
The transition from chat-based AI assistance to agent-based execution changes what humans spend their time on. Less time orchestrating steps, more time defining objectives. Less time re-supplying context, more time evaluating outcomes. Less time managing tools, more time exercising judgment.
This is not a marginal improvement. It is a different division of labor, one that allocates human attention to the activities where human judgment actually matters and delegates execution to agents that can operate autonomously within defined boundaries.
The engineering challenges are substantial. Agents need identity, context persistence, coordination protocols, feedback mechanisms, and organizational knowledge systems. The workspace that houses these agents needs to support private deployment, multiple access points, and integration with existing tools and workflows.
Octo is our approach to building this workspace. The code is open, the design decisions are documented, and the project welcomes examination and contribution. The multi-agent era is arriving through incremental engineering work, one coordination pattern at a time.
Top comments (1)
Yeah the human-judge / AI-execute split is exactly what I've been bumping into. Most of my stories are about the same thing — the judgment layer goes missing and the execution layer just keeps running.
That Taste system though. Without that, every conversation starts from zero and the human has to repeat themselves forever. Most people skip that part.