Teams of Humans and Agents: What an AI-Native Company Looks Like

The pitch usually arrives as a diagram. Hire an AI marketing lead, an AI sales rep, an AI researcher, an AI support agent, and stack them under a CEO box that is also an agent. Define the mission, approve the strategy from the top, and watch the boxes fill in. It looks like a company, so it feels like the obvious shape for an AI-native one.

In practice that shape starts to fight you within the first week. The work a real team does does not respect the boxes. A "sales" task needs a code change to the landing page. A "research" task produces something a human has to approve before it goes out. The CEO box approves things it cannot actually evaluate, and the humans who used to do this work have nowhere to stand in the chart because the chart was drawn as if they left.

The problem is not that the agents are weak. It is that the org chart is the wrong primitive. An org chart is a model of who reports to whom in a company of people who each hold a job for years. Agent work is not jobs held for years. It is tasks that need an owner, a boundary, a check, and sometimes a human decision — assigned to whichever worker, human or agent, is right for that task.

The org chart is a simulation, a team is the real thing

A company-simulator gives you a fixed cast of role-bots and asks you to manage them like direct reports. The appeal is that it looks familiar. The cost shows up the moment the simulation has to touch the company you actually run.

A few things break predictably:

• The roles are a costume, not a contract. An "AI CFO" is a label on a general-purpose agent. The title implies judgment and accountability the agent does not have, so the human ends up reviewing its output anyway — now with a misleading name in the way.
• The humans disappear from the diagram. Real recurring work has a person who owns the outcome, a person who approves the risky parts, and a person who gets pulled in when something is wrong. An org chart of bots has no honest place to draw them.
• Approval flows the wrong direction. Approving "strategy" from the top is cheap and vague. The decisions that actually carry risk are small and specific — send this email, merge this change, spend this budget — and they happen far below the box you were asked to sign off on.
• It assumes a new company. The chart is drawn for a business that does not exist yet. The business you have already has tools, accounts, and people. A simulated org chart has no slot for them.

The alternative is not a better diagram. It is to stop simulating a company and treat the work as a team — your people included — where agents are members and the structure follows the task, not a title.

The model: shared work, autonomy per agent, judgment to one inbox

Three ideas replace the org chart, and they are operational rather than decorative.

Work is assigned, not org-charted. A task gets an owner and an executor. The executor can be a human or an agent. There is no permanent "marketing department" of bots. There is a task that needs doing and a worker suited to it. The same task structure holds whether a person or an agent picks it up, which is what lets the two share a workload instead of running in parallel side channels.

Autonomy is a property of the agent, not the company. You do not set one global "how autonomous is my AI" dial. Each agent has its own level, because a draft-writing agent and a code-merging agent do not deserve the same leash. The levels are concrete:

Autonomy level	What the agent may do alone	Where the human stays
Supervised	Propose and prepare work. Little proceeds without a step	Approves most actions before they happen
Balanced	Act within set boundaries and stop at the risky steps	Approves the specific actions that carry risk
Autonomous	Run the workflow end to end within its boundaries	Reviews results and handles exceptions
Full	Operate without per-step gates inside its scope	Owns the boundary and the budget, not each step

The point of four levels is that you can run a low-risk agent at Autonomous and a high-risk one at Supervised in the same workspace, on the same day. That is impossible to express as a single org chart and trivial to express as a per-agent setting.

Judgment flows to one inbox. Whatever an agent cannot decide alone becomes an inbox item: an approval, a question, a failed verification, an exception, a proposal. Instead of an approval ritual at the top of a chart, the specific decision that needs a human comes back to a single surface with its evidence attached. The human stays in control by living in the inbox, not by watching the boxes.

These three ideas are worked through one surface each. You direct strategy and fan work out in chat, you approve and answer in the inbox, and you dig into a specific piece of work in tasks. Chat to direct, inbox to approve, tasks to dig in.

What humans keep, and where agents fit

Dropping the org chart does not mean dropping structure. It means naming roles per task instead of per title, and being honest that the load-bearing roles stay human.

