Humans direct, systems structure, agents execute

A company is changing how it prices and packages its product. It sounds like one decision, but by the time it reaches the teams who carry it out, it is dozens. Product is redrawing the plan tiers. Finance is reworking billing logic. Legal is revising the contract language and the regional terms. Marketing is regenerating the pricing pages.

Several of these teams are working with agents, and for good reason. A person describes what they need, the agent produces the change, and the person reviews it before it ships. For a while this works exactly the way everyone hoped. Each function moves faster, and the work looks clean.

Then Legal narrows a discount rule for one region. It is a small, sensible change, the kind that happens constantly late in a rollout. But that rule was an assumption other people had already built on. The billing logic now computes a discount that is no longer allowed. A pricing page still advertises the offer Legal just restricted. Two support answers describe the old terms. Some of that work was done by people and some by agents, and most of it was already considered finished.

Fixing any one agent’s output would only address part of the issue. The dependency sits across the tasks: one decision changed while the work built on it was already moving ahead.

The model that already works

The way each team started is not wrong. Handing a bounded task to an agent, reviewing the result, and moving on is a good way to work, and teams are scaling it because it earns its keep. It holds up because one person can keep the whole task in their head: they set the goal, supply the context, and check the output.

That is also the condition it depends on. The loop works while the task is self-contained and one person can stay with it start to finish. For work like that, direct delegation is the right tool, and wrapping structure around it would only get in the way.

Where that model stops being enough

The pricing rollout is not self-contained work. It is many people and several agents acting at once on pieces that all depend on the same direction, the same constraints, and the same decisions, and those decisions are still moving while the work is underway.

Watch what one person has to do when Legal narrows that discount rule. They have to notice it matters beyond Legal, find every piece of work built on the old rule across billing, pricing, entitlements, and support, and tell the people and agents already mid-task that the ground shifted. Then they have to sequence the rework so the billing change lands before the page that describes it, reconcile outputs built on different assumptions, and keep a running account of what is still wrong, because nothing else is keeping it.

That person has become the place where all the coordination happens. Every dependency runs through their memory and their messages. Connecting a person directly to an agent does not eliminate coordination. It can make the person the coordination layer.

The issue is bigger than how well any one agent is prompted. A sharper brief to the billing agent does not tell the pricing page that its offer is void. Adding more agents without changing the coordination model makes it worse: each capable actor produces more work that then has to be kept consistent with everyone else's, and the reconciler is still one person.

What the work has to carry

People have always done this by hand. Someone holds the current direction, passes decisions along, and reconciles the outputs at the end. It works until enough people and agents are acting at once that it can no longer live in one person's head.

The alternative is to move that context out of memory and into the work itself, so every actor reads the current state from the same place and writes changes back to it. The work needs to carry:

• current direction
• ownership
• dependencies
• execution state
• decisions already made
• activity and provenance

When the discount rule changes, it changes in the one place the billing work, the pricing pages, and the support answers are all connected to, not in a message that some people saw and some did not.

The first job of a system here is to keep connected work coherent enough that many actors can operate on the same current state without each other in the room. In Plane, it is what the ordinary objects do. Work items, their states, and the dependencies between them are durable and shared rather than private to a task; Pages and Wiki hold the context the work refers to; activity and history record who did what.

Authority is delegated, not centralized

Shared state tells an actor what is happening. It does not tell them what they are allowed to do about it. Those are different questions, and the second is where agents change the problem.

Humans set the decision space:

• intent and policy
• acceptable risk
• what is delegated
• escalation conditions
• accountability

Inside that space an agent can do real work of its own, weighing options and making a call without returning every choice to a person. An agent updating entitlement rules should be able to resolve an ordinary ambiguity on its own. It should not be able to widen a discount past the limit Legal set, and when it reaches that edge it should stop and hand the decision back.

The system makes those limits explicit and holds them: who may act, what has been delegated, within what bounds, and when the decision returns to a human. Good delegation draws the boundary and leaves room inside it. A capable actor should know where it can move, where it must stop, and when to escalate, without asking permission at every step. Requiring approval before every action may reduce risk, but it also rebuilds the human bottleneck as a queue of approvals.

The four handoffs

Shared state and delegated authority only matter if they survive contact with real work, as it moves between people, the system, and agents, and while several actors move at once. Work changes hands at four points, and each has the same test: whoever picks it up next needs enough current state, context, authority, and history to keep going without rebuilding what came before.

Human → system

A person's direction has to become something the work itself carries: durable intent and delegated authority others can act on without that person in the room. Until it is represented in the work, it lives only in their head, and everyone else depends on that person to relay it.

System → agent

An agent should take on work as a scoped assignment that carries its own context: the current state, the boundaries on what it may decide, what a good result looks like, and how far its reach extends. A prompt can carry that context for one run. Structured work keeps it current and available to everyone acting next.

Agent → system

As the agent acts, its execution has to become shared state. What it produced and changed, and the questions it could not resolve, return to the work so the next actor can use them. What returns is the outcome and the record behind it, not a transcript of the agent's reasoning. Others need to know what changed and what evidence supports it, not how the agent thought.

