ijfw

Your AI tools are brilliant, forgetful, undisciplined, and alone. One install fixes all four.

IJFW is one shared brain, and a full operating layer, for every AI coding tool you use. Install it once and your tools remember across sessions, plan before they build, check each other's work for hallucinations, pull in the right specialist for the job, and quietly cut your token bill. All on your machine. All yours.

npm install -g @ijfw/install && ijfw-install

The receipts: in an open, honest re-run of the field, memory beat no-memory by +55 points on LongMemEval. On recalling when something happened, Mem0, Letta, and Zep scored 0.000. IJFW scored 0.676. See the benchmark, method, and where we lose →

Everything it does

One install, one shared brain, and a full engine room around it. Skim the headlines and the bullets. Click into any engine to go deeper.

Memory that evolves with you

Your AI stops forgetting. Decisions, context, and the why behind them survive across sessions and across tools, and IJFW keeps the store clean on its own.

• Your decisions, project state, and observations persist as plain markdown under .ijfw/memory/, so context survives across sessions instead of evaporating.
• Recall ranks by keyword match with recency decay, so "what did we decide last" returns the latest call, not a random old one.
• A dream cycle promotes proven patterns, supersedes contradictions, and prunes stale notes, so your memory grows sharper over time instead of becoming a junk drawer.
• Bi-temporal facts carry validity windows, letting you ask what was true at a past point, not just what is true now.
• Every connected agent reads the same memory, so a decision recorded in one tool is recallable from another.
• Patterns only graduate to durable knowledge after three references across two sessions, so recall reflects settled facts, not transient remarks.

Read more: how memory works →

Build discipline that holds

The spine that stops AI coding from falling apart mid-session. It plans before it builds and gates every phase behind your sign-off.

• A brainstorm, plan, execute, verify, ship spine makes the plan exist and get signed off before a single line of code, so scope drift dies early.
• Quick mode runs five moves in a few minutes; Deep mode runs six modules for launches, so the ceremony matches the stakes.
• Phase gates are user-facing checklists with no auto-advance, so EXECUTE never rolls into VERIFY behind your back.
• The SHAPE step proposes three approaches, so you start from options to react to instead of a blank page.
• CONVERGE emits an explicit Wave Table marking each wave parallel or sequential, so agent dispatch is deterministic, not re-inferred from prose.
• Every artifact is summarized in chat before it hits disk, so you approve the brief, plan, and waves before they are written.

Read more: the workflow engine →

A second and third AI catch the hallucinations

One model will confidently ship a bug. So on demand, three models from three different labs red-team the same work in parallel, before it reaches your repo.

• Cross-audit puts a second and third training lineage on the same diff in parallel, so one model's confident blind spot does not reach production unchallenged.
• IJFW fingerprints the calling model and excludes it, then picks reviewers from different lineages, so the panel catches errors a single model would wave through.
• Findings come back tagged consensus or contested, so you instantly see which to treat as real and which to weigh yourself.
• It fires automatically as a phase after VERIFY and before SHIP, so a hallucinated change gets a second opinion before you ship it, not after.
• Every run appends a receipt with duration, tokens, and finding counts, so the scrutiny is auditable rather than a claim you take on faith.
• The method admits three models can share a wrong prior, so you read consensus as strong evidence and contested findings as a prompt to think.

Read more: multi-AI cross-audit →

A bench of specialists, summoned on demand

34 skills and a roster of specialist agents that show up only when the work calls for them, then get out of your context.

• Only a 54-line core skill stays resident; the rest load on a matched trigger and unload when done, so your context window stays lean.
• Triggers are natural language ("plan this feature", "cross-audit this"), so you invoke capability by intent without memorizing commands.
• ijfw team reads what you are building and writes a purpose-built bench (architect, security, QA, or world-builder), so the roster fits your actual project.
• Each agent runs on a model matched to its scope (cheap models for reads, the strong model for architecture), so you do not overpay for trivial work.
• IJFW hands the design or test phase to a dedicated skill you already installed, so the tool you paid for gets used where it is strongest.
• Generated agents dispatch automatically when a task matches their role, so the right specialist shows up without you routing it by hand.

Read more: skills & specialist teams →

A token bill that drops every session

Six independent cost levers compound on every turn, so your quality goes up while your bill goes down.

• Six levers compound per turn (cache, routing, output discipline, hot-load, sandbox, recall), so savings come from architecture, not a clever prompt.
• Smart routing sends reads to a cheap model and architecture to the strong one, so you stop paying premium rates for trivial work.
• Large command output (builds, test suites, log tails) streams to disk and returns a terse summary, so it never floods your context.
• A stable rules-file prefix is cached, so the context you resend every turn is read at roughly a tenth of normal input pricing instead of full read price.
• One memory prelude call replaces the ten-to-twenty-tool grep cascade a cold session would otherwise open with.
• Each turn ends with a one-line token-saved receipt, so the savings are a logged entry you can check, not a marketing figure.

Read more: the token economy →

See every session, and the dollars saved

A live, local dashboard across all your AI tools, with a dollar-saved ledger whose every number traces back to your own logs.

• A local dashboard shows every tool call across Claude, Codex, and Gemini on one timeline, so you see what each session actually touched.
• The cache-savings figure is measured, not modeled: it prices your real cache-read tokens at Anthropic's posted 90 percent cache discount, so it traces straight to your own Claude logs.
• Savings only counts what is defensible: measured cache reads, first-recall memory hits, and HIGH findings your cross-audit caught pre-ship at a conservative five dollars each, with no invented "spend without IJFW" multiplier.
• The whole pipeline is one JSON line per tool call plus a zero-dependency local page, so you can inspect the raw events yourself.
• The server binds to localhost only and returns 403 to external requests, so your session data stays on your machine.
• Tiles with no cost data say so plainly instead of showing a dressed-up zero, so you never mistake "no data" for "no savings".

Read more: observability →

It learns you

Rewrite its output once and IJFW notices the diff, then stops repeating that mistake across every tool. It learns from your edits, never your private data.

• The correction loop tracks the gap between what the AI proposed and what you shipped, so it learns from your intentional edits, not noisy copy-paste.
• Nothing enters your profile without a verbatim evidence span behind it, so the system under-learns rather than guessing wrong about you.
• A preference stays unconfirmed until corroborated across separate sessions, so one-off edits do not harden into durable rules.
• The goal is narrow and falsifiable, to stop you repeating the same correction, so success is something you can actually observe.
• A correction captured in one agent informs the profile every other agent reads, so you teach the preference once.
• ijfw personalize off is an instant kill-switch and forget is a hard reset, so you own whether the profile ever rides into a prompt.

Read more: personalization →

One design contract, every AI on-brand

Drop a DESIGN.md in your project and every agent builds to the same colors, type, and rules. No "make it look nice", no cross-tool drift.