Skip to content
← All posts

Blog7 min read

HumanfiaFrom a Review Loop to Four Layers and a Referee

How Humanfia went from a July launch, an agent workflow for serious L3–L4 development, to a four-layer system of agents, a runtime, flows and applications, plus FlowBench, whose best flow becomes the default.

Software agents are becoming capable enough to do more than complete isolated coding tasks. The next challenge is not simply stronger models. It is building a workflow that can carry an idea through architecture, implementation, independent review and refinement without losing human intent.

In July we introduced Humanfia, an open-source effort focused on agent workflows for serious L3–L4 software development. It connected careful human-agent alignment, a workflow-native terminal agent, and a disciplined build-review loop. A month later the shape of the work had changed enough to be worth redrawing. This post tells both halves: the idea as it launched, and the four layers and a referee it became.

Build with agents, in a humanized way.

Why workflows matter ​

A capable model can write a function. A capable development system must do much more. It has to understand a repository, preserve constraints, use the right tools, validate its work, incorporate external review, and continue until the actual acceptance criteria are met.

That system should not remove the human from the process. The human remains the architect, defining intent, evaluating tradeoffs, and deciding what "done" means. Agents provide execution leverage inside that contract.

From first idea to final implementation ​

The workflow we launched with had four stages, and the last two go round until the work is done.

Idea → realization · four stages
Shapethe planExecutebuilderReviewsecond modelRefine to done

Swipe the diagram sideways to see all of it →

1/0 Shape the idea: a rough direction becomes an explicit plan, with constraints and acceptance criteria. The human owns it.

Two open-source foundations ​

As launched, the workflow rested on two pieces.

Feedback loop

RLCR Flow

The disciplined loop. Claude implements, Codex independently reviews, and review findings cycle back into implementation. The human stays responsible for the plan and the final decision.

Model peer-review

The model that built the code should not be the only model judging the change. In RLCR Flow, we recommended Claude as builder and Codex as reviewer.

Beyond general software: Kernel Design Agents ​

The same workflow architecture can be specialised for high-value domains. KDA, Kernel Design Agents, applies iterative generation, benchmarking, review and refinement to produce optimised kernels at scale.

This is where agent workflows become more than coding assistance. They become repeatable production systems, able to explore many candidate implementations while preserving measurement, correctness checks and human oversight.

Then and now ​

The launch promised to keep improving the workflow primitives, to strengthen model peer-review, and to publish what we learned from long-running development tasks. Much of that has since been built and measured. Drag the divider to see what became of each piece.This comparison was added in October 2026.

Humanfia, July → October 2026Drag to compare
July: promised
#In July
1Execution: oh-my-humanize, our own agent
2The loop: RLCR Flow, Claude builds, Codex reviews
3Review: a second model, recommended
4Domains: KDA
5Measurement: "publishing what we learn"
October: built
#By October
1Execution: Humanize, driving your CLIs
2The loop: humanize1, RLAR and more flows
3Review: any CLI, fresh every round
4Domains: KDA, HOA and HMA
5Measurement: FlowBench, ranking flows

What changed ​

The July version of Humanfia was a coding agent with a good workflow inside it. Building it taught us something inconvenient: the workflow was the valuable part, and putting it inside a binary was the worst possible place to keep it. You cannot read it, you cannot fork it, you cannot publish yours, and, the one that actually hurt, you cannot measure it against somebody else's.

So we retired the terminal agent and took the workflow apart along that seam, keeping it outside any one agent.

The loop became a flow: a directory of Python that says what each agent is asked, in what order, and when to stop. The thing that runs it became a runtime that drives whichever coding-agent CLI you already log into, rather than replacing it. And because flows are now comparable objects, we could finally do the thing we wanted all along: find out which ones are actually better.

The layers ​

Here is the whole of it in one picture.

Humanfia · four layers and a referee
12 CLIs · ACP · a personcoganchorCLIs · accounts · anchorRuntimeengine · envs · tracehmzTUIdaemonSDKhumanizeFlowsbuilt in · flowverseApplicationsHOA · KDA · HMAFlowBench

Swipe the diagram sideways to see all of it →

1/0 The agents: twelve coding-agent CLIs, any ACP agent, and a person, each on a login you already have.

