Humanfia

Appearance

Humanize 2 — the runtime ​

One flow, ten coding agents, and a timeline of everything they did. Humanize 2 drives the coding-agent CLI you already log into, in the order a flow asks for, and writes the whole run down as it happens. It is the layer every other project on this site stands on.

pip install git+https://github.com/humanfia/humanize2.git

Into the environment you are already in.

Python ≥ 3.12 · drives the coding agent CLI you already log into · no API key of its own

The installation guide ↗Where flows come from ↗GitHub ↗

  1. 01
    Check it landed

    One binary, no service, no key of its own.

    hmz --version
  2. 02
    Log into an agent you already have

    It drives your CLI under your own subscription. Any one of ten will do.

    claude auth logincodex login
  3. 03
    Run a flow

    A published flow, several agents, and a trace of everything they did.

    hmz exec -f official/flame_chase

One flow, many agents, one trace ​

A flow is a directory of Python that says which agents it drives, what each is asked, in what order, and when to stop. The runtime opens the sessions, takes the turns, puts the work where it is meant to land, and records it.

The recording is the part people underestimate. Every turn's tool calls go onto one clock — every agent, every sub-agent, and every program those turns ran — and come back out as a Chrome trace you open in Perfetto. On an eleven-hour run that is the difference between knowing what happened and believing what the last message said.

stoppedhmz exec -f official/flame_chase
claude/claude-opus-5:highwrites the kernel
turnEditturn
8.3k tok
codex/gpt-5.6-sol:highreads what landed
Bashturnturn
12.2k tok
dsh/deepseek-v4-pro:highruns the benchmark
turnBash
15.7k tok
kimi/kimi-code/k3:highports the module
turnturnEditBash
13.8k tok
4 agents · 33 slices on screen · one track per row of an agent's sessions. Every turn's tool calls land on the timeline as they are made; the real one opens in Perfetto.

What it does ​

The deep end

The five worth reading even if you never install it.

The anchor

The agent runs here. Its syscalls land there.

Every syscall the agent makes is decided one at a time — replayed on another machine, or answered on this one. It is told none of it.

Accounts

Two accounts of one CLI

A CLI signs in once. Humanize runs it as an account it was never signed into, by answering the paths it opens with other paths.

Tracing

One timeline

Every agent, every sub-agent and every program those turns ran, on one clock, in one document you open in Perfetto.

Steering

A line typed mid-turn

It goes into the turn that is running. Not queued behind it, and never quietly counted as said.

Shapes

Answers in a shape

A turn given a pydantic model answers with that model. The model is the whole of the question, and the answer is read back through it.

The shape of a run

Backends

Ten CLIs, one agent

Ten coding agents and anything speaking the Agent Client Protocol, each driven through whatever it actually offers.

Flows

A flow is Python

A loop, a subprocess call, a file read between turns. The agents are its arguments, and the shapes a loop takes are few.

Concurrency

Many turns at once

Turns are sequential only inside one session. Two hundred conversations are two hundred turns.

Resuming

Picked up where it stopped

A loop meant to run for a week is a loop that will be stopped. What it was keeping track of survives; the conversation does not.

Who is at the other end

Goals

It decides when it is done

The backend's own goal feature: a turn that would have ended starts another, until the model says the objective is met.

The person

You, as one of the agents

A flow asks a person the same way it asks a model — which is how a human stays the architect rather than the bottleneck.

Everything else

Twelve pages, one picture each

Hooks, remote execution, providers, containers — a page and a diagram apiece, on the documentation site.

The agent runs here. Its syscalls land there. ​

The anchor is the piece we would point at if we were only allowed to point at one. A seccomp-filtered ptrace supervisor sits between the coding agent and the kernel, and decides every call it makes: replay it on the target, or answer it on this machine.

There is no plugin, no configuration and no cooperation, because the agent is never asked. It opens a file; the file it gets is the target's. It runs pytest; the process is the target's, in the target's working directory, reaching whatever the target reaches. It reads its own credentials, and those are answered here.

this machine

The agent, and what it is not told

claude · codex · dsh · … unchanged, and told none of this

  • credentials
  • state
  • the model provider

answered here

syscalls

supervisorseccomp filter · ptraceevery call decided one at a time
  1. openat("kernel.cu")the agent
  2. write("kernel.cu")the agent
  3. execve("pytest")the agent
  4. connect("pypi.org")pytest
  5. connect(the model provider)the agent
  6. openat("~/.claude/…")the agent

the target

ssh · docker · tcp · a pipe

hmz anchor serve

  • files contents, renames, modes — the target's own errors
  • processes everything the agent spawns, in the target's cwd
  • the network whatever those commands reach

replayed there

No plugin, no configuration, no cooperation — the agent is told none of it, because it is not asked. Reads come out of a local mirror at local speed, and the mirror and the target are kept in step. How it works, syscall by syscall ↗

Twelve layers, one direction ​

The reason the runtime can drive ten different CLIs without becoming ten different products is that the layering is a rule rather than an intention: everything points downward, nothing points both ways, and a test fails a build that bends it.

Everything points downward and nothing points both ways. A layer may name only what is under it — and not all of that: the table of exactly what each one may reach is tests/test_layering.py, which fails a build that bends it. The whole tree, and the exemptions ↗

Where the flows come from ​

The runtime runs flows; it does not decide what a good flow is. That is deliberate, and it is the seam the whole of Humanfia is built along.

Flows live in a flowverse — a directory of Python that anybody can read, fork, publish or beat. The three that ship are there alongside the loops the field already converged on, so comparing a method against another method is a flag rather than a reimplementation. Which of them is actually better is FlowBench's question, and the answer is allowed to delete ours.

Flowverses ↗ · humanfia/flowverse ↗ · FlowBench

What it is not ​

It is not a model. We do not train one, serve one or resell one.

It is not an API client. Humanize 2 holds no API key and talks to no model provider. It drives the CLI you already log into, under your own subscription, the way you already log in. The frontier moves every few weeks; a wrapper around one vendor is the least durable thing we could build.

It is not a coding agent. It does not replace claude or codex — it takes turns on them. If a better one ships next month, it is a name in a list.

Permissions

Humanize runs every agent with permission prompts disabled, and nothing turns them back on. Read Security ↗ before pointing one at a repository you care about.

Where to go next ​

Install it

The installation guide ↗

Prerequisites, the three ways in, which backends count as available, and how to check.

Learn it

The guides ↗

Concepts, loops, containers, remote execution, providers, hooks — how do I use this.

Look it up

The CLI reference ↗

Every command, key, flag and Python call, in one place.

Read it

humanfia/humanize2 ↗

The source, Apache-2.0. Issues and pull requests are the fastest way to reach us.