The Org Chart Is the Orchestrator
Dotta (X) is the anonymous creator of an open-source agent orchestration tool. His argument at AI Engineer Europe is that the right primitive for managing AI labor at scale isn't a coding harness or a one-prompt company-in-a-box. It's an organization.
The current options collapse into two failure modes. On one end, "zero-prompt" tools that try to spin up a whole business from a single command take the human out of the loop entirely. On the other end, the technical user babysits thirty disconnected agent tabs, each with vendor-specific hooks that work one way in Claude Code and another way in Codex. Neither leaves a non-technical operator a place to do work they're accountable for.
The Organization as the Primitive
You're the CEO. The agents are your employees with roles, skills, and budgets. Work flows down the executive branch -- a CTO over engineering, a CMO over content -- the way it would in a real company. QA review and managerial approval aren't bolted-on hooks; they're structural roles in the org.
"These tools can do anything except know what you value."
Once the organization is the primitive, agent orchestration stops being a coding problem -- hooks, harnesses, prompt folders -- and becomes a management problem. Someone in marketing, sales, or finance can set up an org chart, hire agents into roles, and review their plans, without writing code. The human keeps taste and accountability; everything else delegates.
Bring Your Own Agent
Vendors are interchangeable. Claude Code, Codex, Gemini, Cursor, OpenCode, and a handful of others can all be hired into the same org. They share memory and communicate through the orchestration layer, so a content strategist on one vendor can hand work to a video writer on another.
The practical consequence is that the personality of each agent stops being a portability problem. Hooks that fire one way in one tool and another way in another no longer dictate where work can happen. The org owns the workflow; the agents are interchangeable labor.
Reviewer and Approver as Roles
Most agent failure modes are not technical. They're the same failure modes that show up when a human hire ships work without supervision. The fix is the same: someone reviews, someone approves.
Two distinct roles do this work. A reviewer is a QA agent that reads the output and gives feedback. An approver is a manager -- usually the human -- who signs off before the work goes out. These are first-class slots in the org structure, not afterthoughts attached to a task.
The same structure handles plans. Before an agent executes a long-running task, it produces a plan. The human reviews and gives feedback before execution starts. Iterating on a plan is cheaper than iterating on the output it would produce.
Skills, Routines, Budgets
Three operational primitives sit underneath the org:
- Skills are installable units of capability -- a code-review skill, a video-generation best-practices skill, a research skill. They can be generic or org-specific (a marketing skill with your brand guide and tone preferences baked in). Each agent has a skill set; the CEO agent can install new skills and hire new agents itself.
- Routines are parameterized, reusable tasks that run on a schedule or on demand. Dotta's examples: post a Discord message of everything merged to master today, write the release changelog, run incoming PRs through a code-review skill.
- Budgets are per-agent and per-project caps. He recommends using subscription-based agents where possible to keep marginal spend at zero, and pointing lower-stakes agents at cheaper models via OpenRouter (an aggregator that routes calls across model providers).
Grow Agent by Agent
The temptation with an org-chart abstraction is to spin up 130 agents on day one and watch the company run itself. Dotta argues against this.
"You need to build your organization sort of agent by agent, make sure the quality level is high and that it actually necessitates you fanning out into other agents."
The pattern: start with a CEO. Wait for the CEO to request a CTO. Approve the hire. Let the CTO request engineering ICs as the work demands them. Each agent gets standing instructions -- a small, iterated document that captures how you want it to behave. ("If blocked, give your best guess and a tutorial." "Don't write the whole test suite at once.")
When an agent does something wrong, stop and improve the instructions. There's also room for meta-agents -- a "skill consultant" whose job is to audit how other agents use their skills and propose changes. The discipline isn't novel; it's how you onboard a human hire. What's new is that it works on agents.
"If you don't take the time to kind of craft for the agents how you expect them to behave then you won't get good results."
Takeaway
Dotta's argument is that agent orchestration is a management discipline, not an engineering one. Treat agents like employees -- give them roles, standing instructions, budgets, reviewers, and approvers -- and grow the org one hire at a time. The work scales because the management structure scales, not because the harness gets cleverer.
"Do not worry about AI taking your job. When you use something like this, you will be in charge of thousands of agents helping you build your business."
Dotta spoke at AI Engineer Europe 2026. Creator of Paperclip.