In detail the short version is on the Foundry overview

Nobody on a good team types code anymore.

Someone defines the outcome. Agents write, test and review the code. A person looks at what is risky. The Foundry is the ecosystem that makes that work in a real business — your company mapped as a Business Genome, nine stages from idea to production, and nothing shipped without evidence from the Eval Harness.

9 stagesIntake to backpropagation
9 gate checksNothing ships unproved
Yours to runCode, tests and traces stay with you
How good teams ship

Typing code was never the hard part. It was just the slowest part.

Someone defines the outcome. An agent writes the code. The build system compiles and tests it. Specialist agents review it for data, infrastructure and security, and classify the risk. Low-risk changes deploy automatically. High-risk ones wait for a human.

Dark boxes are where a person leads: defining the outcome, and looking at what is risky. Everything else runs on its own.

The conversation is the work

Defining the outcome is not a form to fill in. It is the same back-and-forth you would have with a good colleague, with the agent researching, drafting and pushing back. That hour is the most valuable one in the whole process.

The bottleneck moved

Producing code is now cheap. What is expensive is knowing what to build, knowing what correct looks like, and knowing when to stop. The Foundry is built around those three questions.

Why it goes wrong

Point fifty people at fifty agents and you get fifty pull requests a day that nobody specified.

Nobody evaluated them and nobody fully understands them. That is slop, and it compounds. Four gaps cause almost all of it.

Gap 01

No definition of done

The agent optimises for "the tests pass" or "the user stopped complaining". Nobody wrote the real outcome down, so nobody can check against it.

Gap 02

No review gate

Every change is treated as equally risky. Either everything gets waved through, or everything queues behind one senior person.

Gap 03

No shared context

Each person's agent rediscovers the codebase, the conventions and the business rules from scratch. The tenth internal tool does not know the first nine exist.

Gap 04

No feedback loop

Sessions run and get thrown away. The same failure happens in every team every week, and gets fixed forty times in forty ways.

The model was never the problem. The missing system around it was.

What it costs

Most companies can see the bill. Very few can see what it bought.

The companies that make the models earn money when you consume tokens, so every default points at more of them: the biggest model pre-selected, reasoning set high, sub-agents spawning sub-agents, five retries. Our incentive is the opposite — the fewest tokens that produce a correct outcome.

What you have today

Telemetry

Which model ran, how many tokens it used, what it cost. Useful for a finance review, useless for a decision: it says nothing about what problem you paid to solve.

What the Foundry adds

Attribution

The task, the outcome and the cost together: a bug fixed, a question answered, a feature shipped. Never exact — one session can serve several tasks — but a rough answer per task beats an exact answer per token.

Until a company can say, even roughly, what its token spend bought, it is not running an ecosystem.

The structure

Use the model for intelligence. Build the structure yourself.

The model is very good at reading, reasoning, writing and fixing. It has no idea how your company works, what your risk appetite is, which systems are load-bearing, or what a good outcome looks like for you. The structure supplies what the model cannot.

The model is one box. Everything around it is structure your company owns — anchored to your Business Genome.

Signal in, outcome out

Every piece of execution enters as a defined signal and leaves as a defined outcome. Conversation belongs upstream, where the outcome is being worked out.

Routing

A router that knows your organisation decides which task gets which model, which environment and which permissions. Your people never see the menu.

Context and skills

Conventions, business rules and tooling captured once and distributed everywhere. Which skills exist and who approves them is an organisation question, not a model question.

The commodity underneath

Sandboxes, a control plane, an agent runtime. The value is in fitting them to how your organisation actually works. That fitting is the work.

Business understanding

The Genome is the context. The MRI is how we get it.

The Foundry is only as good as what it knows about the business. Before any signal is triaged or any requirement written, we run the Business MRI and turn its findings into your Business Genome. Everything upstream reads from it and writes back to it.

Every requirement cites the Genome node it belongs to and the number it is meant to move. A requirement that cannot name either is not ready to build.

What the MRI produces

  • The nine business functions, traced across seven end-to-end processes
  • Where the work actually hurts, with volumes and cycle times
  • The decisions your people make, and on what criteria
  • Systems, data and documents each process depends on
  • The KPIs the business already watches

What the Genome gives the Foundry

  • Intake knows which process a message belongs to
  • Triage can tell a bug from a change to an existing promise, against a real map
  • Requirements inherit the rules, the actors and the KPI baseline
  • Blueprints know which systems are load-bearing
  • Skills are business rules captured once, so the next build inherits them
Week 1–2

Run the MRI

Working sessions with your function owners. Volumes, cycle times, decisions, systems, pain. Nothing is designed yet.

Week 2–3

Build the Genome

Findings become a structured map: processes, systems, rules, KPIs, owners. This is the context every agent will read.

Week 3–4

Pick the first loop

One signal-in, outcome-out loop with a number attached. It proves the line and pays for the next one.

The production line

Nine stages, in two halves.

In the first four, people think it through with an agent: the person leads, the agent researches, drafts and pushes back. From work orders on, agents do the work and people hold the gates. The last stage runs backwards and reopens the conversation.

Foundry Sense

Ideate and design, stages 01–04. Your people lead; the agent researches, drafts and pushes back.

Foundry Deliver

Develop, deploy, support and enhance, stages 05–09. Agents do the work; your people hold the gates.

01 · Intake

Everything your team hears, in one place

Customer calls, support threads, sales notes, meeting notes, the idea someone had on the walk in — each tagged to the Genome process it touches. Anyone can add. Nobody decides anything here.

02 · Triage gate

Every input gets a call and an owner

The agent proposes: a bug, a change to something you already promised, a new promise, or noise. Your product owner pushes back until the call is right and has a name on it.

03 · Requirements gate

What the product must do

Each requirement cites the conversation it came from, the Genome node it serves and the KPI it should move. Where two inputs contradict each other, the draft says so instead of quietly picking one.

04 · Blueprint gate

How it will be built

The technical plan, drafted from the requirements. Each part says which requirement it serves and which systems it touches. A working session with your technical lead, not a sign-off.

05 · Work orders

Agent-sized pieces of the plan

The blueprint is cut into work orders an agent can finish in one sitting, each carrying its part of the plan and the requirement behind it. Your lead reorders, merges or drops them.

06 · Build

Agents, in your repository

An agent takes a work order and opens a pull request. If what it built changes the plan, it updates the blueprint in the same pull request. Your engineers review it as they would any other.

07 · Verify

Evidence, not a green check

The Eval Harness runs the checks each requirement names. The result attaches to the work order: what ran, against which version of the requirement, and what it found.

08 · Review and accept gate

The human gate

Every proposal, from a triage call to a code change, waits for a person. The Foundry shows what will change and why. It never applies anything on its own.

09 · Backpropagation

The loop that keeps the rest honest

Change a requirement and every plan and work order built on it is flagged. Ship code that departs from the plan and the plan's owner sees it. The Genome is updated so your documents describe what you actually have.

StageThe agentThe person
Foundry Sense — ideate and design
01–02 Intake and triageCollects and tags every input; proposes the call and shows which requirement and Genome node it touches.Product owner, in conversation
03 RequirementsDrafts, cites its sources, surfaces contradictions, plays back changes.Product owner writes them with the agent
04 BlueprintDrafts the technical plan and keeps it tied to the requirements.Your technical lead, the same way
Foundry Deliver — develop, deploy, support, enhance
05–06 Work orders and buildCuts the plan into work orders and opens pull requests in your repository.Engineers review pull requests
07 VerifyRuns the Eval Harness and attaches the evidence to the work order.Lead decides which checks a requirement needs
08 Review and acceptShows what will change and why. Applies nothing on its own.The owner of that stage
09 BackpropagationFlags everything downstream of a change and updates the Genome.One inbox: still valid, or redraft
Autonomy

How much Deliver is allowed to do on its own.

L1

Suggests

The Foundry proposes; a person does the work. Used on anything new until the evidence exists.

L2

Acts with approval

The Foundry prepares the change in full; a named person presses go. Most work sits here.

L3

Acts within limits

Runs unattended inside agreed thresholds — value, volume, blast radius — and escalates outside them.

L4

Runs unattended

Only for low-risk, well-evidenced loops with a proven rollback. Reviewed, not assumed.

One rule holds the whole line together: nothing moves to the next stage without naming what it came from — the conversation, the requirement, the Genome node, the number it should move.

Eval Harness

Our testing product. Stubs for the parts, scenarios for the whole.

Verify is where most teams wave things through. The Eval Harness is what turns "the build is green" into evidence a business owner can read. It ships with every production line and stays with you afterwards, as your own regression suite.

Mode 01Unit testing

Stubs

A stub stands in for anything the code depends on — an ERP, a bank portal, a model, a colleague's service — and answers exactly as the real thing would, including on its bad days.

  • Recorded from real responses, then frozen, so tests don't drift with the outside world
  • Failure modes on purpose: timeouts, partial data, wrong formats, rate limits
  • Runs in seconds on every change, with no live systems touched and no data leaving
  • Pins the contract: if a supplier changes a field, the stub test fails before your users do
# stub: supplier invoice API, 3 recorded shapes given invoice.pdf (scanned, 2 pages) when extract_fields() then total = 48,230.00 ✓ currency = MYR ✓ confidence < 0.8 → route to review ✓
Mode 02System testing

Scenarios

A scenario runs a whole business journey end to end, the way your team would describe it, and checks the outcome the business actually cares about.

  • Written in business language from the Genome, so the people who own the process can read them
  • Covers the awkward cases: partial shipments, disputed invoices, missing certificates, month-end
  • Measures outcome, cost and time per run, not just "no errors"
  • Every production incident becomes a new scenario, so the same failure can't return
# scenario: export shipment, EU buyer given order + certificate claim + logs from 2 concessions when documents are generated then invoice, packing list, CoO, DDS all agree ✓ claim matches certificate scope ✓ prepared in < 10 min, < ₹20 of model cost ✓
The gate

Nine checks. A change passes, or it doesn't ship.

How hard the gate is depends on the risk class of the change. Low-risk work flows through on evidence alone; anything that touches money, customers or compliance waits for a person.

CheckQuestion it answersEvidence
FunctionalDoes it do the job described in the requirement?scenario pass rate
AccuracyIs the output right against an agreed benchmark?scored golden set
IntegrationDoes it call the right systems, the right way?stub contract tests
SecurityCan it reach only what it's allowed to?permission + injection tests
SafetyHow does it behave on ambiguous or hostile input?red-team suite
RegressionDid this change break anything that worked?full suite on every change
PerformanceIs it fast enough at real volume?load run
CostWhat does one transaction cost to run?cost per run vs budget
Business impactDid the number the requirement named actually move?before and after, from the Genome
What you end up owning

The second build is faster than the first, and the fifth is faster again.

Nothing about your business is rediscovered. It is looked up.

Model and tool independent

Each task runs on the model and platform that suit it. Swap providers without rebuilding business logic — the tests prove the swap is safe.

Everything in code

Requirements, blueprints, skills, stubs, scenarios, gates and routing rules are all versioned. "Improvement" is measurable, not a feeling.

Traces you own

Every session is stored, queryable and attributable to a task. You keep the code, the Genome, the Eval Harness, the traces and the data.

How we start

Three stages. Each one pays for the next.

Stage 01

Attribution

A task taxonomy, sensible routing and a one-page view of what your tokens bought — by task, not by model. Bills tend to fall once someone can see them, and we learn what your company actually does with agents before we build anything.

2–4 weeks
Stage 02

The Foundry

Business MRI, Genome, the loops that matter, the skills captured, the gates set, the Eval Harness standing up, the traces yours. Fitted to your processes, defined in code, handed over with your people trained to change it.

8–12 weeks
Stage 03

Running it

Most clients ask us to keep operating it. Regulated ones take it in-house outright. Either way the Foundry stays theirs, and what we charge is tied to outcomes rather than hours.

ongoing
Where we differ

Most tools start at the ticket. We start at the business.

AI coding platforms

Great at producing changes

They turn a ticket into a pull request. They don't know your processes, and they can't tell you whether the outcome was right for your business.

Consultancies

Great at the roadmap

Slides, target operating models and a plan. Then the building, testing and running is someone else's problem.

Doing it in-house

Full control, slow start

Method, gates, stubs and reuse take a year to get right. We bring them on day one and hand them over.

Already have four AI engineers moving fast?

That is the right start, and it is not slop. It is also where the wall is: each tool is understood by the one who built it, the fifth doesn't know the first four exist, and when one of the four leaves, their tools go quiet. The Foundry is how the four compound instead of accumulate.

Start here

Bring us one problem worth fixing. We'll show you the line that fixes it.

We don't just build software. We build the system that builds it, and the evidence that says it works.

Talk to us →