# jitneuro.ai -- JitNeuro

> JitNeuro is an MIT-licensed framework and harness for AI coding agents: portable Markdown rules and patterns for Codex, Cursor, Claude Code, and other agents, with automatic lifecycle hooks currently wired for Claude Code.

## What it is
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.

Source repository: https://github.com/dstolts/jitneuro
License: code and documentation MIT. Keep the MIT copyright and permission notice with copies.
Repository facts below were verified against dstolts/jitneuro at ref uat on 2026-08-27.

## Frequently asked questions
Q: What is JitNeuro?
A: 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: https://github.com/dstolts/jitneuro/blob/uat/README.md

Q: Is JitNeuro free to use?
A: 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: https://github.com/dstolts/jitneuro/blob/uat/LICENSE

Q: Can I use JitNeuro with Codex, Cursor, or another coding agent?
A: 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: https://github.com/dstolts/jitneuro/blob/uat/README.md

Q: Does JitNeuro modify Claude Code itself?
A: 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: https://github.com/dstolts/jitneuro/blob/uat/README.md

Q: How does JitNeuro remember things after I run /clear?
A: /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: https://github.com/dstolts/jitneuro/blob/uat/templates/skills/save/SKILL.md

Q: Can I remove JitNeuro later?
A: 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: https://github.com/dstolts/jitneuro/blob/uat/docs/technical-overview.md

## A framework and a harness
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: https://github.com/dstolts/jitneuro/blob/uat/docs/technical-overview.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: https://github.com/dstolts/jitneuro/blob/uat/templates/hooks/stop-continue-queue.sh

## 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.

- 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: https://github.com/dstolts/jitneuro/blob/uat/templates/horizon/decision-routing.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: https://github.com/dstolts/jitneuro/blob/uat/templates/commands/divergent.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: https://github.com/dstolts/jitneuro/blob/uat/templates/_patterns/adversarial-verify-before-fix.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: https://github.com/dstolts/jitneuro/blob/uat/templates/engrams/README.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: https://github.com/dstolts/jitneuro/blob/uat/templates/session-state/README.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: https://github.com/dstolts/jitneuro/blob/uat/templates/skills/bundle/SKILL.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: https://github.com/dstolts/jitneuro/blob/uat/templates/hooks/pre-compact-save.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: https://github.com/dstolts/jitneuro/blob/uat/templates/hooks/branch-protection.sh

## 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: https://github.com/dstolts/jitneuro/blob/uat/templates/commands/divergent.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: https://github.com/dstolts/jitneuro/blob/uat/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: https://github.com/dstolts/jitneuro/blob/uat/templates/horizon/decision-routing.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: https://github.com/dstolts/jitneuro/blob/uat/templates/cognition/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: https://github.com/dstolts/jitneuro/blob/uat/templates/cognition/decisions/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: https://github.com/dstolts/jitneuro/blob/uat/templates/skills/gap-analysis.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: https://github.com/dstolts/jitneuro/blob/uat/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: https://github.com/dstolts/jitneuro/blob/uat/templates/_patterns/llm-as-judge.md

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

- Tier 1 -- Persistent memory and rules: Ships day one. Session state, engrams, bundles, and rules that keep Claude consistent across sessions.
  Source: https://github.com/dstolts/jitneuro/blob/uat/README.md
- Tier 2 -- Divergent thinking: /divergent always runs FRAME -> DIVERGE -> EVALUATE -> CONVERGE -> EXECUTE on every response. Single session, no extra infrastructure.
  Source: https://github.com/dstolts/jitneuro/blob/uat/templates/commands/divergent.md
- Tier 3 -- Multi-agent orchestration: Parallel sub-orchestrators with rolling worker pools and adversarial cross-verification, for large multi-repo operations.
  Source: https://github.com/dstolts/jitneuro/blob/uat/docs/sub-orchestrator-pattern.md

## 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.
  Source: https://github.com/dstolts/jitneuro/blob/uat/README.md

## 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.

