Just In Time AI
v0.5.2 jitneuro.ai

Open Source -- MIT License

Your coding agent forgets context. JitNeuro gives it memory and guardrails.

A portable knowledge framework for Codex, Cursor, Claude Code, and other coding agents -- mostly Markdown, plus inspectable shell, PowerShell, and Python helpers. Claude Code also gets automatic lifecycle hooks.

When an agent loses its context, you re-explain your project, your stack, and where you left off. JitNeuro keeps durable project guidance, memory patterns, skills, and guardrails in ordinary files you can open, edit, or delete. Claude Code can automate the save/load lifecycle through hooks; other agents can read the same knowledge layer and invoke or adapt the helpers without a hosted JitNeuro service or daemon.

 git clone https://github.com/dstolts/jitneuro.git
 cd jitneuro
 ./install.sh user

click the block to select all -- no copy button, no JavaScript

View on GitHub Full install steps
Install View on GitHub

What it is

JitNeuro is a portable knowledge framework and an automation harness for AI coding agents. Codex, Cursor, Claude Code, and other agents can use its Markdown rules, skills, and patterns; Claude Code can also run the shipped lifecycle hooks automatically. Everything it installs is a file you can open, edit, or delete.

The framework half is the pattern the repo documents: short directives from you, orchestration by the model, execution by agents, with memory surfaces and rule templates that make the pattern repeatable across projects. Source: docs/technical-overview.md README.md

The harness half is mechanical. Claude Code can run the shipped lifecycle hooks outside the model's reasoning, so a rule can be enforced by a script rather than memory alone. Codex, Cursor, and other agents can use the portable Markdown layer today; automatic lifecycle behavior requires a runtime-specific adapter or manual invocation. Source: templates/hooks/stop-continue-queue.sh templates/hooks/branch-protection.sh

The repository is public and the facts on this page are checkable against it. Each capability below links to the file that implements it, at the ref this page was built from (uat, verified 2026-08-27).

Top

Frequently asked questions

Direct answers to what people actually ask about JitNeuro, each linked to the file that backs it.

  • What is JitNeuro?

    JitNeuro is a free, MIT-licensed framework and harness for AI coding agents: its portable Markdown layer gives Codex, Cursor, Claude Code, and other agents durable project guidance, memory patterns, skills, and guardrails, while Claude Code can also run the shipped lifecycle hooks automatically.

    Source: README.md docs/technical-overview.md

  • Is JitNeuro free to use?

    Yes. JitNeuro's code and documentation are available under the MIT License, with no signup or paid tier; keep the MIT copyright and permission notice with copies of the software.

    Source: LICENSE README.md

  • Can I use JitNeuro with Codex, Cursor, or another coding agent?

    Yes. Codex, Cursor, and other coding agents can read and use the Markdown rules, skills, patterns, and project guidance. Automatic slash commands and lifecycle hooks are currently wired for Claude Code, so other runtimes need an adapter or manual invocation for that automation.

    Source: README.md install.sh templates/hooks/

  • Does JitNeuro modify Claude Code itself?

    No. JitNeuro is an independent project that uses Claude Code's publicly documented hook and memory features; it does not patch, fork, or otherwise modify the Claude Code application, and it is not affiliated with or endorsed by Anthropic.

    Source: README.md

  • How does JitNeuro remember things after I run /clear?

    /save writes a named checkpoint of the current session to disk, and /load restores that checkpoint after a /clear, a crash, or a reboot, so the session picks back up where it left off.

    Source: templates/skills/save/SKILL.md templates/skills/load/SKILL.md

  • Can I remove JitNeuro later?

    Yes. Every part of JitNeuro is an ordinary file under your project's .claude directory, so removing it is deleting those files -- there is no separate uninstall step, background process, or account to close.

    Source: docs/technical-overview.md

Top

The anatomy

Eight pieces do the work. The diagram is a map of how they relate, not a claim about neuroscience -- each region is labeled with the capability it stands for and links to the file that implements it.

