Oracle

Your agents stop making the same mistake.

Oracle figures out how to make your agent better on your project, and checks that it worked.

The problem

Told to use what your project has, the agent uses it. Left alone, it builds its own.

Given clear direction, the agent does the work right. It just doesn't remember the direction, so you give it again every session.

Tested from both sides

Does the right reminder fix the work, and can Wardens tell when it's needed?

Given the reminder, the agent plans the right thing.

The reminder starts as a correction Aron gave. On tasks from our template project, given his correction with its reason before it planned, the agent produced the right fix 4 of 4 times.

A bare hint, such as the name of the right file or a nudge to search first, made two of those cases worse. The reason has to come with the reminder.

Wardens catch most of the moments that need one.

Wardens are small agents in Foundry, each holding what one part of your project already has. In the latest full test, on 2 November 2026, they caught 82% of the moments that called for a reminder (93 of 114), and spoke up wrongly on 2% of the rest (29 of 1,350).

These numbers are early. They come from our template project, on the same tasks the Wardens were tuned on.

How Oracle does it

Oracle learns from the work you have already done.

Tests that run a full agent are expensive, up to a million tokens for a single plan, so Oracle chooses which to run, with cheap checks first and full runs only where they decide something.

  1. It rebuilds your past work. From the sessions Archive keeps, and your tickets, threads and pull requests in Linear, Slack and GitHub, reached through Kingdom: what was asked, what the agent did, where it went wrong, and what you corrected. Foundry records each correction with what the agent was doing when it was given.
  2. It turns that into tests. Each test hands the agent a real task from before the work landed. What you merged is the answer key. Cheap tests ask only whether the right Warden spoke up; the full test lets the agent build in a sealed copy of the repo.
  3. It tries changes against them. Changes to your docs and to what each Warden knows, each made in the one place that owns the mistake. A change ships only when it does at least as well as what it replaces, on the same work; Oracle drops the rest.
  4. It holds some work back. About one piece of work in four is set aside and never tuned on, so Oracle can tell a real gain from one that only fits its own tests.
  5. It watches for the same correction. If you give the same correction again in a later session, the change did not stick, and Oracle goes around again.

Where it stands

  • Running on inixiative's own projects.
  • Oracle, the Prospector included, is closed source.
The Prospector

Oracle's harvester.

When work lands on main, the Prospector reconstructs what went into it: the ticket, the pull request and its reviews, the agent sessions that built it, and every correction given along the way. It keeps that as a log of what happened, and Oracle will build its tests from it.

It also works out which parts of the codebase each piece of work touched, and sets aside about 1 in 4 pieces of work for each part as a held-out set that tuning never reads. Every report splits the two. If results on the held-out work fall behind results on the work used for tuning, the tuning is overfitting, and the gap shows by how much.

Where it stands
  • Built: the log, which links each piece of finished work to its ticket, pull request, reviews and the agent sessions behind it, and the held-back share. Reading Slack comes later.
  • Over 30 days of sessions, 508 of 646 corrections were matched to the work they belonged to. The matching was tuned on those same 30 days.
  • No test reads the held-out set yet, so there is no overfitting number. The first check on work the Prospector has not seen is due after 18 November 2026.
Why not a skill

A skill adds to your agent's context, and context runs out.

Writing your project's lessons into skills works while there are few of them. Each one adds to what your agent carries, and the more it carries, the less of it the agent uses well.

Foundry splits what your project knows across Wardens, each holding one part, and only what applies to the moment reaches your agent. Each Warden stays small: in Foundry's tests, a Warden holding about 20,000 tokens caught 90% of what it should, and one holding 80,000 caught 67%.

Oracle tunes that split: what each Warden holds, and where one part ends and the next begins.

Foundry

How Oracle's changes reach your agent today.

Foundry is the workspace around Claude Code and Codex, free to use and source-available. Its Wardens remind your agent of what your project already has and where it's written down, on every turn. When Oracle changes a doc or a Warden, Foundry carries that change into your next session.

Waitlist

Run Oracle on your project.

Join the waitlist to hear when Oracle opens to other projects, with the results as they come in.