System → human

Most execution should never come back to a person. It comes back when an agent reaches the edge of what it was allowed to do, when two pieces of work conflict, or when execution turns up something that suggests the direction itself was wrong. When the billing agent finds that the narrowed discount breaks a contract already signed with a customer, that is not a task to finish. It is a decision for an accountable person, and the answer becomes the new direction.

None of this is a single baton passed hand to hand. The actors work in parallel, and the system's harder job is keeping them coherent while they do: when one changes a state another relied on, when a decision shifts mid-execution, when a new constraint invalidates work already in flight. A change made in one place has to reach the others through the shared state, not through the person who used to carry messages between them.

The state everyone works from is authoritative in one sense only: it is the agreed basis for what happens next. That is not the same as being right. Execution turns up things the direction did not anticipate, and when it does, the accountable human can revise or reaffirm the direction, and the revision becomes the new basis for action. That feedback loop is what lets execution change the direction rather than only carry it out.

In Plane, this is why humans and agents can operate against the same work context even when execution happens in connected tools, why state changes and dependencies stay available in the same work context to the actors who need them, and why the activity log of a work item records human and agent actions alike. It is what a handoff to a coding agent like Cursor is built around: the branches, pull requests, and state changes it produces return to the same work item, instead of ending their life in a separate system.

What changes when a layer is missing

A model is worth more if it says what goes wrong when a part is missing. Here the three roles are not interchangeable, and their absences do not match.

Without a system

Take the system away first, because this is a common failure today and the direct result of the pricing story. An agent may keep history and attribution inside its execution environment, but that is different from shared organizational state that every connected actor works from. So context fragments across people, agent runs, and tools. Two actors work from different versions of the same thing. Someone reconciles agent output into the shared state of the work by hand, after the fact. Discoveries do not reliably land where the next actor will see them. And the person in the middle stays the router, which is where the opening left them.

Without accountable human authority

Removing accountable human authority is a different failure, and not the same as having no human present. A person can delegate broad discretion and step out of routine execution entirely, and the work can be better for it. What cannot go missing is ownership of the direction, the definition of where the boundaries sit, and a path for exceptions to reach someone when those boundaries stop being enough. The failure is unowned direction and unowned exceptions. The chairs can all be full and a consequential tradeoff still gets made by something with no standing to make it, or does not get made at all.

Without agents

Take the agents away and the work still functions. People have directed and carried out work through structured systems for a long time; agents add another kind of execution capacity to that structure. A team that uses none of them is not doing it wrong. What changes when agents arrive is the set of actors, not the job the structure has to do.

When authority has to become explicit

Enterprise systems have long modeled roles, approvers, scoped access, service accounts, workflows, and conditional permissions. Those controls already define what different actors are allowed to do. Agents introduce a harder question: when should an actor exercise that permission without a person making the call in the moment?

Traditional permissions mostly answer one question: what may this actor access or do? The other question, when an action is appropriate, often did not have to be encoded in software. It lived in judgment, training, policy, oversight, and convention. In many teams, software can determine whether a support rep can issue a refund, while policy and judgment still help determine whether they should.

When an autonomous agent reasons and acts directly on the work, the organization cannot count on tacit norms or a manager's judgment being present at the moment the action is taken. So more of that decision boundary has to become explicit and enforceable in the system itself.

As agents act with more autonomy, the conditions around when an action is appropriate have to become more explicit in the system instead of relying on the people around it to supply that judgment.

So the coordination system has to take on more of what often sat outside it: decision boundaries, delegated discretion, escalation conditions, the authority specific to each actor, and a record of what autonomous actors did and on what basis. Making work legible enough for humans and agents to operate on was the earlier step. The next step is making delegated discretion first-class, and how well a system does it decides whether more execution capacity becomes coordinated progress or only more output to reconcile.

How this looks in Plane

Plane already supports key parts of this model:

Shared state

Much of the foundation for shared state is already there: work items, their states, and the relationships and dependencies between them give the work durable structure, while Pages and Wiki hold the surrounding context, and activity and history record who did what.

Governance and boundaries

The governance layer is here too. Workflows, governed state transitions, and approvals put real limits on how work moves, and permissions define what human users may do.

Agent execution

Where execution returns to the work, agents appear as identities of their own, each with its own name, so an agent's action is attributed to it in a work item's activity and history the same way a person's is. A handoff to a coding agent like Cursor is built so the branches, pull requests, and state changes come back to the same work item, which is the agent-to-system return path made concrete.

A coordination layer for humans and agents

The pricing rollout is where this started. Several teams were using agents well until a decision moved and the connected work did not move with it. Another agent on each team would not have solved that. A system that holds the shared state and the boundaries lets each of them keep acting through the change instead of waiting on one person to carry it.

Humans direct, systems structure, agents execute. Plane is the coordination layer being built around that.

See how Plane brings humans and agents into the same work context.