← Research library

Orchestration, not individual agents, is the real unit of work

AI-assisted research. This note was prepared with the assistance of AI tools. It may contain errors and is not professional advice. See our Legal Disclosures.

Most early work with marketing agents focuses on a single task: write a post, summarize a report, score a lead. Those experiments are useful, but they hide the real challenge, because marketing outcomes are rarely produced by one task.

A campaign that drives pipeline involves research, positioning, content, distribution, follow-up, and measurement. Each step depends on the others, and each may involve a different agent, tool, or person. Improving one step in isolation can leave the campaign no better off.

That is why our research treats orchestration, the coordination of many agents, tools, and people toward a shared goal, as the real unit of work.

Where single agents stall

Programs that deploy several independent agents tend to hit the same wall. Each agent performs well in its own tests, yet the campaign still underperforms. The symptoms are familiar once you know to look for them.

  • Lost findings: the research agent's insights never reach the content agent.
  • Stale targeting: the content agent writes for a segment the targeting agent no longer uses.
  • Missing provenance: nobody knows which agent produced which asset, or why.
  • Open loops: results come back, but nothing feeds them into the next cycle.

The individual agents look fine in isolation. The system underperforms because nothing connects them, and no single agent's test suite can reveal that. The failure lives in the spaces between steps.

Why the task view misleads

Task-level evaluation asks whether an output was good. It is the right question for a single agent, and it is a misleading one for a program. An email can be well written, on brand, and accurate, and still be the wrong email for this customer at this moment.

The task view also hides cost. If a strong draft requires a person to gather context by hand, chase approvals, and copy results into another tool, the agent saved less time than its output suggests. The work moved to the seams, where nobody measures it.

The orchestration view treats the whole run as the thing to design, test, and improve. That includes the handoffs, the waiting, the review, and the feedback into the next plan.

What an orchestration layer does

An orchestration layer, which we call an Agentic Hub, sits between the people who set direction and the specialist agents that do the work. It has five jobs.

  • Plan: break a goal into tasks and decide their order and dependencies.
  • Route: send each task to the right specialist agent or person.
  • Hold shared context: keep one source for the brief, audiences, approved facts, and decisions, so every agent works from the same material.
  • Enforce approvals: track the state of each piece of work and make sure required reviews cannot be skipped.
  • Keep a run log: record each run, decision, and outcome, so results can feed the next plan.

You can see how these pieces fit together in our Agentic Hub architecture diagram. The hub coordinates, and it does not produce work itself. Content, analysis, and outreach stay with the specialists, and goals and guardrails stay with people.

A worked example

Consider a hypothetical team launching a webinar series with three agents: one researches topics, one drafts promotional emails, and one builds paid social ads. Run as separate tools, each produces solid work.

The research agent finds that the audience cares most about integration costs. The email agent, working from last quarter's brief, leads with ease of setup. The ad agent targets a segment that sales retired a month ago.

Every output passes its own review. The campaign still sends a mixed message to partly the wrong audience. Afterward, nobody can trace why, because each agent's log lives in a different tool.

Now run the same agents under an orchestration layer. The research findings go into shared context, and the plan ties the core message to them. The email and ad agents read the same message and the same current audience definition. Approvals happen in one place, and the run log ties each asset to the plan that produced it.

The agents did not get any smarter. The system did, because each agent now starts from the same facts and every result has a place to go. Our post on the Agentic Hub pattern walks through a fuller version of this setup.

Orchestration changes what you measure

When the unit of work is a single agent, teams measure task quality. When the unit is the orchestrated system, the questions widen, and we suggest asking them at the end of each campaign.

  • Outcome: did the campaign meet its goal?
  • Handoffs: where did work stall, get rejected, or lose information?
  • Review load: which step consumed the most human review time?
  • Learning: what did this cycle teach the next plan, and did the next plan use it?

These are harder questions, but they are the ones that connect agent work to business results. They also depend on having a run log, since you cannot answer them from scattered tool histories. Our post on observability for marketing agents covers what that log should contain.

Start small, but design for the system

You do not need a full orchestration layer on day one. You do need to design individual agents as if they will be orchestrated later, because retrofitting is expensive. In practice that means a few habits.

  • Clear inputs and outputs: give every agent a defined input and output format.
  • Logged runs: record each run with its inputs, outputs, and decisions.
  • Shared facts in one place: keep approved facts out of individual agent prompts.
  • Explicit handoffs: define what passes between steps, as we describe in designing agent handoffs.

Teams that follow these habits can connect their agents into a working system without starting over. Teams that skip them often find that each agent must be rebuilt before it can share context with the others.

What we are studying next

We are studying where the orchestration boundary should sit as programs grow. A small program may need only a shared plan and a run log. A large one may need a dedicated planner, a router, and a formal state model.

We want to understand which of these pieces should come first, and what signals tell a team it is time to add the next one. Our orchestration run diagram shows the full cycle we are using as a reference.

How to apply this: map one campaign end to end and mark every point where information passes between people, tools, or agents. Those handoff points are where orchestration will either add value or lose it, so start your design work there.

Related research

Put this research to work

Marketix turns these patterns into software: agents, automated workflows, and a hub that keeps people in control. Sign up for early access.