JitNeuro's eight parts, drawn as regions of a sectioned brain A stylised brain in cross-section, divided into numbered regions and enclosed in a dashed frame. Regions one to five divide the cerebrum: decision routing at the front, divergent thinking across the top, adversarial verification at the back, long-term memory along the lower front, and short-term memory at the centre. Region six is the cerebellum, recall on demand. Region seven is the brainstem, consolidation while you are away. Region eight is the dashed frame enclosing everything, the harness. Every region is listed with its full description in the legend beside this figure. 12345678
The anatomy is a map of how the pieces relate. It is not a claim that the project models actual brain regions -- the placement is chosen to be memorable, and every label links to the file that implements it.

  1. Decision routing

    Three tiers decide what happens without you: proceed autonomously, proceed and report, or stop and ask. The tier is a property of the action, not of the model's confidence.

    Source: templates/horizon/decision-routing.md templates/rules/approval-workflow.md

  2. Divergent thinking

    A breadth control, separate from depth. /divergent runs frame, diverge, evaluate, converge, execute so more than one approach is generated before one is chosen.

    Source: templates/commands/divergent.md templates/skills/divergent-thinking.md

  3. Adversarial verification

    An independent verifier is dispatched to attack a diagnosis before any fix is authored, because a confident pass that diagnosed several bugs at once has usually invented at least one of them.

    Source: templates/_patterns/adversarial-verify-before-fix.md templates/skills/differential-security-review.md

  4. Long-term memory

    Engrams: per-project knowledge that strengthens over time as /learn evaluates a finished session and writes back what it learned about that specific repo.

    Source: templates/engrams/README.md templates/skills/learn/SKILL.md

  5. Short-term memory

    Session state: a named checkpoint on disk written by /save and restored by /load, so a /clear, a crash, or a reboot does not cost you your place.

    Source: templates/session-state/README.md templates/skills/save/SKILL.md

  6. Recall on demand

    Bundles and a memory index keep domain knowledge out of the default context window and pull it in only when a session needs it, so you pay for the context you use.

    Source: templates/skills/bundle/SKILL.md templates/memory/detail-index.md

  7. Consolidation while you are away

    The work does not stop when you do. A PreCompact hook checkpoints before the context window is compacted, a session-end hook flushes captured lessons to disk, and a Stop hook can hold the session on its queue instead of yielding after each task.

    Source: templates/hooks/pre-compact-save.sh templates/hooks/session-end-lessons-flush.sh templates/hooks/stop-continue-queue.sh

  8. The harness

    Everything above sits inside it. Hooks fire in Claude Code's own harness, outside the model's reasoning, so a guardrail holds whether or not the model agrees with it.

    Source: templates/hooks/branch-protection.sh templates/rules/trust-zones.md

Top

See it work

The loop the whole thing exists for:

 /save auth-refactor  # checkpoint this session to disk
 /clear  # context window emptied
 /load auth-refactor  # you are back where you were

/save writes a named checkpoint to local disk. /load restores it after a /clear, a crash, or a reboot. These save/load templates do not transmit the checkpoint to a JitNeuro service.

Source: templates/skills/save/SKILL.md templates/skills/load/SKILL.md

Top

The memory model

JitNeuro splits memory into five surfaces with different lifetimes, so a session reloads what is relevant instead of replaying an entire transcript.

Top

Thinking systems

