Simone Consumption Engine

How can AI agents use what a project already knows?

Consumption Engine is my main research project. I build and test ways to preserve project sources, carry relevant evidence into an agent's task and revisit work when its sources change.

A public synthetic example is available to run; the Consumption Engine runtime remains private research software in development.

What is the consumption problem? Why I am building this.

Watch the recorded exampleRun the public fixtureDiscuss the research

How it works

Carry the source
into the task.

Local software preserves selected documents, finds source passages and prepares context that an agent can inspect while working. This workflow is still in development across separate implementations.

  1. 01

    Preserve

    Keep originals and source identity.

  2. 02

    Find

    Select relevant passages and their conditions.

  3. 03

    Apply

    Use the evidence in a concrete task.

  4. 04

    Check

    Assess the output against the task.

  5. 05

    Retain

    Keep useful work, failures and corrections.

Explicit checks can detect changed or missing declared sources. Choosing indispensable evidence and deciding whether it supports a conclusion still require review.

A source-to-task example

Illustrative example: updating a project's engineering guidance.

  1. Select. An operator chooses the documents and required passages. The agent requests the material relevant to its task.
  2. Receive. The local tool returns selected passages with source identity, locators and qualifications. Explicit checks can refuse changed or missing declared material.
  3. Act and check. The agent uses that context to propose an edit. The output still needs task-specific checks and substantive review before it is retained for reuse.

The hypothesis is that this preparation can make recurring work easier to inspect and correct. It must be tested against a capable agent using the same sources and tools, with preparation and review included.

One correction, made visible (no setup required)

The source changes.
The old answer needs a check.

Before installing Python, you can inspect the recorded correction lifecycle directly in your browser:

  1. Input. A service runbook declares a retry limit of 3. An earlier answer relies on that snapshot.
  2. Correction. The runbook is revised from 3 retries to 2. The earlier snapshot is refused when the task runs again, while its original receipt stays in history.
  3. Resulting answer. A successor run reads the updated source, answers 2 retries, and records its own check.

The browser cutaway steps through those recorded values. Technical readers who want to verify the lifecycle locally can run the separate public Python fixture.

Explore the recorded exampleRun the Python fixture locally

In a real project

Used in the Baldies remake

I used Consumption Engine in one of the two earlier prototypes behind the Baldies remake. That prototype decoded the original level files and used a disassembler; the engine supplied source-linked context that carried disassembled values, such as the house-capacity table, into that prototype's data tables.

The Baldies remake running: a generated grass-world level in project-made pixel art, with a red-roofed house, trees and a few small figures.
The remake running in its browser edition, which generates its own levels.

The problem. There was no original source code. Design data such as house capacities existed only inside the 1995 program. One prototype was written from public specifications without decompiling the executable; the other decoded the level files and used a disassembler for data tables.

What the engine supplied. In one prototype, notes worked out from the original files were kept with their sources, and the engine delivered them as context to the AI coding agent writing that prototype's data tables (Baldies verification record). Values such as the house-capacity table reached those tables this way.

The result. I combined the two prototypes into the remake. It uses the first prototype's Python simulation, and its house capacities match the second prototype's table.

Limits: This is one use, in one prototype. It does not show that the engine made the remake faster or better, and the engine does not run in the browser game.

  1. 01Source notesValues worked out from the original files with a disassembler
  2. 02Selected contextThe engine supplies those notes with their sources
  3. 03Data tablesValues such as house capacities land in the prototype's tables
  4. 04Combined remakeThe remake's house capacities match that table
How disassembled values reached one prototype's data tables.

Play the remake on the homepageHow the remake was madeBaldies verification record

The original level files are not published, so the playable browser edition generates its own levels.

Where the project stands.

Reviewed October 7, 2026

What runs
Local prototypes preserve selected source documents, return passages with references and prepare task context with explicit source checks. Implementation and local results.
What the studies showed
On a synthetic project, task-only builds passed 0 of 38 house-rule checks and library-assisted builds passed 34 to 38 of 38; on 37 real-repository tasks (222 builds), library tools (49.0%) and a compiled guide (48.8%) did not beat the ordinary workflow (53.8%). Results and evaluation conditions.
What you can run
A public synthetic Python fixture exercises a correction, stale-work refusal and restored history. It is separate from the private runtime. Run the public fixture.
What is next
Reliable benefit on new tasks under qualified comparisons, including preparation, execution and review effort. Next research question.

Read the current research brief

Evidence

Research results and runnable examples

Dated reports preserve each experiment's methods, outcomes and limitations. The public fixture is a separate runnable package.

Summary of measured Consumption Engine studies and scope boundaries.
Evaluation Sample & Conditions Measured Outcome Scope Boundary
Synthetic house-rule benchmark 38 house-rule checks (104 total), 5 builds per arm 0/38 task-only vs 34–38/38 with library tools Synthetic project; whole-corpus prompt matched compiled guides on small corpus
Sept 24 local demo 9 hand-annotated synthetic cases, deterministic client 2 emitted (3 to 2 retries), 6 refused, 1 retained Manual annotations, private runtime, same-machine guarded replay
Sept 30 generation & manual reuse 2 CS336 policies generated; 2 retained ordinary procedures reused across 6 batches 2/2 generated per arm (21,103 prepared vs 11,151 ordinary reported prompt-plus-generation tokens); 6/6 manual reuses correct (0 model calls for dispatch) Retained procedures came from the ordinary-source arm; manual dispatch; 0 autonomous run_skill calls; no net end-to-end savings measured
Oct 7 real-repository study 37 real tasks x 3 arms x 2 builds (222 builds) 53.8% ordinary vs 48.8% guide & 49.0% library tools Partial-check scores; prepared context did not beat ordinary workflow

Latest reported work

Teaching an AI agent a project's rules.

Given only the task, agents passed 0 of 38 house-rule checks on a synthetic project; with source-linked library tools they passed 34 to 38 of 38. On 37 real-repository tasks (222 builds), a compiled guide (48.8%) and library tools (49.0%) did not beat the ordinary workflow (53.8%).

Read the latest findings

Local ingestion and useful assisted work

Selected documents can be preserved, indexed and delivered as source-linked context. Local studies include successful manual procedure reuse and unsuccessful agent-selection and maintenance comparisons.

Read the September 30 findings

A public synthetic replay

The public package checks a recorded correction, stale-snapshot refusal, preserved history and archive replay in a fresh directory. Other expected refusal states are manually specified in its oracle projection.

Run the fixture and inspect its scope

Earlier repeatability and recovery checks

The one-hour fixture receipt records 60 cycles of four cases, with zero failures. It was not a load test.

The September 24 local demonstration also retained a same-machine restore.

Next research question

Make reuse useful
on the next real task.

Evaluate a concise briefing of current facts, decisions and next steps against ordinary source reading, including preparation and review effort.

I want to measure supported task completion, correction handling and total effort against a capable ordinary workflow, with preparation and review counted alongside execution. Read the current development status.

Research discussion

Evaluate on a collection

Public artifacts: the synthetic fixture and dated research reports. Private research code: the local runtime and study receipts. To discuss the research, email me.

Supporting research

Research contributing to Consumption Engine

Preservation and retrieval provide the source foundation. BigBoss explores human approval for agent actions, Council explores claim review, and SEED supplies evaluation methods. These are distinct projects; completed integration is not implied.

File details on this page

Format, size and a short SHA-256 identifier, measured when this page was built.