An AI workforce: a framework for thinking about agent orchestration

The keynote pitch for agent orchestration is engineering-shaped, pipelines, queues, message buses, the standard distributed-systems vocabulary applied to a new foundation. That framing produces working systems and produces specific failure modes that the framing makes harder to see. The framing that holds up better in production AI deployments I’ve read about is workforce-shaped: roles, teams, supervisors, performance review, succession planning. The agents aren’t workers in any literal sense; the management discipline that works for them is the same shape as the management discipline that works for human workers.

Worth being explicit about why and what falls out of the framing.

Why the engineering framing partly misses

The engineering framing for agent orchestration treats the system as a directed graph of computational units. Inputs flow in, transformations happen, outputs flow out. The discipline that comes with this framing is good distributed-systems practice, observability, retries, backpressure, idempotency, capacity planning. All of which are real and necessary.

What the engineering framing doesn’t capture cleanly:

Agent personas drift over time in ways that distributed systems don’t. The behavior of an agent six months after deployment isn’t the same as on day one. The system-prompt drift, the retrieval-corpus drift, the model-version drift all compound. Engineering frameworks don’t have a natural place for “this agent is performing worse this quarter than last.”

Agents accumulate institutional context in ways that processes don’t. A long-running agent has seen patterns, accumulated edge cases, learned the shape of the org. A new replica of the same agent doesn’t have any of that. Engineering frameworks treat replicas as identical; the workforce framing recognizes that experience matters.

The relationship between agents matters. When the planner-agent is consistently wrong about what the executor-agent can handle, the failure pattern looks like a manager-employee mismatch, not a queue-throughput problem. The diagnosis from the engineering framing produces wrong fixes.

The org evolves around the agent population. Humans adjust their work to accommodate the agents. Some workflows get easier; some get harder; some get replaced. The engineering framing models this as “users of the system”; the workforce framing models it as “team dynamics,” which is closer to the actual experience.

The engineering framing isn’t wrong. It’s incomplete in ways that matter for production operation.

The workforce framing, in concrete terms

Treat the agent population the way you’d treat a real workforce. The roles, the patterns, the practices:

Roles, with job descriptions. Each agent has a defined role, what it’s responsible for, what it’s not, who it reports to, what tools it has. Written down. Updated when the role changes. Same shape as a job description for a human employee, scaled to the simpler scope an agent occupies.

Teams, with supervisors. Agents don’t operate in isolation. The planner-executor pattern is a manager-direct-report relationship. The tool-scoped subagent pattern is a department with specialists. Supervisor agents (the planners, the routers, the orchestrators) have direct reports (the executors, the specialists). The chain of accountability is explicit.

Performance review. Periodic evaluation of how well each agent is doing its job. Acceptance rate of its outputs. Cost per useful outcome. Time-to-completion vs. expected. Same metrics shape as a human performance review, easier to measure because the agent’s outputs are structured.

Onboarding and offboarding. New agents get explicit setup, system prompt, tool access, scope, training data, evaluation suite. Departing agents get explicit decommissioning, context archived, dependencies migrated, audit trail preserved. Same lifecycle as a human employee.

Succession planning. When an agent is going to be replaced (newer model, different prompt, different scope), the transition is planned. The new agent shadows the old one for a period; differences are evaluated; the rollover is deliberate rather than abrupt.

Manager 1:1s. Periodic explicit review with each agent, what’s working, what isn’t, what scope changes are needed. Sounds anthropomorphic. In practice it’s the workflow that catches drift before it compounds.

These all sound silly at first. They land in production deployments visible in public reporting because they map cleanly to real organizational patterns the team already knows how to operate.

What the framing prevents

A few specific failure modes that the workforce framing catches that the engineering framing doesn’t:

Agent sprawl. Without role-and-supervisor discipline, agents proliferate. Every team adds their own. Nobody knows which is which. The org has 80 agents and uses 12. The workforce framing demands an org chart; the org chart prevents the sprawl.

Capability redundancy. Multiple agents doing the same job because nobody knew the existing one was there. The workforce framing treats this as duplicate hiring; the duplicate-hiring conversation is one orgs already know how to have.

Silent underperformance. An agent quietly getting worse over months. Nobody noticing because the engineering metrics don’t capture it. The workforce framing’s performance-review cadence makes the decline visible.