Memory is the half that gets talked about. This is the other half: the decision and reasoning machinery that runs before an answer is written. None of it needs configuration to start working, and all of it is a file you can read.

  • Divergent thinking

    Depth and breadth are separate controls. Effort decides how hard a session thinks; /divergent decides how wide, running frame, diverge, evaluate, converge, execute so alternatives exist before one is picked. It can be set per repo to auto, always, or never.

    Source: templates/commands/divergent.md templates/skills/divergent-thinking.md

  • Adversarial verification

    Before a fix is authored for a batch of diagnosed bugs, an independent verifier is dispatched to try to refute the diagnosis -- because a single confident pass that found several bugs at once has usually invented at least one, and fixing a phantom bug is worse than finding nothing.

    Source: templates/_patterns/adversarial-verify-before-fix.md

  • Decision routing

    A three-tier ladder for who decides: proceed autonomously, proceed and report at a checkpoint, or stop and ask. Approval is defined precisely enough to be mechanical -- answering a question is explicitly not approval, and approving a plan is not authorization to execute it.

    Source: templates/horizon/decision-routing.md templates/rules/approval-workflow.md

  • Friction detection

    A pre-reasoning scan of what you just typed for correction signals -- frustration, a repeated ask, a wrong assumption, a constraint you already gave -- with a defined response for each. It escalates to root-cause analysis only when you say yes, never on its own.

    Source: templates/cognition/friction-detection.md templates/rules/friction-detection.md

  • Root-cause analysis

    A decision workflow that applies to failures of every kind, not just code: bugs, process breakdowns, and the model's own behavioral errors. The rule it enforces is the unpopular one -- never patch the symptom.

    Source: templates/cognition/decisions/root-cause-analysis.md templates/skills/root-cause-analysis.md

  • Gap analysis before delivery

    A self-check that runs before work is handed to you, surfacing missed edge cases, blind spots from a specialist lens that never activated, and assumptions that were never stated. Paired with a rule against asking you to verify anything the session has not verified itself.

    Source: templates/skills/gap-analysis.md templates/rules/verify-before-presenting.md

  • Conflict resolution between lenses

    When two specialist perspectives produce opposite recommendations, a defined ladder decides which one wins and when the disagreement escalates instead of being averaged into mush.

    Source: templates/_patterns/conflict-resolution.md

  • Scored output gates

    A rubric-scored review stage that completes only when the score clears a threshold, retries with a sharpened prompt when it does not, and caps its own escalation so it cannot loop forever or quietly advance weak work.

    Source: templates/_patterns/llm-as-judge.md templates/_patterns/validation-gates.md

Top

The reasoning ladder

Three tiers. You climb them as your needs grow; none of them require configuration up front.

Top

Sixteen specialist review lenses

Every request is evaluated by sixteen specialist lenses at once -- architect, security, backend, DBA, reliability, QA, UX, and others. They are not commands and not keywords. They are simultaneous perspectives on a single response.

Asking for a bulk-delete endpoint produces this, before any code:

[Backend Engineer + Security Engineer]

Endpoint design here...

[Security] Re-authenticate before bulk delete -- this is a destructive operation.
[UX] That adds friction on every bulk action.
[Resolution] Re-auth only when selection exceeds 10 items or includes admin records.
[DBA] Add a partial index on deleted_at for the soft-delete scan -- full table scan at scale.
[Reliability] Wrap the delete loop in a transaction with explicit rollback on partial failure.

Five specialist perspectives in one response, with the conflict resolved inline.

Source: README.md

Top

What it installs into the session lifecycle

JitNeuro's behavior comes from Claude Code's documented lifecycle hooks. These are shell scripts you can read and edit; 14 hook templates ship in the repo.

  • Master-orchestrator identity on SessionStart

    A SessionStart hook injects a master/orchestrator role into every new session, so Claude coordinates and delegates by default rather than behaving as a generic single-threaded coding agent.

    Source: templates/hooks/session-start-identity.sh

  • Post-compact recovery

    A PreCompact hook checkpoints state before Claude Code compacts the context window and instructs the next turn to reload it, so a compaction does not silently lose your place.

    Source: templates/hooks/pre-compact-save.sh

  • Session-end autosave and lesson flush

    Session-end hooks write an autosave checkpoint and flush captured lessons to durable storage, so an unclean exit does not discard the session's learnings.

    Source: templates/hooks/session-end-autosave.sh templates/hooks/session-end-lessons-flush.sh

  • Branch protection

    A hook checks git operations against a configured protected-branch list before they run, catching an accidental push to main locally.

    Source: templates/hooks/branch-protection.sh

