Nucleus

io.github.eidetic-worksPublished by GitHub account eidetic-worksv1.17.1Updated Nov 3, 2026

Persistent memory for AI agents — shared .brain across Claude Code, Cursor & Codex

VerifiedStreamable HTTPWeb executableProductivity & WorkflowDeveloper ToolsAI & ML

Overview

Nucleus's hosted MCP server (relay.nucleusos.dev); no sign-in required; Streamable HTTP; 28 tools.

No AI overview yet: these facts come from the registry entry and the server itself.

Endpoint
relay.nucleusos.dev
Last checked

Installation

In SourceWeft

  1. Open Nucleus in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.eidetic-works%2Fnucleus/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "nucleus": {
      "type": "http",
      "url": "https://relay.nucleusos.dev/mcp"
    }
  }
}

README

.brain — the portable decision log

The portable decision log your AI tools all read. One MCP server. Any AI tool. Plain files.

[PyPI version] [License: MIT] [MCP Compatible] [NPM] [nucleus-mcp MCP server]

Every AI coding session starts by re-explaining context the last session already knew. .brain is a folder in your repo that Claude Code, Cursor, and Codex all read via one MCP server. Decisions, policies, plans — written once, remembered across every session and every tool.

MIT licensed. File-based (plain JSON + markdown). No embeddings. No vendor lock-in.

Also included: nucleus-rabbithole

nucleus-mcp ships a second, fully independent tool: nucleus-rabbithole, a rabbit-hole depth tracker for focus-prone developers.

It gives your AI a push/pop depth stack, a context-switch thrash detector, an open-loop externaliser, and a weekly review — all backed by local SQLite, no network, no daemon.

bash
# Already installed with nucleus-mcp — just run:nucleus-rabbithole

Claude Code .mcp.json snippet:

json
{  "mcpServers": {    "nucleus-rabbithole": {      "command": "nucleus-rabbithole",      "args": []    }  }}

Full documentation: docs/RABBITHOLE.md — also installed with the package, at <site-packages>/mcp_server_nucleus/docs/RABBITHOLE.md.

Three Frontiers

The core loop that makes AI reliability compound over time:

  GROUND              ALIGN               COMPOUND  ──────              ─────               ────────  Machine verifies    Human corrects      System learns
  AI writes code  →  You fix a mistake →  Delta recorded  GROUND checks   →  Verdict stored    →  DPO pair created  Receipt logged  →  Event emitted     →  Training data grows       │                   │                    │       └───────────────────┴────────────────────┘                    Reliability improves

GROUND — 5-tier execution verification. Syntax, imports, tests, runtime. Goes outside the formal system to check the AI's work.

ALIGN — One-call corrections. nucleus review records a verdict against a prior decision, which becomes a training pair and an event.

COMPOUND — Deltas measure the gap between intent and reality. Recurring patterns become strategy. Negative deltas become training signal.

Every tool response shows frontier health:

[frontiers: GROUND 42 | ALIGN 12 | COMPOUND 28]

Quick Start

Hosted access is not currently available. The remote MCP endpoint is withdrawn pending an access-control review. Use the local install below.

Local install (Cursor, Windsurf, Claude Desktop):

bash
pip install nucleus-mcpnucleus init --recipe founder

Two commands. Nucleus is running. nucleus init seeds .brain/, writes a project-local .mcp.json, and offers to configure every AI client you have installed. Say yes, then restart the client.

nucleus build additionally needs a coding-agent CLI on PATH — any one of claude (npm i -g @anthropic-ai/claude-code), devin, or agy, already authenticated (claude/devin/agy login once, separately). Without one, build stops at the plan stage. If build reports status='error' without a clear cause, the vendor CLI's own error (e.g. an expired login) lands in .brain/relay/cross_vendor/*.json — check the newest file there.

What It Does

30 MCP tools across 16 facades, exposing 210 actions, plus 19 brain:// resources and 8 prompts. Regenerate these with python3 tools_audit/count_surface.py rather than editing them by hand — three hand-maintained copies of this number had drifted apart before that script existed.

  • GROUND — Execution verification (5 tiers: diff, syntax, imports, tests, runtime)
  • ALIGN — Human corrections (verdict + delta + DPO + event in one call)
  • Memory — Engrams that persist across sessions. Write once, recall forever.
  • Sessions — Save context, resume later. Session arc shows your last 3 sessions.
  • Tasks — Priority queue with escalation, HITL gates, and heartbeat monitoring.
  • Governance — Kill switch, compliance configs (EU DORA, MAS TRM, SOC2), audit trails.
  • Orchestration — Agent slots, multi-brain sync, task dispatch.
  • Archive — Training pipeline (SFT + DPO), delta tracking, frontier health dashboard.