Responsibility	Human	Agent	Notes
Owner of the outcome	Yes	No	A person is accountable for whether the work was the right work
Executor of the steps	Sometimes	Often	Either can do the work, and the agent does the repeatable bulk
Approver of risky actions	Yes	No	Sending external mail, merging, spending — a human signs off
Reviewer of quality	Usually	Rarely	A human checks fit-for-purpose, and an agent can pre-check mechanics
Escalation point	Yes	No	When the agent is stuck or uncertain, a named person answers
Verifier of mechanical checks	Sometimes	Yes	Tests, link checks, field extraction — gates a workflow can run
Proposer of new work	Yes	Yes	Agents notice repetition and can propose tasks or workflows

Read down the human column and you have the real chart: owner, approver, reviewer, escalation point. None of those are titles you assign to a bot. They are positions a person holds relative to a specific piece of work, and they are exactly the positions the org-chart pitch erases.

The agent column is broad on execution and verification, narrow on accountability. That asymmetry is the whole design. An agent can do an enormous amount of the work and still not be the thing that is responsible for it.

Where an autonomous lead agent makes sense

There is a version of "agent at the top" that is useful, and it is worth separating from the company-simulator version.

You can configure an autonomous lead — an agent that runs ahead of you, picks up work, coordinates other agents, and keeps things moving without waiting for a step at every turn. This is the legitimate kernel inside the "AI CEO" fantasy. The difference is that the lead is one configured agent with an autonomy level and a budget, not a costume implying it runs the company.

A lead makes sense when:

• The work is high-volume and repetitive enough that routing every item through you is the bottleneck.
• The boundaries are clear enough that "run ahead" has a defined edge.
• The decisions that still carry real risk are wired to stop at the inbox regardless of how far ahead the lead runs.

A lead is the wrong reach when the work is mostly novel judgment, when the boundaries are still being discovered, or when "run ahead" would mean the lead approving its own risky actions. The honest tradeoff: a lead trades oversight for throughput, and that trade is only safe where the stop points are explicit. An autonomous lead with vague boundaries is just the org chart's CEO box wearing better marketing.

Determinism is what keeps a team from becoming a simulation

The reason a team of humans and agents does not collapse back into improvisation is that the recurring work runs as deterministic workflows, not an agent freelancing on your behalf.

A workflow is an explicit graph. It has steps, branch conditions, retries, approval nodes where a human must sign off, and verifier nodes where a check decides whether the work may proceed. A run does the same thing every time, and you can read it afterward. Two controls keep it inside its lane:

• Budgets cap what an agent or a run can spend, so "run ahead" cannot quietly turn into runaway cost.
• Step logs record what each step did, so a finished run is something you can inspect, diagnose, and improve rather than a summary you have to trust.

This is the part the org-chart metaphor never delivers. A box on a chart does the same work differently every time and leaves no trail. A workflow with approval and verifier nodes is the opposite: repeatable where it should be, gated where it must be, and legible after the fact.

An honest limit

This model asks more of you up front than the simulator does. A company-simulator's appeal is real: you describe a mission, it spins up a cast, and you are "running a company" in minutes because it brings its own conventions and assumes a blank business.

Setting autonomy per agent, naming owners and approvers, and wiring approval and verifier nodes into a workflow is more deliberate work than accepting a pre-drawn chart. The payoff is that the result fits the company you already run instead of a simulated one, and that the control is real rather than ceremonial. But it is a genuine tradeoff, not a free win — if your work is a handful of one-off prompts, the structure is overhead you do not need yet. The model earns its setup cost when the work repeats, touches shared systems, and has consequences other people feel.

Where Task Machine fits

This is the shape Task Machine is built around. Humans and agents share the same tasks across three surfaces — chat to direct, inbox to approve, tasks to dig in. Autonomy is set per agent across Supervised, Balanced, Autonomous, and Full. An autonomous lead runs ahead where you configure one. Recurring work runs as deterministic workflows with approval and verifier nodes, bounded by budgets and recorded in step logs, and everything that needs your judgment comes back to one inbox.

It is not an org chart of bots you approve from above. It is the operating layer for a team of humans and agents, slotted into the company you already have.

If that is the company you are trying to build, join the private beta on the waitlist.