Top

The security guardrails -- and their honest limits

JitNeuro ships 78 rule templates, including a trust-zone permission model and a set of security guardrails. What matters as much as the rules is where they stop working, which the project documents rather than hides.

  • Trust zones (GREEN / YELLOW / RED)

    A three-tier permission model. GREEN actions -- read, write, edit, search, test, analyze -- run freely. YELLOW actions such as schema changes, new dependencies, API contract changes, and .env writes execute but are reported at a checkpoint. RED actions -- push to main, production deploy, database migrations -- stop and ask you, every time, including when the change is small or urgent.

    Source: templates/rules/trust-zones.md

  • Secrets stay out of the repo

    Guardrail rules keep API keys, tokens, and passwords out of markdown, specs, and source, requiring a reference to the .env location instead of the value, and cover CLI invocations that would otherwise leak a secret into shell history.

    Source: templates/rules/security-guardrails.md templates/rules/cli-secret-safety.md

  • Verification before claiming

    A rule requiring an agent to verify against the actual codebase before reporting something missing, broken, or done -- aimed at the failure mode where a confident model reports a false absence and triggers duplicate work.

    Source: templates/rules/verify-before-claiming.md templates/rules/verify-before-presenting.md

Stated limit: local hooks are Layer 1, not a security boundary

The project's own enterprise-security documentation states plainly that a developer who can edit the hook scripts, settings files, or CLAUDE.md can bypass any local check, and that server-side controls -- GitHub branch protection, CI gates, deploy policy -- are the actual enforcement. It documents CLAUDE.md as the subtlest risk, because it is natural-language instruction Claude will follow. For teams that need the trust root outside a developer's write access, it describes serving hooks and policy config from a read-only share.

Source: docs/enterprise-security.md

Top

What ships in the repo

JitNeuro is mostly Markdown, with inspectable shell, PowerShell, Python, JSON, and supporting files. These are exact directory counts from the repository tree, not rounded marketing figures.

Counts taken from the repository tree at ref uat on 2026-08-27; 396 files in total.

Top

Install

You will need:

  • For automatic lifecycle hooks: Claude Code (CLI, desktop, or web) -- latest version recommended.
  • For Codex, Cursor, or another coding agent: use the Markdown rules, skills, and patterns directly; adapt or manually invoke Claude-specific hooks and slash commands.
  • Git plus Bash for the Unix installer and hooks. On Windows, use PowerShell and Git Bash; jq is optional when merging an existing settings file.
 git clone https://github.com/dstolts/jitneuro.git
 cd jitneuro
 ./install.sh user

On Windows PowerShell, run .\install.ps1 -Mode user instead of the last step.

Claude Code users: close and reopen it so the hooks load, then try /save, /learn, and /load. Other agents can read the installed Markdown immediately, but automatic commands and lifecycle events require an adapter.

Source: install.sh install.ps1 QUICKSTART.md

Upgrades do not clobber your work

A manifest separates framework files from yours. Pulling a new release and re-running the installer updates the framework, prunes files the new version dropped, and leaves your own rules, bundles, horizon files, and learnings alone; a framework file you edited is backed up rather than overwritten.

Source: templates/COMMUNITY-PUBLISH-MANIFEST.json docs/setup-guide.md

Top

Community rule packs

Optional packs live in community/. Nothing there is loaded automatically -- they are a menu, not a mandate. Copy the individual rules that solve a real problem for you and edit them; they are yours.

  • ADHD-friendly -- 7 rules

    Keeps AI output scannable and action-oriented: ASCII only, single-line commands, highest-value-first, ship over perfect. Not clinical advice.

    Source: community/adhd-friendly/README.md

  • Contribute a pack

    Fork, add a folder under community/, write a README, keep each rule under 30 lines, open a pull request.

    Open a pull request →

    Source: community/README.md

Top