Normally this is four people: one writes the spec, one checks the design, one builds it, one reviews it. Agentum hands each job to an agent and runs them as phases the server tracks. It doesn't stop to ask what's next. You start it once, walk off, and come back to a change that's already been through review.
Clarifies the spec into checkable acceptance criteria.
Validates the design and writes it down before any code.
The verify gated feature loop builds each item, one at a time.
Reads the change, raises concerns or signs it off.
Every gate green. A human stop is opt in, never the default.
The agent gets exactly one feature. It writes the code, stops, and verify.sh runs. Green? Locked in, on to the next. Red? The failing output goes straight back to the agent, which tries again until it passes or hits max_retries. A shell script calls it done, not the model's mood.
max_retries. Green, done, hand off, next feature.Agents need a home that survives a closed laptop. Agentum picks the boring, proven one: tmux. The agent lives in a session on a machine you keep, the repo holds the state, and shutting your lid touches neither. You leave; it keeps working.
Each agent gets its own named tmux session. Close the lid, switch machines, drop off Wi-Fi, it keeps thinking. Reattach later and you land right where it left off, scrollback and all. No reconnect dance, no lost work.
Give Agentum any machine that stays on, a cloud VM, an old desktop in the closet, whatever's handy, and it SSHes in and sets it up for you: tmux, git, the agent CLIs. After that the loop runs day and night, and you look in over a tunnel from wherever you are. Nothing to install on the remote, no ports left open to the world.
The daemon speaks an HTTP/WS API behind rustls TLS and a bearer token, and the live pane streams over WebSocket. For browser work, a host-resident Chromium is watched live via a CDP screencast tunnelled over ssh -L. You watch, steer, and unblock an agent from a coffee shop. Your keys and code never leave the host you own.
One idea each, and how Agentum actually pulls it off. Read them in order or jump around. Start the course →
A bigger model doesn't fix it. The failures are structural.
Read →Six stages, one loop. Walk through each one.
Read →PM, architect, developer, reviewer. All agents, all automatic.
Read →If it isn't committed, the next session can't see it.
Read →One giant AGENTS.md rots. Keep the entry file short.
Read →Continuity is a file you write, not memory you trust.
Read →Build and check the world once, before any feature.
Read →One feature at a time keeps the diff reviewable.
Read →Make "done" something a script can actually check.
Read →The gate decides done, not the agent.
Read →Unit tests pass; the seams still break. Run it for real.
Read →An agent that can't see the runtime debugs blind.
Read →End every run committed, tidy, and handed off.
Read →Agentum is the harness, packaged: one Rust binary that spawns Claude, Codex, Gemini and friends in tmux, keeps them running when you close the lid, and lets you check in from anywhere.