Engineering runs in a loop: design it, write it, ship it, see it, understand it, diagnose it. Every tool you own covers one arc and knows nothing about the others, so you carry the context between them by hand.
We are moving that loop onto one substrate an agent can read, one arc at a time. Seeing and understanding are already there.
| ergo framework | actors, supervision, clustering | 01 | |
| ergo.tools | scaffolder, argus, saturn | 01 | |
| ergo.observer | ui and mcp — see it, ask it | 02—03 | |
| ergo.engineer | /devops and /architect | 04—06 | |
| ergo.cloud | stage and production | 07 |
Ready-made design patterns on the actor model. A small stateful process is the unit — arrange them and you have a business process, not a diagram of one.
And because every part is an actor under supervision, the system has a structure a machine can read. That is what the six steps after this one stand on.
Nodes, processes, connections, mailboxes and events, live. You look at what is happening now instead of assembling last night out of log lines.
Over MCP, Claude — or any agent that speaks it — inspects the cluster itself, in conversation. It answers about the business layer, not only heap and CPU: which orders are stuck, on which peer, for how long.
You stop describing your system to the model — though you are still the one asking.
This is where the ecosystem crosses into autonomy. One agent watches the runtime, the logs, Grafana and the source at once, and reacts to an incident without being asked.
It rebuilds what happened and what is still happening, and maps the behaviour back to the code that causes it.
What arrives is a root cause and a proposed fix — in Slack, Telegram or Jira.
Four levels: how domains talk, how services talk inside a domain, how components talk inside a service, and the actors underneath. Each level is the same drawing — a Gantt across time crossed with a sequence across participants.
The drawing is the specification code is generated from, and changes in code come back into it, at every level.
The architect generates the implementation itself and reflects edits back into the design, at every level.
You keep intent and the review gate. Nothing else needs a person to carry it from one tool to the next.
Stage and production without leaving the browser you designed in. The moment it ships it is runtime again — which is where step 02 picks it up.
From here the loop turns without you inside it.
Everything between them is work the loop can carry. That is what the seven steps add up to — not seven products, but seven jobs that stop needing a person in the middle.
Three steps ship today: the runtime, live observability, and an agent that reads the running cluster — the whole understanding half. The acting half is drawn and not yet built. If you think this is where engineering is going, come and build it with us.