Features
humanize runs flows: directories of Python that drive one or more coding agents in a loop and write down everything they did. Most backends drive a coding agent you already have under its existing login; the bundled DeepSeek Harness is the SDK-backed exception.
This section is what the system is rather than how to operate it: the unusual parts drawn, one map over all of them, and a page for each mechanism worth pushing on. Nothing here is a command — the guide that runs it is one click from every diagram.
To install it and run something, start on the home page, which has a quickstart for running a flow, weaving one and working on humanize.
A run, as it happens
One flow, many agents, one trace. Every turn's tool calls land on the timeline as they are made — every agent, every sub-agent and every program those turns ran, on one clock. Hover a lane; change how many agents are on it.
claude/claude-opus-5:highwrites the kernel0 tokcodex/gpt-5.6-sol:highreads what landed0 tokdsh/deepseek-v4-pro:highruns the benchmark0 tokkimi/kimi-code/k3:highports the module0 tok4 agents · 0 slices on screen · one track per row of an agent's sessions
A simulation of the shape of a run, not a recording. One timeline is how the real one is built.
What it does, one picture each
One flow, many coding agents
agy · claude · codex · cursor · dsh · grok · kimi · mimo · opencode · pi · qwen · zcode
Typed mid-turn, into the turn
Not queued behind it. It reaches the agent that is working.
Trace a run on one timeline
Reconstruct the agents and programs, then inspect them together in Perfetto.
Its work lands elsewhere
An ssh host or a container of its own. The agent is told nothing.
Answers in a shape
A pydantic model in, a field out — no paragraph to parse.
Two accounts of one CLI
Your subscription and somebody else's endpoint, in one run.
Picked up where it stopped
A loop stopped on Thursday carries on from its own record.
You, as one of the agents
A flow asks a person the same way it asks a model.
The agent runs here. Its syscalls land there.
A seccomp-filtered ptrace supervisor decides every call the coding agent makes, one at a time. No plugin, no configuration, no cooperation — the agent is told none of it.
lands on the target Read out of the local mirror at local speed. The mirror and the target are kept in step.
How it works, syscall by syscall: The anchor. What you are deliberately not entitled to: its reference.
How the capabilities fit together
A run crosses five systems: the flow that describes the work, the control plane that drives agents, the fabric that decides where work lands, the record that keeps it continuous and readable, and the surfaces people start and inspect it through. Hover a group to read the guarantee it owns.
5 systems, 19 capability groups. Hover or focus a group for its core guarantee; open it for the closest explanation.
The complete map adds the boundaries, related guides and reference for every group: Capability map.
Feature deep dives
Each takes one mechanism far enough that its trade-offs make sense, around a diagram you can push.
Flow system
| Python becomes a prophecy | A deliberately narrow flow becomes a typed graph that can be checked, compared and resumed node by node. |
| A flow is Python | Ordinary Python and compiled atlases live side by side, chosen by how much of the work must be knowable before it runs. |
| Many turns at once | Turns are sequential inside one session; concurrency comes from having several conversations to run. |
| Picked up where it stopped | Ordinary flows preserve explicit state; atlases preserve completed node visits. Neither recreates a conversation. |
Agent control plane
| Many backends, one agent | Native servers, streaming CLIs and Agent Client Protocol backends meet one session contract. |
| Two accounts of one CLI | Credentials, model catalogues and failure chains stay isolated while a session changes where it runs. |
| A line typed mid-turn | Acknowledged queues put guidance into the turn that is working rather than behind it. |
| A turn can be cut off | A per-turn cap on tokens or clock, read off the live meter, ends the turn that is running. |
| Every run has an allowance | Hours, millions of output tokens and dollars, held to at every session edge, stop the whole run. |
| Answers in a shape | A pydantic model is both the question and the contract the answer must satisfy. |
| It decides when it is done | A backend-owned pursuit loop continues until the model settles the objective. |
| The moments of a turn | Typed lifecycle moments let a flow react without teaching the backend about the flow. |
| You, as one of the agents | Questions, the mission board and a person-shaped agent put human decisions on the same run. |
Execution fabric
| The anchor | A local agent can work against a remote target while paths, processes, networks and ownership keep their meaning. |
Run continuity and observability
| The terminal can leave | A workspace daemon owns the PTY, so watchers may disconnect and return without owning the run. |
| One timeline | Agent events, sub-agents and sampled processes are reconstructed on one calibrated clock. |
Product surfaces
| One system, four ways in | Local discovery, schema-driven setup, Python, CLI, TUI and the daemon all reach the same run and session model. |
The flows it comes with
A ralph loop and a stateful one, two agents alternating, an actor with a reviewer between its rounds, a loop the model itself decides is over, and isolated lanes under a coordinator. Each has a page with its own loop played on it.
Every one of them, with the shape of each: Flows. What a weaver writes to add another: Writing a flow.
Where to go next
Before you point one at a repository you care about
humanize runs every agent with permission prompts disabled, and nothing turns them back on. A flow is trusted Python: loading or running it may execute its code, even though static checks can inspect selected structure without doing so. Read Security.