Lack of clear ownership. Agents running in production with no human owner. Decisions about scope changes, budget, retirement happen ad-hoc or not at all. The workforce framing assigns each agent a manager; the manager is accountable for the agent’s behavior.

Departure-induced fragility. When the engineer who built the agent leaves the company, the agent becomes orphaned. The workforce framing makes the succession-planning conversation explicit before the departure rather than after.

These are predictable. The engineering framing makes them harder to see because the framing’s vocabulary doesn’t have words for them.

The patterns from the workforce framing that work

Three specific practices that emerge from treating the agent population as a workforce:

The agent registry. A central document (usually a spreadsheet or a small structured database) listing every agent in production with its owner, role, scope, last-reviewed date, performance metrics. Same shape as an HR system’s employee directory, applied to agents. The teams that maintain this have markedly better operational hygiene than the teams that don’t.

The quarterly review. Once a quarter, each agent gets explicitly reviewed against its role and metrics. Underperforming agents get scope adjustments or get retired. Outperforming agents get expanded scope. The cadence prevents the silent-underperformance failure mode.

The role-versus-position distinction. A role is a defined set of responsibilities (“triage incoming customer-support tickets”); a position is a specific agent filling that role (“agent-id-7281, deployed 2025-08-12”). When an agent gets replaced (newer model, better prompt), the role persists; the position changes. The distinction lets the org reason about continuity through churn.

These map directly to standard HR practices. The teams that recognize the mapping save themselves from reinventing the discipline; the teams that don’t end up reinventing it badly.

Where the framing breaks

Worth being honest about the limits:

Agents aren’t actually workers. They don’t have agency, they don’t have careers, they don’t have wellbeing. The framing borrows the management vocabulary because it’s useful, not because it’s literally accurate. Pushing the framing too far (“the agent is unhappy”) is anthropomorphism that produces bad decisions.

The economics are different. Hiring a new human employee is a multi-month commitment with real onboarding cost. Spinning up a new agent is minutes. The workforce framing’s deliberation about hiring decisions doesn’t always apply to the agent case where iteration is cheap.

Performance review for agents is more straightforward. Agents don’t take feedback poorly, don’t have personal lives interfering with performance, don’t have ambiguous-attribution cases. The performance-review cadence that’s painful for human workers is easier for agent populations.

Some patterns don’t transfer. Career development, mentorship, succession into management, these don’t have agent equivalents. The framing borrows what’s useful and stops where it stops being useful.

The workforce framing is a tool for thinking, not a literal claim about what agents are. The teams that hold it loosely get the value; the teams that hold it too tightly get the anthropomorphism failure mode.

How this fits with the broader discipline

The workforce framing extends naturally from the treat-the-AI-like-an-employee discipline at the individual-agent level to the team-and-org level. The patterns from the agent design patterns piece (planner-executor, tool-scoped subagents, human-in-the-loop checkpoints) all have natural workforce analogs (manager-IC relationships, departments with specialists, approval workflows).

The foundation that supports the framing is the same one I’ve been writing about, MCP-only architecture for portability, OPA for policy, conversation as the atomic unit for cost and audit. The framing isn’t a substitute for the technical patterns; it’s the management overlay that makes the technical patterns operationally tractable at scale.

What I’d recommend

For teams running more than five or six agents in production:

• Start the agent registry. A spreadsheet is fine. Owner, role, scope, performance metrics, last reviewed. The act of starting it forces clarity about what you have.
• Do quarterly reviews. Block the time. Look at each agent. Decide whether the scope is right, the performance is acceptable, the role still matches the org’s needs.
• Distinguish role from position. When you replace an agent, you’re filling the same role with a new position. Track both.
• Assign owners. Every production agent has a human owner accountable for its behavior. The owner is the manager; the agent is the report.
• Treat sprawl as a real problem. When you find duplicate agents, consolidate. When you find orphaned agents, retire. Same pattern as headcount management.

The workforce framing is the framing the production AI orgs converge on after the engineering framing’s gaps become operational. The teams that adopt it earlier save themselves the discovery cycle. The teams that don’t end up at the same place a year later, with more cleanup work along the way.

Worth being deliberate about it.