runfoundry Write to Marcel on LinkedInWrite on LinkedIn

Foundry: my test-first loops for AI coding agents

I decide what gets built. Agents build it, and plain code checks it.

On Navigo Bau (construction-site documentation), from the run records

  1. 1 Nov 2026Bau's new front end in production, 9 days after the first run of the UI loop, foundry's predecessor.
  2. 13 Nov 2026Foundry's first run from plan to merge: one requirement in 101 minutes, $5.19 at API prices. The run record
  3. 11 to 19 Nov 202615 build runs, 9 merged, 14 requirements on main, about $220 at API prices. Two merged themselves.

I'm Marcel Bierbauer-Szigeti, co‑founder and CTO of Navigo Intelligence. I built foundry, my own project, so that what a customer says in a meeting ends up as tested, merged code, with agents doing most of the work. If it breaks in production, that's on me.

  1. Goal in
  2. Plan bay
  3. Gate one
  4. Build bay
  5. Check bench
  6. Gate two
  7. Into production
  • G1
  • G1.F1
  • G1.F2

Plan A goal becomes a plan and stops at gate one until it's approved.

Fig. 1 One run, step by step Each bar on the check bench is one acceptance test. The lamps are the checks.

  • Yellow I decide
  • Dashed Planned, not built
  • Blue edge A round is running
  • Green and red A check result
  • Pale box A finished task, frozen
  • Red frame and arrow Blame points at a task

What it has built

The UI loop, before foundry

The UI loop rebuilt the front end of Navigo Bau, which documents construction sites, in eleven runs from 23 October 2026, and it has run in production since 1 November. I'd promised the customer it would be intuitive. The day after it went live was his two-year guarantee inspection. The room was full, and I sat next to him while he clicked through it as if he'd been trained on it. Its tasks, run by run, are drawn on the design page.

Foundry on Navigo Bau

I built foundry because I was spending my days restarting and steering agent sessions instead of deciding what to build. I started it on 1 November 2026, the day the new front end went live. I build everything with Claude Code sessions, and foundry was no different: design notes first, code two days later. Its first build run on Bau started on 11 November, and the first one to merge two days after that. That one was small: one requirement and four short builder rounds, two of them fixes from the review.

Fig. 2 Two real build runs, as their records tell it From the run records, redacted to numbers. Read the 13 November record
13 November: one requirement15 November: four requirements
stop reason done: merged after I approved it (back then, gate two was the merge itself). checks-red: three requirements built, three resumes, then one flaky test in the product's CI. I merged its work by hand two days later, with one test of mine added: the existing ones didn't catch a deliberately broken line.
wall time 101 minutes, plan to merge 597 minutes
rounds 13: planner 1, test writer 1, builder 4, blame 4, reviewer 3 46: planner 1, test writer 9, builder 13, fixer 2, blame 14, reviewer 7
time while working same minute scale 88 minchecks 73 min agents 15 minThe rest: 13 minutes at the two gates (gate one under a minute, approved for me by a Claude session; gate two 12 minutes, by me). 397 minchecks 319 min agents 78 minThe rest: 177 minutes queued behind the other run of that day, 17 minutes waiting for me, and about 6 minutes of the foreman's own steps (rooms, pull request).
cost $5.19 at API prices $19.40 at API prices

What surprised me most: the agents were the fast part and the checks the slow one. That was partly my own design, since every feature check ran the product's whole unit suite.

Foundry's runs on Bau, November 2026

Build runs started15, from 11 to 19 November
Runs merged9. Two merged themselves (all checks green and no open review point, the rule is code). I approved two myself, one at a terminal and one through my answer to a judge question. A Claude session approved the other five, under a standing go-ahead from me.
Runs stopped6: four by me (their branches predated fixes to the test setup), two on red checks
Resumes by hand22 in all, none in the last three runs
Requirements on main14: twelve through their run's own merge, two through my hand merge of a stopped run's pull request
Requirements set aside2, in one run, so the rest could merge. I narrowed their text, and the next run built them.
Tasks119 reached a verdict: 94 green after the builder's round, 14 after one fixer round, 11 blocked
Judge calls9: four decisions, four facts, one question for me. I haven't overturned or confirmed any yet.
Fixes after a mergeNot tracked yet. I know of none from the first week on one product.
Cost at API pricesAbout $220 for all 15, and $5.19 to $38.70 per merged run. That's a floor: a round that hit its turn limit and failed recorded no cost.
Discovery runs8, from 6 to 19 November: recorded customer calls and documents in, claims, questions and draft requirements out, $2.46 to about $250 each at API prices. They run on foundry's runner scripts, not under the foreman.

What the runs showed

What went wrong

How one run goes

A run takes a batch of approved requirements. A plain program, the foreman, gives each job to a fresh agent session (a round) and checks what comes back. It writes no code itself. Each run gets a throwaway virtual machine on my own homelab, destroyed when the run ends. When a round finds a gap in a requirement, a judge round fills it with the option that's easiest to undo, or asks me.

  1. Plan

    A planner splits the batch into features and tasks.

  2. Gate one: the plan is approved

    By me, or by a Claude session under my go-ahead, and tied to a hash of the plan's text.

  3. Test first

    A test writer writes acceptance tests that fail before anything is built, or says why one is already met.

  4. Build, then check

    A builder takes one task, the foreman runs its tests, green freezes it, red goes to a fixer.

  5. Feature check

    On a red acceptance test, blame reopens only the task at fault, then a reviewer reads the feature.

  6. Goal check

    A reviewer reads the whole run, then the full suite and the product's CI run.

  7. Gate two: I approve the release

    A clean run has merged itself and reached dev; I read its report and decide on production.

Read the role sheets: builder, test writer, judge. The full design: checks, guards, what each round gets, and how a run ends.

Where I decide

Foundry has three loops, and each stops for me. Discovery turns recorded customer conversations into draft requirements (the eight discovery runs above), and I approve each one. Build is the run above, with its two gates; on Bau a Claude session approved every plan and five of the merges under my go-ahead (what that means). In UAT, personas use the whole app before a release, and a normal release waits for their report (a soft block, hotfixes exempt).

My co-founder records the customer calls. The loops themselves are my own work. The three loops, the judge and the overseer, in full

Laneboard

Laneboard is where I watch foundry: the runs, the gates and every Claude Code session in lanes, with an inbox of things waiting on me. Loop runs built it too.

Fig. 3 A plan at its gate Laneboard's demo: the shop and every name are invented
About 15 seconds, no sound, repeats

A plan waiting at gate one. Laneboard calls a plan a recipe.

Open the recording: video, new tab

Work with me

I'm open to forward-deployed and applied-AI roles. Foundry is my own project, and Navigo's products use it.

If you're hiring for that, or you'd like to try a run on your own product, write to me on LinkedIn.

If you bring a product

It needs a GitHub repository, tests, CI and a profile with its install, build and test commands. Every real build run has been on one product, one stack and one model provider: Python (FastAPI) and TypeScript (Next.js) on PostgreSQL, with Claude. You'd still approve the requirements, each plan and each release yourself.