Intake
PAY-412PAY-412 arrives from the tracker. It is sized, given a track and a human owner, and logged in the ledger.
EILAID is a methodology and open toolkit for building and growing large software projects with AI agents, with engineers in the loop.
npx eilaid initProduct illustration with sample data: EILAID Mission control for a demo Payments workspace. A board shows work moving through the loop: Shape, Gate 1, Build, Verify, Gate 2 and Merged. Agents build in parallel, engineers approve at the two gates, a live ledger records every claim, answer and approval, and a budget meter tracks spend for the day and the cost per merged item.
Designed to work with the tools you already use
01The methodhow work flows
Why EILAID
Most teams hand agents one ticket at a time. Each one starts with no context, works with no awareness of the others, and forgets everything when the session ends.
Without EILAID: five agents each work alone in their own corner. Two of them reach for the same file and collide, two carousel libraries get added, the same question is asked again, and context is lost when each session ends. Project memory drains.
With EILAID: the same agents work in orderly lanes, each connected to a shared Ledger and to the Oracle. Leases prevent collisions, the Oracle answers with citations, handoffs and learnings are saved, and project memory fills up.
Each session starts empty, with whatever someone pasted in.
Agents edit the same files and add the same library twice.
Decisions and answers vanish when the session ends.
The loop
Every work item runs the same eight steps. The process is sized by track, so a one-line bug never pays for an epic's ceremony.
Normal feature work. A Shaper drafts the brief, and an engineer holds both gates.
PAY-412 arrives from the tracker. It is sized, given a track and a human owner, and logged in the ledger.
The EILAID loop has eight steps: Intake, Shape, Gate 1, Build, Verify, Gate 2, Merge and Learn. Gate 1 and Gate 2 are human decisions made by an engineer; agents do the steps in between, and failed checks in Verify loop back to Build. In Learn, the system turns review notes and failures into rules, tests or context, and the item's owner approves each one. Patch work skips Shape and passes Gate 1 automatically when a failing reproduction exists. Epics add an Architect who splits the work into Features that run in parallel.
Agents
Seven personas, each with its own tools, context and output. Need another? Your team writes one as a markdown file.
Implements one approved brief, test-first, inside its declared footprint. Several run in parallel, each in its own git worktree.
Three Builders run in parallel, each in its own git worktree: PAY-412 partial refunds, PAY-512 image gallery and BILL-38 queue worker. The PAY-412 Builder works through its plan: claim a lease on src/api/refunds.ts, write a failing test, implement, run 12 of 12 tests green, commit, open draft pull request 1842 and hand off to Verify. The ledger shows five items in flight and no collisions.
Researches the codebase, asks the Oracle, drafts the brief.
Shaper drafting the brief for PAY-512, image gallery: goal, three acceptance criteria ticked, context files attached, ready for Gate 1.
Writes the spec for an epic, then splits it into features that run in waves.
Architect writes the spec for epic BILL-37, invoice queue, which passes its spec gate, then splits it into three features. BILL-38 queue worker and BILL-39 retry policy run in parallel in wave 1. BILL-40 admin view depends on the queue worker, so it runs in wave 2.
Writes the failing reproduction first, then the checks that prove the fix.
Tester on AUTH-221, session refresh: writes six failing reproduction tests, including a concurrent refresh race; once the fix lands in pull request 1851 all six pass.
Reviews every diff against the brief. Can run on two vendors at once.
Reviewer reads the PAY-412 diff on two vendors, leaves one comment and sends the change back to Build automatically.
The night shift: dependency bumps, flaky tests, stale docs, re-indexing.
Steward at 02:00 bumps dependencies, fixes a flaky test, refreshes stale docs and rebuilds the Oracle index, batched into one morning review.
Answers from the project's own knowledge, with citations. Unsure means it asks a human.
Oracle answers 'Any precedent for a swiper library?': none in use, standards allow a small well-documented package, Swiper fits, lazy-load it. Three citations above the 0.60 threshold: docs/standards.md#dependencies, apps/shop/package.json and decisions/0007-frontend-bundle-budget.md.
A persona is a short markdown file: instructions, tools, budget and context. Commit it, review it like code, and the loop can schedule it on any runtime.
Example persona file personas/accessibility.md with name accessibility, tools read, edit, a11y and oracle, a 20 minute budget, context AGENTS.md, the brief and tokens.md, and instructions to check each changed view against WCAG AA. eilaid doctor validates it, the feature track schedules it in the Verify step next to the Tester and Reviewer, and it loads on Claude Code, Codex, OpenCode or a custom runtime.
Runtimes are adapters. Pick Claude Code, Codex, OpenCode or Custom per persona in config.yaml, with a fallback.Models and runtimes
Models & runtimes
Every persona picks its own runtime and model, with fallbacks for when a vendor is down. Frontier where judgement matters, fast for chores, local when nothing may leave your network. No vendor lock-in.
Interactive configurator. Each persona (Builder, Reviewer, Tester, Shaper, Steward, Oracle) picks a runtime (Claude Code, Codex, OpenCode or Custom) and a model tier (Frontier, Balanced, Fast or Local), or start from a preset: Max quality, Balanced, Lean or Air-gapped. Use the arrow keys to choose within a group. The config.yaml preview and the illustrative cost per merged item update as you change them. A silent auto-demo cycles the presets until you focus a control.
If a vendor is down, each persona falls back to another runtime and the next tier down.
# .eilaid/config.yamlpreset: balancedpersonas: builder: runtime: claude-code model: frontier reviewer: runtime: [claude-code, codex] model: balanced tester: runtime: claude-code model: balanced shaper: runtime: custom model: fast steward: runtime: claude-code model: fast oracle: runtime: custom model: fastfallback: # when a vendor is down runtime: codex model: next-tier-downnetwork: { egress: allowed }The Oracle
Drop in context files in whatever form you have them. Agents ask in plain English, mid-task, and every answer cites its sources. Anything the Oracle can't answer goes to an engineer, once.
An interactive demo of the Oracle. Pick an example question. The Oracle expands it with the asker's task, files and related terms into several search queries, retrieves the nearest passages from the project's indexed context, and writes an answer only from those passages, with numbered citations. When confidence is low, the question is routed to the owning engineer, and their answer is saved to context so the next ask is instant.
Every context file is split into passages, each gets a line of context, then it is embedded and stored. Re-runs on every merge.
A short question is widened with the asker's task, files and related terms, then written as several queries, not one.
Nearest passages from every query are merged, de-duplicated and ranked. Anything below the threshold is dropped.
Written only from the passages, with citations. Thin evidence goes to the owning engineer once; their answer is saved.
02At scalecost, people, time
Cost control
Every step runs on a budget of minutes and tokens. Chores go to cheaper models, the Oracle answers repeat questions from cache, and the board shows cost per merged item. A step that blows its budget is marked stuck and sent to its owner, never retried forever.
Illustration: the Builder step on PAY-412 burns tokens steadily, then loops on one failing test. Its token use crosses the 80% alert and hits the two million token budget, so the step is stopped, marked stuck and routed to its owner, @sam, with no automatic retry.
Minutes and tokens, per step. Blow the budget and a human gets it, with no endless retries.
Illustration: four agent steps run with minute and token budgets. The Builder on PAY-412 reaches its two million token budget, is marked stuck and is routed to its owner, @sam, instead of retrying.
Steward on a fast model
Dependency bumps, flaky tests, stale docs. 22 runs, $9.00 this week.
Oracle answers from cache
912 repeat questions answered free this week, keyed by question and commit.
All guardrails on
Remote monitoring
A live board of every agent and step, with heartbeats, logs and budget used. When something needs a person, it finds you, and one tap puts the agent back to work.
Illustration: a live Runs dashboard lists five agent runs with their step, heartbeat, elapsed time and tokens against budget, and streams the log of PAY-512. When the Shaper's brief for AUTH-226 is ready for Gate 1, the Reviewer on WEB-88 asks a question, and the Tester on AUTH-221 hits its token budget, each event is sent to the owner's phone. Approving, replying or extending the budget from the phone updates the run on the board.
Gate 1 · brief ready for review
Rotate signing keys, by Shaper
Question from Reviewer
Is there a copy style guide?
Tester hit its token budget
800k of 800k used → needs you
Multi-engineer teams
Ownership routes every gate and question to the engineer who owns the code. Leases stop agents and people colliding, and everyone works from one shared ledger.
payments/checkout/summary.ts@alexweb/gallery@alexpayments api db@samIllustration: a live codebase map with eight modules, each owned by an engineer. @sam owns payments and db/migrations, @maria owns billing and notifications, @jun owns auth and api, and @alex owns web/gallery and search. Agents lease the files their brief needs: the PAY-412 Builder leases five files across payments, api and db/migrations. WEB-88 needs payments/checkout/summary.ts, which PAY-412 holds, so it waits in the queue and takes its lease only after @sam accepts and merges PAY-412. The PAY-512 Shaper reads web/gallery without a lease. PAY-512 is @sam's item, but web/gallery is @alex's code, so the Shaper's question about the Lightbox goes to @alex and its brief goes to @sam for Gate 1. Questions on AUTH-221 and BILL-37 go to @jun and @maria. Every event is written to one shared ledger that everyone sees.
Continuous development
The same loop runs features, bug fixes, migrations, nightly maintenance and learning. Only the trigger and the track change, and every rejection makes next week’s work smoother.
Illustration of one day of continuous development, from midnight to midnight.
Every rejection, review comment and repeated question becomes a file in git, approved by its owner.
03Foundationswhere it runs
Platform
A built-in tracker designed for agents, adapters for the one you already use, any agent runtime, and it runs on a laptop, inside your network or hosted.
Diagram: the EILAID core sits in the middle. Trackers (the built-in tracker, Jira, Linear, GitHub Issues and Azure Boards), agent runtimes (Claude Code, Codex, OpenCode and custom agents) and infrastructure (Git and CI, Slack, Postgres with pgvector) connect to it through adapters. Every tracker adapter does the same five things: imports work items, maps statuses both ways, writes the brief, handoffs and pull request back, mirrors gates, and mirrors blockers and questions. Select a node to read more.
Deployment
All three run the same code on the same data model. Start on a laptop and move to a server without migrating anything.
A single binary: CLI, terminal board and a local web UI.
Docker Compose or a Helm chart, inside your network.
A hosted service. Sign in and connect your repo and tracker.
Same code, same data. Move between modes without a migration.
Agents get the least access they need.
Principles
Tracks, personas, gates and the Oracle all fall out of these. When in doubt, an agent (or an engineer) comes back here.
methodology.mdRead them in fullHumans sit at gates, not inside every loop.
Diagram: a ticket moves through the eight loop steps. Agents run Intake, Shape, Build, Verify, Merge and Learn. An engineer appears only at Gate 1, to approve the brief, and at Gate 2, to accept the change. A failing check loops back to Build with no human involved.
If it is not in the ledger or the repo, it did not happen.
Each step starts with a fresh context window, built for that step.
Brief, footprint, decisions and cited answers. Nothing stale.
Every acceptance criterion maps to an automated check.
A criterion nobody can check is an open question, not a requirement.
Briefs, personas, decisions and knowledge are plain files.
Unsure? Ask the Oracle, then a human. Never invent an answer.
Each human answer is saved, so it is only asked once.
Each mistake becomes a rule, a test, a lint check or a skill.
A typo fix must not need a requirements document.
Patch, Feature or Epic: the track fits the work.
Trackers, agent runtimes and models are swappable adapters.
Start with the method: a brief, two gates and a shared ledger. Add the tools when you need them. Everything is plain files in git, so nothing is locked in.
npx eilaid init