Benchmark: decision-retention-evals — does your AI agent remember why the code is the way it is? (ask on Discord for the current mirror)

Nucleus Pro

Everything above is free (MIT). Nucleus Pro adds verifiable governance:

bash
nucleus trial                              # 14-day free trialnucleus compliance-check                   # Score your AI governancenucleus audit-report --format html -o report.html   # Audit report

$19/month or $149/year — nucleusos.dev/pricing

FreePro
30 tools, 19 resources, 8 promptsYesYes
Persistent memoryYesYes
Governance & HITLYesYes
Audit trails (DSoR)YesYes
Signed audit reports-not yet shipped
Compliance exportsScore onlyFull PDF/HTML
Priority issues-Yes

Install

bash
pip install nucleus-mcp      # or:  uvx nucleus-mcp  ·  pipx install nucleus-mcpnucleus init                 # seeds .brain/, then offers to configure your AI clients

Requires Python ≥3.10; on 3.14 some dependencies (e.g. watchdog) build from source — 3.11–3.13 install wheels cleanly. init writes whichever nucleus binary it resolves first on PATH into the config it generates — with a stale global install alongside a venv, pipx/uvx or which nucleus keeps the right one.

nucleus init always does three things: seeds .brain/, writes a project-local .mcp.json that Claude Code reads in that folder, and runs a memory write-and-recall self-test so you can see it working before you trust it.

In an interactive terminal it then asks whether to configure your other AI clients. Answer yes and it writes the nucleus entry into every one it finds installed — Claude Desktop, Claude Code, Cursor, Windsurf, Antigravity, Devin — backing up each file it touches. It tells you how many it configured, and says so plainly when that number is zero rather than leaving you to wonder.

Run with --no-wizard, or in a script where there is no terminal to ask, and it seeds the brain and the project-local config only. Use nucleus setup for the client configuration in that case.

Then restart your AI client. To verify: your client's tool list now shows nucleus_* tools, or run nucleus doctor.

An existing nucleus entry is never touched unless you pass --force. For most clients a <config>.json.bak copy is written before the edit. Claude Code's ~/.claude.json is handled differently and deliberately: nucleus writes a temp file and swaps it in atomically, so a failed write leaves the original exactly as it was, and no .bak is left lying beside it. A client that is installed but has never had an MCP config gets one created; a client you do not have is left alone entirely, and ~/.claude.json is never invented if it is missing. Already have a .brain? Run nucleus setup to configure clients without re-seeding it, with --dry-run to preview the exact changes first.

Claude Desktop — one-click bundle

A one-click nucleus.mcpb bundle for Claude Desktop is built via bash scripts/build_mcpb.sh (it will be attached to releases once the release workflow ships it). Opening the bundle with Claude Desktop uses Claude's built-in uv runtime to fetch and run nucleus-mcp — no Python setup required.

Hosted / no-install access

Currently unavailable. The remote MCP endpoint is withdrawn pending an access-control review; use a local install.

Manual config (fallback)

If a client isn't auto-detected, run nucleus setup --dry-run to print every location nucleus looks in and the exact mcpServers block it would write, then paste that block into your client's config yourself. nucleus setup --create writes a Claude Code config even when nothing is detected. The full manual walkthrough lives in docs/QUICK_START.md, which ships with the package at <site-packages>/mcp_server_nucleus/docs/QUICK_START.md.

Path Discovery

Nucleus finds your .brain automatically:

  1. NUCLEUS_BRAIN_PATH environment variable (explicit)
  2. Walk up from CWD looking for .brain/ directory
  3. Fall back to $HOME/.nucleus/brain

This lookup order applies to the running server. nucleus init instead seeds .brain/ in the directory you run it in (or the path argument) — set NUCLEUS_BRAIN_PATH afterwards if you want the server to find a brain placed somewhere else.

CLI

Nucleus has a full CLI alongside the MCP tools. Auto-detects TTY (table output) vs pipe (JSON).

bash
# Memorynucleus engram write my_key "insight here" --context Decision --intensity 7nucleus engram search "compliance"nucleus engram query --context Strategy --limit 10
# Tasksnucleus task list --status READYnucleus task add "Ship the feature" --priority 1
# Sessionsnucleus session save "Working on auth refactor"nucleus session resume
# Healthnucleus status --healthnucleus sovereign
# Compliancenucleus comply --jurisdiction eu-doranucleus audit-report --format html -o report.html
# Chat (multi-provider: Gemini, Anthropic, Groq)nucleus chat

Pipe-friendly:

bash
nucleus engram search "test" | jq '.key'nucleus task list --format tsv | cut -f1,3

Compliance

One-command configuration for regulatory frameworks:

bash
nucleus comply --jurisdiction eu-dora       # EU DORAnucleus comply --jurisdiction sg-mas-trm    # Singapore MAS TRMnucleus comply --jurisdiction us-soc2       # US SOC2
JurisdictionRetentionHITL OpsKill Switch
eu-dora7 years5 typesRequired
sg-mas-trm5 years5 typesRequired
us-soc21 year3 typesOptional
global-default90 days2 typesOptional

Telemetry

Nucleus collects anonymous, aggregate usage statistics (command name, duration, error type, versions, OS). No engram content, no file paths, no prompts, no API keys, no PII — ever.

bash
nucleus config --no-telemetry# or: NUCLEUS_ANON_TELEMETRY=false

See TELEMETRY.md for details.

Contributing

License

MIT © 2026 | [email protected]

Companion repositories (optional)

Some deployments keep companion scripts in a repo next to this one. Point nucleus at them with either:

bash
export NUCLEUS_SIBLING_REPOS="$HOME/repo-a:$HOME/repo-b"     # os.pathsep-separated# or, one path per line:printf '%s\n' "$HOME/repo-a" "$HOME/repo-b" > ~/.config/nucleus/siblings

With neither set, nucleus searches only its own repo — no assumptions are made about the host. A job whose script cannot be found fails with an error naming every location tried.

Privacy

Where your memories live depends on which Quick Start option you chose.

Option B — local install. Nucleus is local-first. Engrams, memories and project state are written to .brain/ on your machine. Nothing is sent anywhere unless you configure a relay yourself.

Option A — no install (relay.nucleusos.dev). This is a hosted service we operate. Your engrams are stored on our servers, not on your machine, and what is stored is the full content of each memory — the value field, not just a key or a timestamp — along with its context label, intensity, version and timestamps. There is no local .brain/ in this mode; the relay is the brain.

We keep tenants separated and reachable only with your own bearer token. But "local-first" does not describe Option A, and it would be wrong to let the word cover it: if you would not put something on a server we run, do not put it in a memory while connected this way. Use Option B for that.

An earlier version of this section described only the local case, and understated what a relay receives. It has been corrected.

Telemetry: Anonymous, aggregate usage statistics only (command name, duration, error type, versions, OS). No engram content, no file paths, no prompts, no API keys, no PII — ever. Disable with nucleus config --no-telemetry or NUCLEUS_ANON_TELEMETRY=false. This is separate from, and unaffected by, which option above you chose.

Self-hosted relay (optional, Option B): If you point Nucleus at a relay endpoint you run, full engram content is synced there — same record shape as above. That server is yours.

Contact: Privacy questions → [email protected]

Source: README.md at commit 30fcfd4

Tools

28

nucleus_governance

Governance

