Foundry

Stop repeating yourself to Claude.

The voice of your project.

Coding agents keep writing their own versions of what your codebase already has. Foundry is the workspace around your agent: Claude Code and Codex, and agent apps such as Paseo and T3 Code that speak the Agent Client Protocol (ACP). What you've already decided reaches every session.

Illustration of a neon-lit workshop at night: a glowing blue wireframe structure rises over a ring of workbenches, screens and machines.
The problem

Every session starts half-amnesiac.

You pay a re-alignment tax: you explain your conventions, your past decisions and your taste again. The model is outside your control, and so is the harness it runs in.

Your docs, your rules and your CLAUDE.md are the one layer you control. Foundry is a tool for controlling it.

The bet

Told the right thing, the agent does what you want.

The bet is that your corrections compile into docs that tell it automatically. In early runs, when Aron's corrections reached the agent before it planned, the plans came out right. Oracle runs the loop that tunes those docs.

The longer version is the essay The Real Problem With AI Coding Isn't Capability. It's Alignment.

What it does

What it does today.

  1. Stop repeating yourself to Claude.

    What you've already decided reaches every session. Foundry splits what your project knows across small agents called Wardens, each holding one part. When your request touches a Warden's part, it reminds your agent what already exists and where it's written down. Wardens never block; your agent decides what to use.

    Wardens are built from your repo's docs, one per topic. They are off on a fresh install. Turn them on per project with "chorus": { "enabled": true } in the repo's .foundry/project.json, or with the project's Chorus switch in Foundry's settings. Repos built from template ship with their Wardens built and turned on.

    Watch it in the demo
  2. Every agent you pay for, in one place.

    Claude Code and Codex on your own subscriptions. Each thread picks its worker, and every session is captured.

What's next

In progress.

  1. Stop being a meat proxy.

    Your agent, their agent and the people in one thread, hashing out the work.

    Hosting a shared thread worksThe view for people who join is in progress
    Watch it in the demo
  2. Illustration of a Herald: a silver-haired runner with winged boots leaps across a neon city skyline, holding a staff toward a glowing antenna dish.

    Stop checking a dozen apps.

    Whatever comes in (a Slack DM, a review request, an email) reaches you already researched and in context. It's read as data, so it can't instruct your agent.

    In progress
    Watch it in the demo
  3. Set up your repo.

    Foundry reads your repo and builds the docs and Wardens.

    In progress
How Wardens work

Each Warden holds one part of what your project knows.

Foundry splits your docs and code by topic and gives each topic to one Warden. A Warden speaks up only when your request touches its topic, and makes sure your agent is reminded of it. Repos started from template come with their Wardens built. Building them for any repo is in progress.

Illustration of a Warden: an armoured guard in a long black coat stands at a red, hexagon-patterned firewall gate, holding a long rifle.
  1. You ask in plain words. In Claude Code, Codex or an Agent Client Protocol app, the way you already work.
  2. Wardens notice what it touches. Each one checks whether the request is in its part of your codebase.
  3. They remind your agent of what exists. The primitive, the pattern, and the doc section where it's written down. They never block.
  4. Your agent decides. It builds with that in view, on your machine.
Working in Foundry

From install to a correction that sticks.

The rest of working in Foundry, in the order you meet it.

  1. Install it beside the agent you use. One command installs the daemon. You work in Foundry's own window, or keep working in an agent app such as Paseo or T3 Code. Until you turn something on, your messages reach Claude Code or Codex exactly as you typed them.
  2. Turn on the Wardens for a project. Wardens come from the project's own docs, one small expert per topic. Repos started from template come with theirs built; building them for any repo is in progress.
  3. Give each task its own thread. Each thread runs on the worker you pick, Claude Code or Codex with the model and effort you choose, on your own logins. A thread can move to another worker partway through and carries on from its record. Subagents show up as threads under the one that started them.
  4. Correct the agent once. /feedback records a correction with what was happening at the time, so it can go into the docs every later session reads.
  5. See what you keep repeating. Every session is kept in Archive on your machine, and foundry repeats lists the corrections you give again and again.

What it lets you do

  • Stop re-explaining your conventions at the start of every session.
  • Run every agent subscription you pay for from one place, a thread at a time.
  • Keep a full record of what your agents did, on your own machine.
  • See which corrections stuck and which keep coming back.
Runs on your subscription

It runs on your subscriptions, with no API key.

Foundry runs on your machine and uses the Claude Code and Codex logins you already have. Every session runs in the real harness, on your own subscription. Kingdom can hold those logins for you and give each project its own pool.

License

Source-available, and MIT in April 2030.

Foundry is under BSL 1.1. It is free to use, including at work. You may not resell it. It becomes MIT in April 2030. The core engine and the ACP adapter are MIT today.

Thanks to UserEvidence for supporting open-source software.

Foundry comes in three parts.

Source-available
  • FoundryBSL 1.1The app and its daemon.
  • foundry-coreMITThe engine underneath.
  • foundry-acpMITLets other agent apps, such as Paseo and T3 Code, use Foundry over the Agent Client Protocol (ACP).
Run it

Install it with one command.

Requires macOS (the daemon is a launchd agent), Bun 1.4.4 or later, and Claude Code logged in (claude). For a Codex worker, also codex login. The local Archive runs on Docker.

$ bunx @inixiative/foundry-acp setup

This installs Foundry and foundry-acp, runs the daemon, prints the settings for Paseo and T3 Code, and ends with foundry repeats. Then open http://localhost:4500.

From source:

$ git clone https://github.com/inixiative/foundry.git
$ cd foundry && bun install
$ bun run setup
$ bun run start