The agents. Twelve coding-agent CLIs, including Claude Code, Codex, Antigravity, Grok Build, Kimi Code, Qwen Code, pi and opencode, plus any agent that speaks the Agent Client Protocol, and a person at the keyboard, who can take a role like any agent. Each CLI is driven through the interface it already serves, and runs on its own sign-in or on an account you add. The frontier moves every few weeks, and the wrapper around one vendor is the least valuable thing in this picture.This section was updated in October 2026 to match humanize as it is today: more backends, the flows that now ship built in, and the runtime's real layers.

Humanize, the runtime. Humanize is one layer in two halves. The lower half, coganchor, is the only part that knows how to drive a CLI: which backend a role is, which account it runs as, which machine its turns land on, where a turn goes when that place cannot take it, and what its tokens cost. Nothing above it reaches past it to a driver.

The upper half opens and resumes sessions and takes turns in the order a flow asks for. It puts work in a container, on another machine over SSH, or across a swarm when it should, and writes the whole run down as it happens, so it reads back as a timeline. The command line, the terminal interface, the daemon that keeps runs alive after a terminal closes, and the Python SDK are all ways into that one runtime, not copies of it. Its documentation is at humanfia.ai/humanize.

Flows. The flows: RLAR, Flame Chase, Ralph loop and the other loops built in, humanize1, and every flow the flowverse lists. The loops everyone already uses are kept alongside ours, so that a comparison is a flag rather than a reimplementation.

Applications. HOA for olympiad mathematics, KDA for GPU kernels and HMA for machine-learning engineering. Each was chosen because the scoreboard belongs to somebody else.

Why the benchmark is a layer and not a report ​

FlowBench sits alongside the stack rather than on top of it, and the arrow that matters is the one going back up.

There is a well-known trick where you start a fresh session every turn, so nothing carries over and the agent cannot talk itself into a hole. Everybody has heard of it. Nobody has published what it is worth. Ask how much better it is than holding one session, on a task that takes a day, at a given model, and the honest answer is a shrug and an anecdote.

That is the state of the entire field of agent methodology, and it is unusual. Imagine compilers with strongly held opinions about loop unrolling and no benchmark suite.

So the method becomes the variable and everything else is held fixed. The tasks are long enough that the loop matters more than the model, and the scoring is done by something real rather than by another language model asked to be a judge. The flow that wins becomes a default. The flow that loses gets deleted, including ours.

A benchmark that ranks things is a scoreboard. A benchmark whose winner becomes the next default is a flywheel.

That last clause is the whole design. It means our opinions have to survive contact with a number, every time.

FlowBench is not released yet. When it is, the first thing published will be the numbers for the flows on this site, whether or not they flatter us.

The part that keeps us honest ​

The applications are not demos. They are the reason any of this is trustworthy.

Every layer below them can be evaluated with numbers we chose ourselves, and numbers you choose yourself have a way of going up. A Lean 4 kernel does not care what we intended. A contest deadline does not care. A public leaderboard does not care. So far that has produced all six IMO 2026 problems formally verified, all 672 of PutnamBench, and top-three placements on every track of the MLSys 2026 FlashInfer kernel contest with MIT HAN Lab.

They are also where the hard tasks come from. A benchmark assembled from a domain nobody works in decays into a puzzle collection within a year. Ours is assembled from work we were doing anyway.

What is next ​

FlowBench, released.

With the first cross-flow numbers.

More flows.

Including several that only exist because a trace showed us where an eleven-hour run went wrong.

More applications.

On the same rule: somebody else keeps the scoreboard.

Everything is at github.com/humanfia. The projects are open source, and we welcome builders who believe the future of software development should be both more automated and more intentional. If you have a loop you think beats ours, we would genuinely like to see it. That is the entire point of publishing the ones we have.

The goal is not to hand software development over to agents. The goal is to give agents a better workflow, and give humans a better way to direct them.

Read next

BlogFlow Science: A New Dimension of Scaling AgentsModels scale with parameters and data, and agents scale with tools; the next dimension is the flow. Why one flow cannot solve every problem, flow-level ablations on four benchmarks with the models held fixed, four findings we did not expect, and whether a flow is engineering or a science.Read it BlogKDA²: Kernel Design Agents (KDA) Optimize Kimi Delta Attention (KDA)Our agents wrote Kimi Delta Attention kernels that run up to 2.96× faster than FlashKDA on B300 with a tenth of its state error. Here is how, and how the agents tried to cheat along the way.Read it BlogRLAR: The Review Is the Next PromptTwo small decisions inside RLAR changed how long-horizon runs behave: the reviewer's words go to the actor verbatim, and "done" is read off a field rather than a sentence.Read it