Governance, Hypervisor & security tools for the Nucleus Agent OS. Actions: auto_fix_loop - Auto-fix loop: Verify->Diagnose->Fix->Verify (3 retries). params: {file_path, verification_command} lock - [HYPERVISOR] Lock a file/dir immutable (chflags uchg). params: {path} unlock - [HYPERVISOR] Unlock a file/dir. params: {path} set_mode - [HYPERVISOR] Switch IDE context: "red" or "blue". params: {mode} list_directory - [GOVERNANCE] List files in a directory. params: {path} delete_file - [GOVERNANCE] Delete a file (governed by Hypervisor). params: {path, confirm?}. HITL: requires confirm=true. watch - [HYPERVISOR] Monitor a file/folder for changes. params: {path} status - [HYPERVISOR] Report current security state of Agent OS curl - [EGRESS] Proxied HTTP fetch for air-gapped agents. params: {url, method?} pip_install - [EGRESS] Proxied pip install for air-gapped agents. params: {package} validate_strategic_plan - [PROTOCOL] Validate Strategic mode PLAN has Big Bang [BB##] refs. params: {plan_text, mode?} comply_list - [COMPLIANCE] List available regulatory jurisdictions comply_apply - [COMPLIANCE] Apply jurisdiction config. params: {jurisdiction, brain_path?} comply_report - [COMPLIANCE] Generate compliance status report. params: {brain_path?} audit_report - [COMPLIANCE] Generate audit-ready report. params: {report_format?, since_hours?, brain_path?} kyc_review - [COMPLIANCE] Run KYC demo review. params: {application_id?, brain_path?} sovereign_status - [STATUS] Get sovereignty posture report. params: {brain_path?} trace_list - [DSoR] List decision traces. params: {trace_type?, brain_path?} trace_view - [DSoR] View specific trace. params: {trace_id, brain_path?}

Parametersactionrequiredparams

nucleus_features

Feature Flags

Feature tracking, proof generation & MCP server mounting. Actions: add - Add a feature. params: {product, name, description, source, version, how_to_test, expected_result, status?, tags?} list - List features. params: {product?, status?, tag?} get - Get feature by ID. params: {feature_id} update - Update feature fields. params: {feature_id, status?, description?, version?} validate - Mark feature validated. params: {feature_id, result} search - Search features. params: {query} mount_server - Mount external MCP server. params: {name, command, args?} thanos_snap - Trigger Instance Fractal Aggregation unmount_server - Unmount MCP server. params: {server_id} list_mounted - List mounted MCP servers discover_tools - Discover tools from mounted servers. params: {server_id?} invoke_tool - Invoke tool on mounted server. params: {server_id, tool_name, arguments?} traverse_mount - Recursively mount downstream servers. params: {root_mount_id} generate_proof - Generate proof document. params: {feature_id, thinking?, deployed_url?, files_changed?, risk_level?, rollback_time?} get_proof - Get proof for a feature. params: {feature_id} list_proofs - List all proof documents

Parametersactionrequiredparams

nucleus_sessions

Session Management

Session management, events, state & checkpoint tools. Actions: save - Save session for later. params: {context, active_task?, pending_decisions?, breadcrumbs?, next_steps?} resume - Resume a saved session. params: {session_id?} list - List all saved sessions check_recent - Check for recent session to resume (alias: "current") end - End work session. params: {summary?, learnings?, mood?} start - Mandatory session start protocol archive_resolved - Archive .resolved.* backup files propose_merges - Detect redundant artifacts, generate merge proposals garbage_collect - Archive stale tasks. params: {max_age_hours?, dry_run?} emit_event - Emit event to brain ledger. params: {event_type, emitter, data, description?} read_events - Read recent events. params: {limit?} get_state - Get brain state. params: {path?} update_state - Update brain state. params: {updates} checkpoint - Save task checkpoint. params: {task_id, step?, progress_percent?, context?, artifacts?, resumable?} resume_checkpoint - Resume from checkpoint. params: {task_id} handoff_summary - Generate handoff summary. params: {task_id, summary, key_decisions?, handoff_notes?} ingest_conversations - Ingest Claude Code JSONL transcripts. params: {mode?: "incremental"|"batch"|"single", session_id?, limit?, dry_run?} search_conversations - Search ingested conversations. params: {query, limit?, session_id?, date_from?, date_to?} list_conversations - List ingested sessions. params: {limit?, offset?, sort?: "recent"|"size"|"turns"} conversation_stats - Aggregate conversation corpus statistics register - [T3.11] Register agent session envelope. params: {session_id, agent, role, provider, worktree_path?, pid?, heartbeat_interval_s?, role_credential?} (role_credential required when NUCLEUS_ROLE_CREDENTIAL=1 — see stone-1.5) heartbeat - [T3.11] Touch last_heartbeat on an

Parametersactionrequiredparams

nucleus_tasks

Task Management

Task management, depth tracking & ADHD context-switch tools. Actions: list - List tasks. params: {status?, priority?, skill?, claimed_by?, required_role?} get_next - Get highest-priority unblocked task. params: {skills, required_role?} claim - Atomically claim a task. params: {task_id, agent_id} update - Update task fields. params: {task_id, updates} add - Create a new task. params: {description, priority?, blocked_by?, required_skills?, source?, task_id?, skip_dep_check?, required_role?, plan_ref?} (alias: "create") import_jsonl - Import tasks from JSONL. params: {jsonl_path, clear_existing?, merge_gtm_metadata?} escalate - Escalate task for human help. params: {task_id, reason} depth_push - Go deeper into subtopic. params: {topic} depth_pop - Come back up one level depth_show - Show current depth state depth_reset - Reset depth to root depth_set_max - Set max safe depth. params: {max_depth} depth_map - Generate exploration map context_switch - Record context switch / ADHD drift check. params: {new_context} context_switch_status - Get context switch metrics context_switch_reset - Reset context switch counter

Parametersactionrequiredparams

nucleus_sync

Cross-Agent Sync

Sync, artifact, trigger & deploy management for multi-agent coordination. Actions: identify_agent - Register agent identity. params: {role, provider, session_id} (per ADR-0005 §D1) OR legacy {agent_id, environment, role?} (coerced per §D5 until end of Cycle C+2) sync_status - Check current multi-agent sync status sync_now - Manually trigger sync. params: {force?} sync_auto - Enable/disable file watching. params: {enable} sync_resolve - Resolve a file conflict. params: {file_path, strategy?} read_artifact - Read an artifact file. params: {path} write_artifact - Write to an artifact file. params: {path, content} list_artifacts - List artifacts. params: {folder?} trigger_agent - Trigger an agent via event. params: {agent, task_description, context_files?} get_triggers - Get all defined neural triggers evaluate_triggers - Evaluate triggers for an event. params: {event_type, emitter} start_deploy_poll - Start monitoring a Render deploy. params: {service_id, commit_sha?} check_deploy - Check deploy poll status. params: {service_id} complete_deploy - Mark deploy complete. params: {service_id, success, deploy_url?, error?, run_smoke_test?} smoke_test - Run a smoke test. params: {url, endpoint?} shared_read - Read shared state. params: {key} shared_write - Write shared state. params: {key, value, agent_id?} shared_list - List all shared state keys notify - Send notification to all channels. params: {title, message, level?} list_channels - List configured notification channels add_channel - Add a channel. params: {channel_type, webhook_url?} test_channel - Test a channel. params: {channel_name?} relay_post - Post message to another session type (Cowork↔Claude Code). params: {to, subject, body, priority?, context?, sender?, to_session_id?, from_session_id?, in_reply_to?, task_id?} relay_inbox - Read messages for

Parametersactionrequiredparams

nucleus_next_message

Next Message

Get the next unread relay message. One call — returns full message body and auto-acks. Long-poll (60s timeout). This is the agent's idle loop. Call it, get a message or None, act or re-call. No separate inbox + ack dance. The agent's loop: 1. nucleus_next_message() → blocks up to 60s for a message 2. If message: handle it (execute task, respond to comment, etc.) 3. Re-call nucleus_next_message() — always re-arm, never sit idle 4. Never stop the loop Role is auto-detected from posture (.brain/posture/current.json). No args needed. Returns: dict with: message: full relay message (id, from, subject, body, priority, task_id) or None acked: True if message was auto-acked waited_seconds: how long the poll ran

Parametersrecipient

nucleus_relay_subscribe

Relay Subscription

Long-poll subscription that pushes ctx.info() on each new inbox file. Replaces bash polling daemons (watch-relay-*.sh) with server-initiated push. Call once at session start (e.g. via SessionStart hook). Server holds the subscription, watches the calling agent's role-specific inbox dir, and fires info-level notifications on each new relay file arrival. Client re-calls this in a loop for persistent coverage. Per PR #1 (CCR-inversion-for-relay-pickup): `inbox_filter` parameter added to BYPASS role-based dir resolution. Use when role detection is unreliable OR when subscribing to a specific canonical inbox (e.g., 'cc_tb'). Closes 3-week-old feedback_relay_arrival_invisible_midsession HARD RULE.

Parametersroleinbox_filtertimeout_seconds

nucleus_ccr_arm

CCR Arm

One-shot convenience: resolve canonical inbox + arm long-poll subscription. Per PR #2 (CCR server-side auto-arm) — IDE-agnostic relay-arrival arming. This is the RECOMMENDED entry point for SessionStart auto-arming across all MCP clients (Claude Code, Antigravity, Cursor, Windsurf, etc.). Equivalent to: 1. resolve_canonical_inbox_name(role) → canonical inbox name 2. nucleus_relay_subscribe(inbox_filter=<canonical>, timeout_seconds=...) Why this exists vs nucleus_relay_subscribe + inbox_filter: nucleus_relay_subscribe + inbox_filter requires the caller to KNOW the canonical inbox name for their role. nucleus_ccr_arm hides that step. Agent just calls nucleus_ccr_arm() with no args; server detects role from CC_SESSION_ROLE / NUCLEUS_SESSION_ROLE env OR detect_session_role().

Parametersroletimeout_seconds

nucleus_wakeup_wait

Task Wakeup Wait

Quick scan for a PENDING task. Returns the task directly if one is available, or None if no task is ready within the timeout. Default timeout is 5s (non-blocking). The agent should NOT loop on this — tasks arrive via relay push. This is a fallback for when the agent wants to check for tasks without waiting for a relay. No args needed — the role is auto-detected from posture (.brain/posture/current.json) or NUCLEUS_AGENT_ROLES env var.

Parametersskillsagent_idauto_claimrequired_roletimeout_seconds

nucleus_orchestration

Orchestration

Satellite view, commitments, loops, patterns & metrics. Actions: satellite - Unified satellite view. params: {detail_level?} scan_commitments - Scan artifacts for new commitments archive_stale - Auto-archive commitments older than 30 days export - Export brain to zip list_commitments - List open commitments. params: {tier?} close_commitment - Close a commitment. params: {commitment_id, method} commitment_health - Get commitment health summary open_loops - View all open loops. params: {type_filter?, tier_filter?} add_loop - Add a new open loop. params: {description, loop_type?, priority?} weekly_challenge - Manage weekly challenge. params: {action?, challenge_id?} patterns - Manage learned patterns. params: {action?} metrics - Get coordination metrics pr_watch - Enumerate stale PRs (>N days), classify (auto-mergeable / billing-stuck / needs-verdict), fire one relay per stale PR to the integration coord. params: {threshold_days?, dry_run?}

Parametersactionrequiredparams

nucleus_telemetry

Telemetry

LLM tiers, telemetry, PEFS notifications & protocol tools. Actions: set_llm_tier - Set default LLM tier. params: {tier} get_llm_status - Get LLM tier configuration record_interaction - Record user interaction timestamp value_ratio - Get Value Ratio metric check_kill_switch - Check Kill Switch status pause_notifications - Pause PEFS notifications resume_notifications - Resume PEFS notifications record_feedback - Record notification feedback. params: {notification_type, score} mark_high_impact - Mark loop closure as high-impact check_protocol - Check protocol compliance. params: {agent_id} request_handoff - Request agent handoff. params: {to_agent, context, request, priority?, artifacts?} get_handoffs - Get pending handoffs. params: {agent_id?} agent_cost_dashboard - Get agent cost tracking dashboard dispatch_metrics - Get dispatch telemetry (per-action timing, error rates) rate_limit_status - Get dispatch rate limiter status (calls per facade, window)

Parametersactionrequiredparams

nucleus_slots

Slots & Sprints

Orchestration slots, sprints & mission management. Actions: orchestrate - THE GOD COMMAND. params: {slot_id?, model?, alias?, mode?} slot_complete - Mark task complete. params: {slot_id, task_id, outcome?, notes?} slot_exhaust - Mark slot exhausted. params: {slot_id, reset_hours?} status_dashboard - ASCII dashboard. params: {detail_level?} autopilot_sprint - Sprint command. params: {slots?, mode?, halt_on_blocker?, halt_on_tier_mismatch?, max_tasks_per_slot?, budget_limit?, dry_run?} force_assign - Force assign task. params: {slot_id, task_id, acknowledge_risk?} autopilot_sprint_v2 - Enhanced sprint V3.1. params: {slots?, mode?, halt_on_blocker?, halt_on_tier_mismatch?, max_tasks_per_slot?, budget_limit?, time_limit_hours?, dry_run?} start_mission - Start mission. params: {name, goal, task_ids, slot_ids?, budget_limit?, time_limit_hours?, success_criteria?} mission_status - Get mission status. params: {mission_id?} halt_sprint - Halt sprint. params: {reason?} resume_sprint - Resume sprint. params: {sprint_id?}

Parametersactionrequiredparams

nucleus_infra

Infrastructure

Infrastructure: file changes, cloud, marketing & strategy tools. Actions: file_changes - Get pending file change events gcloud_status - Check GCloud auth status gcloud_services - List Cloud Run services. params: {project?, region?} list_services - List Render.com services scan_marketing_log - Scan marketing log for failures synthesize_strategy - Analyze marketing & update strategy. params: {focus_topic?} status_report - Generate State of the Union. params: {focus?} optimize_workflow - Self-optimize workflow cheatsheet manage_strategy - Read/Update strategy doc. params: {action, content?} update_roadmap - Read/Update roadmap. params: {action, item?} growth_pulse - Full growth pipeline: brief→metrics→streak→compound. params: {write_engrams?} capture_metrics - Refresh GitHub+PyPI metrics + gate evaluation. params: {write_engram?}

Parametersactionrequiredparams

nucleus_agents

Agent Spawning

Agent spawning, critic, swarm, memory, ingestion & dashboard tools. Actions: spawn_agent - Spawn Ephemeral Agent. params: {intent, execute_now?, persona?, confirm?}. HITL: requires confirm=true. apply_critique - Apply critique fixes. params: {review_path} orchestrate_swarm - Start multi-agent swarm. params: {mission, agents?} search_memory - Search long-term memory. params: {query} read_memory - Read memory category. params: {category} respond_to_consent - Respond to respawn consent. params: {agent_id, choice?} list_pending_consents - List agents awaiting consent critique_code - Run Critic review. params: {file_path, context?} fix_code - Auto-fix code. params: {file_path, issues_context} session_briefing - Get session briefing. params: {conversation_id?} register_session - Register session focus. params: {conversation_id, focus_area, role?, tier?, charter_path?, parent_session?}. Tier ∈ {opus,sonnet,haiku}; role must start with tier prefix. handoff_task - Hand off task. params: {task_description, target_session_id?, priority?} ingest_tasks - Ingest tasks. params: {source, source_type?, session_id?, auto_assign?, skip_dedup?, dry_run?} rollback_ingestion - Rollback ingestion. params: {batch_id, reason?} ingestion_stats - Get ingestion statistics dashboard - Enhanced dashboard. params: {detail_level?, format?, include_alerts?, include_trends?, category?} snapshot_dashboard - Create dashboard snapshot. params: {name?} list_dashboard_snapshots - List snapshots. params: {limit?} get_alerts - Get active alerts set_alert_threshold - Set alert threshold. params: {metric, level, value}

Parametersactionrequiredparams

nucleus_federation

Federation

Federation management for multi-brain coordination. Actions: status - Get comprehensive federation status join - Join a federation via seed peer. params: {seed_peer} leave - Leave the federation gracefully peers - List all federation peers with details sync - Force immediate synchronization with all peers route - Route a task to the optimal brain. params: {task_id, profile?} health - Get federation health dashboard

Parametersactionrequiredparams

nucleus_engrams

Memory & Engrams

Engrams, health, observability, DSoR & tier system tools. Actions: health - Get system health status version - Get Nucleus version info export_schema - Export MCP toolset as JSON Schema performance_metrics - Get perf metrics. params: {export_to_file?} prometheus_metrics - Get Prometheus metrics. params: {format?} audit_log - View cryptographic interaction log. params: {limit?} write_engram - Write engram to memory. params: {key, value, context?, intensity?}. context: Feature|Architecture|Brand|Strategy|Decision. intensity: 1-10. (alias: "add") query_engrams - Query engrams. params: {context?, min_intensity?, limit?}. limit default 50, max 500. search_engrams - Search engrams. params: {query, case_sensitive?, limit?}. limit default 50, max 500. (alias: "search") governance_status - Get governance status morning_brief - Daily Nucleus Morning Brief hook_metrics - Monitor auto-write engram hooks compounding_status - Compounding Loop status end_of_day - Capture EOD learnings. params: {summary, key_decisions?, blockers?} session_inject - Session-start context injection weekly_consolidate - Weekly consolidation. params: {dry_run?} list_decisions - List DecisionMade events. params: {limit?} list_snapshots - List context snapshots. params: {limit?} metering_summary - Token metering summary. params: {since_hours?} ipc_tokens - List IPC auth tokens. params: {active_only?} dsor_status - Comprehensive DSoR status pulse_and_polish - God Combo: automated health check pipeline. params: {write_engram?}. Runs prometheus→audit→brief→engram. self_healing_sre - God Combo: SRE diagnosis pipeline. params: {symptom, write_engram?}. Runs search→metrics→diagnose→recommend. fusion_reactor - God Combo: self-reinforcing memory loop. params: {observation, context?, intensity?, write_engrams?}. Compounds knowledge. c

Parametersactionrequiredparams

nucleus_relay

Relay Messaging

Relay-substrate facade — post / read / ack / status. Actions: post - Send a relay envelope. params: {to, subject, body, sender?, priority?, in_reply_to?, context?, id?, from_session_id?} sender? auto-fills from your session role when omitted. to accepts short role aliases: main, peer, tb, ops, agy, board. "recipient" is accepted as an alias for "to". Returns {sent: bool, id: str (server message_id), error?: str}. inbox - List inbox messages. params: {role?, unread_only?, limit?} role auto-fills from CC_SESSION_ROLE env. Returns {messages: [...], role: str}. ack - Mark messages seen. params: {message_ids: [str], role?} Returns {acked: int, failed: int}. status - Diagnostic (no server call). params: {role?} Returns {is_http_mode, relay_url_set, bearer_set, canonical_role, resolved_inbox_dir}. Bearer resolves per-role at call-time (~/.tb/relay_token_<role>, falling back to NUCLEUS_RELAY_BEARER env) — never passed via this tool's prompt surface. Per ADR-0036 amendment c068abc1 + v0.2.1 Layer A.

Parametersactionrequiredparams

nucleus_route

Cost Router

W5 tier routing — route a prompt to the optimal model tier. Actions: route - Route a prompt to cheapest capable model. params: {prompt, complexity?, context?, estimated_output_tokens?} complexity ∈ 'routine' | 'complex' | 'sovereign' (default 'routine') Returns: provider, model, cost estimates, sovereignty tier.

Parametersactionrequiredparams

nucleus_audit

Audit Log

W8 Team-tier tamper-evident audit log (SHA-256 hash chain). Actions: log_event - Append an audit event to the chain. params: {event_type, actor, resource, outcome, metadata?, team_id?, ts?} query - Single-tenant query. Rejects team_id='*'. params: {team_id, since?, until?, actor?, event_type?, limit?, offset?} admin_query - Cross-tenant query (team_id='*' allowed). Requires NUCLEUS_AUDIT_ADMIN_TOKEN env match. Logs every successful call to the synthetic '__admin__' chain. params: {admin_token, team_id?, since?, until?, actor?, event_type?, limit?, offset?} verify - Verify SHA-256 chain integrity for a team. params: {team_id}

Parametersactionrequiredparams

nucleus_delegate

Cross-Vendor Delegate

Hand a coding or review task to a cross-vendor lane — a cheap, non-Claude agent that does the work for you. Use this INSTEAD OF shelling out to any CLI: it picks the vendor, injects the correct per-vendor permission flags, captures all output synchronously, and reports a real status. Do NOT run `agy`/`devin` yourself in Bash — the raw CLIs take DIFFERENT per-vendor flags (pass the wrong one and a build silently makes ZERO edits yet exits 0), and hand-driven background calls flush output late (a finished call looks empty for tens of seconds). This tool is the only robust path. First call `list` — it needs no setup, confirms cross-vendor is enabled, and shows each vendor's selectable_models + default_model. If dispatch/review return a disabled error, cross-vendor is OFF: run `nucleus onboard` once (one-time), then retry. Actions: dispatch - Hand a task to a cross-vendor lane. params: {vendor, prompt, artifact_ref, mode?, model?, expect_paths?, to?} REQUIRED: vendor ∈ 'agy'|'devin', prompt, artifact_ref. mode ∈ 'write'|'read' (default 'write'): write = the vendor CHANGES things (edit files, run commands, build/fix). read = the vendor only LOOKS and REPORTS (analyze/summarize); no file changes. When unsure use 'write': a read task still works in write mode, but a write task silently does NOTHING in read mode. model? — optional. Defaults to the vendor's verified model (agy → gemini-3.1-pro-high, devin → glm-5.2). These are ALREADY the defaults, so omitting model is sufficient; pass it only to be explicit or to override. The response echoes model_id — read model_id (NOT model_family) to confirm which model ran. A cross-wired model (e.g. glm-5.2 with agy) is rejected with the valid ids named. artifact_ref — a commit SHA / PR# / file path to bind the result to. No commit yet (a from-scratch build)? Pass the repo-relative path you will write, e.g. src/fo

Parametersactionrequiredparams

nucleus_lane_init

Set up an autonomous task-execution loop in a git repo. WHEN TO USE: you have a list of tasks (bugs, features, tests) you want executed automatically without manual prompting — the lane runs watcher/executor/secretary daemons that claim tasks, invoke an LLM to implement them, and independently verify the results. Use this when you want to batch-execute a backlog of well-defined tasks. Creates .brain/, SPEC.md template, and pins via git tag.

Parameterstagroleforcevendorrepo_pathspec_path

nucleus_lane_start

Start autonomous lane daemons (watcher + executor + secretary) in background. WHEN TO USE: after nucleus_lane_init and SPEC.md is written — this launches the loop that autonomously claims and executes tasks. The executor invokes an LLM CLI (devin/agy) per task; the secretary independently verifies each result. Runs until nucleus_lane_stop is called.

Parametersexecutorsrepo_pathno_watcherno_secretary

nucleus_lane_stop

Stop all running lane daemons. WHEN TO USE: when all tasks are CONFIRMED or you want to pause autonomous execution.

Parametersrepo_path

nucleus_lane_status

Check lane status: task counts (PENDING/IN_PROGRESS/DONE/CONFIRMED), daemon health, spec verification. WHEN TO USE: after starting a lane to monitor progress, or before starting to check if a lane is already running.

Parametersrepo_path

nucleus_lane_feedback

Report friction/bugs/enhancements to the nucleus team. WHEN TO USE: when the lane misbehaves, a task fails unexpectedly, the SPEC.md format is confusing, or you have an improvement idea. Creates a GitHub issue on the public nucleus-mcp repo (cross-machine visible) AND stores locally. Requires gh CLI auth'd.

Parametersbodyrequiredsubjectrequiredreporterrepo_pathfeedback_typerequired

nucleus_plan_execute

Execute a plan file autonomously. WHEN TO USE: you have a plan file (.brain/plans/*.md) you want executed autonomously — parses the plan, creates tasks, starts a mission with budget/time limits. Chains import_plan_as_tasks() then _brain_start_mission_impl() and returns the mission status string.

Parametersgoalplan_pathrequiredbudget_limittime_limit_hours

nucleus_plan_import

Import a plan file as PENDING tasks without starting a mission. WHEN TO USE: you have a plan file (.brain/plans/*.md) you want loaded into the task store so the executor daemon / sprint mission can pick the tasks up later — but you don't want to start a mission right now.

Parametersplan_pathrequired

nucleus_plan_list

List available plan files in .brain/plans with task counts. WHEN TO USE: you want to discover which plan files exist and how many tasks each contains before importing or executing one. Returns: JSON string: a list of dicts each with ``{"name", "path", "size_bytes", "task_count", "format"}``. Missing directory returns ``[]``.

Takes no parameters.

Version history

2
  1. v1.17.1LatestNov 3, 2026
  2. v1.15.2Sep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts