agent processes · a worked example

A simulation of one run

One run of the social campaign process, played from start to finish. The left column is the process document doing its job: phases light up when their after: lines are satisfied, every record lands under the phase that produced it, and the run-scoped lane fires on its own clock while the pointer is elsewhere. The right side shows the inside of whichever phase is active, drawn in the same language as the simulations on agentcollab.dev and agentworkpatterns.com, which are the patterns the phases convene.

the process

How a social campaign gets made

Each box is one activity: its name, what happens in it, and who does it. The arrows show what waits on what. Once the parameters are set, producing the posts and setting up the practical side run at the same time, and both have to finish before launch. The amber box is where people sign off, and the dotted arrows point backwards: a sign-off can send work back for changes, and an ad that has gone stale sends the team back to produce new assets. The dashed frame holds the work that keeps going for as long as the campaign is live.

The Social Campaign Process

flowchart LR
  T(["a campaign brief arrives"]) --> IN
  IN["1. take in the brief
work out what it must accomplish
manager"] --> PAR
  PAR["2. set the parameters
platforms, audience, dates, budget
manager · leadership on budget"] --> CRB
  PAR --> PRC
  CRB["3. brief the creatives
say what is needed and by when
manager · creative team"] --> DIR
  DIR["4. settle on a direction
weigh concepts until one is worth backing
manager · creative team"] --> PRO
  PRO["5. produce the posts
copy, images, video, sized per platform
copywriter · designer · video editor"] --> SGN
  SGN["6. get sign-offs
brand and legal approve the material
manager · brand · legal"] --> GO
  SGN -. "changes requested" .-> PRO
  PRC["7. set up the practical side
tracking, landing pages, ad setup, schedule
manager · media buyer · web team"] --> GO
  GO["8. launch
posts go out, the ads start
manager"] --> WATCH
  GO --> ENG
  GO --> OPT
  subgraph FLIGHT["while the campaign is live"]
    WATCH["9. watch performance
track results against the brief
manager · analytics"]
    ENG["10. engage
answer comments and messages
manager or community manager"]
    OPT["11. optimize
move ad money, swap stale creative
manager · media buyer"]
  end
  OPT -. "needs new assets" .-> PRO
  WATCH --> WRAP
  ENG --> WRAP
  OPT --> WRAP
  WRAP["12. wrap up
ads off, numbers pulled, reported
manager"] --> LRN
  LRN["13. record what was learned
what to repeat, what to avoid
manager"] --> DONE(["the campaign is closed"])
  classDef act fill:#0F1D22,stroke:#6BA8FF,color:#E7EFEC;
  classDef gate fill:#151a14,stroke:#F2A93B,color:#E7EFEC;
  classDef ends fill:#0b1220,stroke:#4A5D5A,color:#7C918C;
  class IN,PAR,CRB,DIR,PRO,PRC,GO,WATCH,ENG,OPT,WRAP,LRN act;
  class SGN gate;
  class T,DONE ends;

drag the diagram sideways, or scroll inside it, to see the whole graph

where this is going

From a process run by people to a process run by agents

Everything in the diagram above is done by people today. Writing the process down this precisely is what changes that. Once the activities, the handoffs and the sign-offs are on the page, an organization can hand them to agents one activity at a time — drafting the copy long before anyone lets an agent confirm a budget — and each activity that moves keeps working the same way, because the process says what it waits on and who has to see the result.

The agents that take this work on are a fleet: a copywriting agent, a design agent, an analytics agent, often built by different vendors. They work together the way the people did. They meet in rooms and follow the collaboration patterns on agentcollab.dev, an activity the size of a whole job follows a work pattern from agentworkpatterns.com, and their messages travel over AgentMesh, which stores and forwards them so an agent that is offline gets its messages when it comes back.

The common vocabulary is what makes a fleet possible. Two agents that have never met can run a briefing, a bake-off or an approval together, because each pattern says who speaks, who decides, and what record is left behind. The record is also what lets a person check the work afterwards, which is how an activity earns its way up the automation ladder.

The simulation below plays one run of the process as it works today, with people in every seat. Legal asks for changes partway through, and later a stale ad sends the designer back for fresh images — the two backward edges from the diagram.

The process document this run followed, and the records it left behind, are on the social campaign page.