- Session State: /save writes a named checkpoint of the current session to disk; /load restores it after a /clear, a crash, or a reboot. This is the working-memory tier.
  Source: https://github.com/dstolts/jitneuro/blob/uat/templates/skills/save/SKILL.md
- Engrams: Per-project deep context that accumulates over time. /learn evaluates a finished session and persists what it learned about that specific repo, so project knowledge outlives the session that produced it.
  Source: https://github.com/dstolts/jitneuro/blob/uat/templates/engrams/README.md
- Context Bundles: Domain knowledge kept out of the default context window and loaded on demand, so a session pays for the context it actually needs.
  Source: https://github.com/dstolts/jitneuro/blob/uat/templates/bundles/example.md
- Memory Index: The always-loaded memory file is capped short on purpose and holds a pointer to a detail index rather than the details themselves, so a session pulls deep knowledge in only when it is needed.
  Source: https://github.com/dstolts/jitneuro/blob/uat/templates/memory/detail-index.md
- Horizon: Vision, mission, goals, operating-rhythm, and owner-profile templates plus a guided interview (POPULATE-HORIZON) so every session aligns to your actual goals instead of guessing.
  Source: https://github.com/dstolts/jitneuro/blob/uat/templates/horizon/

## 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: https://github.com/dstolts/jitneuro/blob/uat/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: https://github.com/dstolts/jitneuro/blob/uat/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: https://github.com/dstolts/jitneuro/blob/uat/templates/hooks/session-end-autosave.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: https://github.com/dstolts/jitneuro/blob/uat/templates/hooks/branch-protection.sh

## 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: https://github.com/dstolts/jitneuro/blob/uat/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: https://github.com/dstolts/jitneuro/blob/uat/templates/rules/security-guardrails.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: https://github.com/dstolts/jitneuro/blob/uat/templates/rules/verify-before-claiming.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: https://github.com/dstolts/jitneuro/blob/uat/docs/enterprise-security.md

## 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: https://github.com/dstolts/jitneuro/blob/uat/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.
  Source: https://github.com/dstolts/jitneuro/blob/uat/community/README.md

## 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.
- 78 rule templates -- https://github.com/dstolts/jitneuro/tree/uat/templates/rules/
- 42 skill templates -- https://github.com/dstolts/jitneuro/tree/uat/templates/skills/
- 35 pattern documents -- https://github.com/dstolts/jitneuro/tree/uat/templates/_patterns/
- 31 documentation pages -- https://github.com/dstolts/jitneuro/tree/uat/docs/
- 24 command templates -- https://github.com/dstolts/jitneuro/tree/uat/templates/commands/
- 14 lifecycle hook scripts -- https://github.com/dstolts/jitneuro/tree/uat/templates/hooks/
- 9 cognition templates -- https://github.com/dstolts/jitneuro/tree/uat/templates/cognition/
- 8 horizon templates -- https://github.com/dstolts/jitneuro/tree/uat/templates/horizon/

## Install
- Prerequisite: For automatic lifecycle hooks: Claude Code (CLI, desktop, or web) -- latest version recommended.
- Prerequisite: 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.
- Prerequisite: 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.

## 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.

## Affiliation
JitNeuro is an independent open-source project. It is not affiliated with, endorsed by, or officially connected to Anthropic, Claude, or Claude Code. "Claude Code" is a product of Anthropic, PBC. JitNeuro uses Claude Code's publicly documented features and does not modify or extend the Claude Code application itself.

## Page sections
- What it is: https://jitneuro.ai/#what-it-is
- FAQ: https://jitneuro.ai/#faq
- Anatomy: https://jitneuro.ai/#anatomy
- Memory: https://jitneuro.ai/#memory
- Thinking: https://jitneuro.ai/#thinking
- Reasoning: https://jitneuro.ai/#reasoning
- Lenses: https://jitneuro.ai/#lenses
- Lifecycle: https://jitneuro.ai/#lifecycle
- Guardrails: https://jitneuro.ai/#security
- Install: https://jitneuro.ai/#install