EMBER

The problem

Most multi-agent systems are flat: a pool of workers and a dispatcher. That works until something goes wrong, and then there is nowhere for the problem to go. A worker that cannot finish its task has no one to escalate to, no one who can decide the task was wrong in the first place, and no one who can change the plan rather than retry it.

Real companies solved this a long time ago. They did not solve it with a queue. They solved it with a hierarchy, where authority to make different kinds of decisions sits at different levels, and where "I cannot do this" travels upward until it reaches someone who can act on it.

What was built

An orchestration framework that models a software organisation as a role hierarchy: CEO, CTO, Product Owner, Project Manager, Architect, Team Lead, Developer, plus QA and DevOps. Work decomposes downward. Failure escalates upward.

The name is short for Embrace Failure, which is the thesis: retry, escalation and checkpointing are not error handling bolted on afterward. They are first-class objects in the domain model, because in a system of fallible agents, failure is the normal path rather than the exception.

Git checkpointing sits underneath it, so a branch of work that goes wrong can be rolled back to a known state rather than unwound by hand.

Why the hierarchy is the point

A flat agent pool forces every decision to the same level. A hierarchy lets the kind of decision determine who makes it: a developer agent retries, a team lead reassigns, an architect changes the approach, a product owner questions whether the work should happen at all. That is not organisational cosplay; it is a routing structure for decisions of different scopes, and it falls out of the same reasoning that produced the org chart it copies.

Where it stands

In progress. Seventy commits, and worth being precise about how they landed: sixty-two of them arrived in one unbroken run of eight hours and thirty-nine minutes, with no gap between consecutive commits longer than thirty minutes. That run was driven by an autopilot loop of my own, the framework and the thing building it converging on the same idea.

The architecture is elaborate and the execution layer is still thin: the role hierarchy, escalation model and checkpointing are designed and encoded, but no task, agent or checkpoint has been persisted through a full production run yet. It is a structure waiting on its engine.