The agentic process as an event-driven system

I’ve stopped thinking of the agentic development process as a pipeline of stages and started treating it as software architecture: a set of services exchanging messages, with humans taking part in the same model.

Each stage is defined by what it consumes and what it produces, rather than by who performs it. Refinement reads the PRD and produces stories, design reads both and produces a plan, and build turns the plan into code. Every stage has a contract that its downstream consumer defines, checked structurally by schemas and references, and semantically by a judge that has to cite evidence.

Messages come in three kinds. Events are facts in the past tense, like StoriesPublished or ItemChanged, broadcast to whoever cares. Commands ask one addressee to act and expect an outcome event back. Data travels by reference, so a message carries an artifact ID and version while the artifact store holds the content, and nothing works from a stale copy. Each message also carries a correlation ID, the PRD version and a hash of its parent artifact versions.

An agent’s contract is its message interface: what it subscribes to, what it reads, what it may publish and the shape of its output. Publication rights define responsibility. Only the product owner agent publishes StoriesPublished, and only the intent authority publishes a new PRD version, with the platform enforcing both.

Agents react to events directly, so no orchestrator needs to know the whole flow. A thin coordinator handles the global concerns: gates, human approvals and escalations, staleness bookkeeping, loop limits, and routing findings to the stage where the drift entered. Pure choreography gets hard to reason about at around ten interacting agents, and the coordinator keeps the global invariants without owning the workflow.

Agents don’t produce the same output twice, which changes the usual distributed-systems playbook. Work is deduplicated on the hash of parent versions, every retry is stored as an attempt with one promoted through the gate, and feedback loops are capped so two agents can’t ping-pong forever. Failed or unroutable messages go to a dead-letter queue with an owner, and low-confidence judgements get escalated instead of passed through.

Change is where the design pays off. When intent changes, an ItemChanged event marks every artifact that traces to that item as stale, and each owning agent decides whether its artifact is unaffected, needs revising or needs regenerating. Most come out unaffected. Agents never edit the PRD, only propose amendments with evidence, and a human approves them.

Take a small case. The product owner agent finds R-3 ambiguous while writing stories and asks for clarification, the coordinator sends a command to the intent authority, and the human’s answer is published as a new PRD version. Artifacts tracing to R-3 go stale, the owners run their impact checks and the held stories resume. The human is a subscriber like everyone else, and the audit trail is complete because that decision sits in the same log.