Skip to main content
Glama

LangChain. LangGraph. CrewAI. DSPy. Claude Code skills. OpenHands. OpenClaw. Every few months the next framework drops and you migrate again.

Your notes rot too. The API you read three weeks back has changed. The doc you wrote last year is wrong now. Your AI does not even remember last week's decisions. Every new conversation starts from zero.

Now imagine one living substrate. It ingests the frameworks, the papers, the APIs, the codebases, the datasets, the decisions, the frictions. It keeps them connected in a graph the agent actually reads. It catches its own drift. It reshapes itself when your work outgrows its old form. For six months. For six years. No migration.


What it is

Myco is a living cognitive substrate for your AI agent.

Everything the agent reads or writes — code, papers, decisions, frictions — lives on your filesystem as markdown + YAML, linked into a mycelial graph. The agent eats raw material, digests it into integrated knowledge, immune-checks against drift, propagates learning across projects, and — when your work outgrows the old shape — reshapes the substrate itself. The kernel that runs all this is itself a substrate: editable by default, maintained by the same agent that uses it.

Not a framework. Not a vector DB. Not a managed service. A living filesystem for an agent you talk to.

This works now, not because the idea is new, but because agents are finally smart enough to maintain the system themselves. Earlier attempts died because humans could not keep up. Myco bakes "the maintainer is an agent" into every surface, every verb, every rule.

Related MCP server: Knowledge Graph Memory Server

How it lives

You speak. The agent listens. Between your turns, Myco runs a metabolism:

  • Ingestion. hunger asks what's missing. eat absorbs whatever you point at — a path, a URL, a paragraph. sense and forage scan what's already here.

  • Digestion. assimilate cooks raw notes into integrated knowledge. sporulate concentrates integrated notes into a dispersible proposal.

  • Circulation. traverse walks the mycelial graph for anastomotic health. propagate publishes learnings to a downstream substrate.

  • Homeostasis. immune runs a 25-dimension lint against the seven hard rules. senesce gracefully winds down each session.

  • Evolution. When the substrate's shape no longer fits — a canon field is missing, a lint dimension is needed, a verb must change — fruit drafts a three-round craft proposal, winnow gates its shape, molt ships the contract bump.

Eighteen verbs, one manifest, two faces (a CLI for observation, an MCP server for the agent). You memorize nothing; the agent drives.

Five principles

  • Only for the agent. Every surface is primary material for the agent, not documentation for a human reader.

  • Devour everything. No filter on intake. Missing a signal costs more than eating one too many.

  • Self-evolving shape. Canon, lint dimensions, verbs, the contract itself — all mutable through a governed craft loop.

  • Nothing is final. integrated is a state, not an endpoint. Today's conclusion is tomorrow's raw material.

  • Mycelium network. Every node links to every other by traversal. Orphans are dead tissue.

The kernel IS a substrate

Myco's own source tree is a substrate. _canon.yaml at the root. MYCO.md as the agent entry page. docs/primordia/ holds the three-round craft doc that justifies every contract bump. The Python code under src/myco/ is the innermost ring of its own ecosystem, not a read-only artifact someone else wrote.

So the normal install clones the source and pip install -es it. The agent that uses Myco is the same agent that maintains Myco; if it needs a new lint dimension, it scaffolds one with myco ramify, proposes with myco fruit, ships with myco molt. No fork. No waiting PR. 永恒进化.

PyPI exists for bootstrap + library-consumer use — not as the normal install.

Quick start

pipx run --spec 'myco[mcp]' myco-install fresh ~/myco

Clones the repo to ~/myco, pip install -es it, leaves you with a writable kernel. Then germinate a substrate for any project:

cd your-project
myco germinate . --substrate-id your-project

Hook Myco into your agent host in one command:

  • Claude Code — /plugin marketplace add Battam1111/Myco, then /plugin install myco@myco.

  • Claude Desktop / Cowork — myco-install host cowork writes the MCP entry, then download myco-<ver>.plugin and drag it into Claude Desktop → Settings → Plugins → Upload. Claude Desktop uploads it to your private Cowork marketplace and every subsequent session auto-installs the myco-substrate onboarding skill.

  • Any other MCP host — myco-install host <cursor | windsurf | zed | vscode | openclaw | claude-desktop | gemini-cli | codex-cli | goose>, or --all-hosts to auto-detect every host on this machine.

  • Via the official MCP Registry — io.github.Battam1111/myco for clients that auto-resolve namespaces.

Per-host snippets for the nine hosts with divergent schemas, Python-framework adapters (LangChain / CrewAI / DSPy / Smolagents / Agno / PraisonAI / MS Agent Framework / Claude Agent SDK), and library-embedding examples live in INSTALL.md.

The eighteen verbs

Six subsystems. Every name is a fungal-biology term whose meaning tracks its action.

  • Germination — germinate starts a fresh substrate.

  • Ingestion — hunger (what's missing?), eat (absorb raw), sense (keyword search), forage (scan ingestible paths).

  • Digestion — assimilate (raw → integrated), digest (promote a single note), sporulate (integrated → dispersible proposal).

  • Circulation — traverse (walk the graph), propagate (publish downstream).

  • Homeostasis — immune (25-dimension lint, --fix repairs mechanically).

  • Cycle — senesce (session dormancy), fruit (three-round craft), winnow (gate the craft), molt (ship the contract bump), ramify (scaffold new dim / verb / adapter), graft (manage substrate-local plugins), brief (human-facing state rollup).

Every verb lives in src/myco/surface/manifest.yaml. The CLI (myco VERB) and the MCP tool surface both derive from it mechanically — one source of truth for both faces. A downstream substrate can ramify its own dimensions or verbs into .myco/plugins/ without forking Myco.

Self-validation

Myco does not trust its agent to remember the contract. It enforces it.

  • 25 lint dimensions across four categories — mechanical (canon invariants, write-surface, LLM-boundary), shipped (package ↔ canon version parity), metabolic (raw backlog, stale integrated notes), semantic (graph connectedness, orphan detection). myco immune --fix repairs mechanically where it can.

  • Seven hard rules (R1–R7) govern every session — boot ritual, session-end, sense-before-assert, eat-on-friction, cross-reference-on-creation, write-surface discipline, top-down layering. Full contract at L1_CONTRACT/protocol.md.

  • Pulse sidecar. Every MCP tool response carries a substrate_pulse echoing the current contract version and a rule hint that escalates (R1 → R3 → …) as the session progresses. A server-side push: the agent cannot accidentally forget.

  • Write-surface enforcement. Any write outside _canon.yaml::system.write_surface.allowed is refused with WriteSurfaceViolation. Discipline as a mechanism, not as a request.

Zero host-side configuration. R1–R7 ride inside the MCP server itself, so every client — Claude Code, Cursor, Windsurf, Zed, Codex, Gemini, Continue, Claude Desktop, OpenClaw, OpenHands — gets the same contract on boot.

Integrations

  • Claude Code. Official plugin wires MCP + hooks + slash skills in one command. Or drop .claude/ in by hand.

  • Cowork (Claude Desktop local-agent-mode). Two-step: (1) myco-install host cowork writes the MCP server entry; (2) drag the .plugin bundle from GitHub releases into Claude Desktop's plugin upload. Claude Desktop uploads to your private Cowork marketplace, and every session auto-installs the myco-substrate onboarding skill so the agent follows R1-R7 the moment it sees _canon.yaml. Cowork doesn't expose hooks and doesn't read local plugin dirs, so drag-drop is the only persistent path — see INSTALL.md for the full rationale.

  • Any MCP host. Ten automated via myco-install; another nine with per-host snippets in INSTALL.md; any other client via mcp-server-myco over stdio.

  • Python agent frameworks. LangChain, CrewAI, DSPy, Smolagents, Agno, PraisonAI, MS Agent Framework, Claude Agent SDK all consume Myco via StdioServerParameters(command="mcp-server-myco").

  • Downstream substrates. myco propagate publishes; adapters live in myco.symbionts.

Learn more

L0_VISION.md · L1_CONTRACT/ · L2_DOCTRINE/ · INSTALL.md · CONTRIBUTING.md · Issues

Architectural changes land as dated craft docs under docs/primordia/. Every release is governed by a three-round debate, then a molt, then an auto-published fan-out to PyPI + MCP Registry + GitHub release.

MIT · LICENSE · PyPI · Releases

Available Tools

20 tools
myco_assimilateA

Promote notes from notes/raw/ to notes/integrated/ — in bulk (all eligible raw notes) or for a single named note. Integrated notes are the substrate's stable knowledge layer; raw notes are the intake queue. A bulk promotion is typical during session-end or before a release: assimilate sweeps the raw queue, re-writes filenames to the n_.md convention, and leaves raw/ empty.

Use this when: raw_backlog reported by myco_hunger is > 0 and you want to integrate the pending captures. Use with note_id= when you want to promote exactly one specific note (e.g. a high-priority decision that needs immediate visibility); for that case myco_digest is the single-note equivalent. Do NOT assimilate before the note is ready (integration is supposed to represent stable knowledge, not half-thoughts).

Side effects: moves files from notes/raw/ to notes/integrated/ (delete + create; atomic). Updates frontmatter (status, promoted_at). R6 write_surface must cover both directories. Errors on a per-note basis are collected and returned; one failed note does not abort the whole batch.

Returns: { exit_code, promoted, already_integrated, errors, outcomes: [ { status, path, dry_run, note_id } ], synced_contract_version_updated }.

Inputs: note_id, project_dir.

myco_briefA

Produce a human-facing markdown rollup of substrate state: hunger summary, immune findings, note counts by layer, recent primordia, local-plugin inventory, and a "suggested next" action list. Per L0 principle 1 ("Only For Agent"), this is the single carved exception where Myco authors human-facing prose — every other verb's output is primary material for the agent alone.

Use this when: a human operator wants to glance at substrate state (weekly / release-time check-in). For agent-to-agent reporting prefer hunger (structured) or the substrate_pulse sidecar (automatic on every verb). Do NOT use brief as an input to other verbs — it's a terminal rollup, not a structured protocol surface.

Side effects: none. Pure read. Output goes to stdout as markdown; agent / human reads, nothing is written.

Returns: { exit_code, markdown: '...' }. The markdown string is the full rollup; callers print it or surface it in UI as-is. No other fields beyond exit_code + markdown.

Inputs: project_dir.

myco_digestA

Promote exactly one raw note to integrated — the single-note equivalent of myco_assimilate. Used when you need to integrate a specific capture without sweeping the whole raw queue (e.g. a decision that must be visible now while other raw notes need more marination).

Use this when: one specific note must be integrated right now and the rest of the raw queue should stay put. For bulk promotion, use myco_assimilate (same underlying pipeline, no note_id filter).

Side effects: moves one file from notes/raw/ to notes/integrated/. Atomic. Updates frontmatter. R6 write_surface must cover both directories. Fails with exit_code 3 if note_id does not match any raw note.

Returns: { exit_code, status, path, dry_run, note_id }. status is one of: 'promoted', 'already_integrated' (no-op), or raised as UsageError.

Inputs: note_id (required), dry_run, project_dir.

myco_eatA

Ingest raw material into the substrate: one of literal text content, a local file or directory, or an http(s) URL. Writes a markdown file to notes/raw/ with frontmatter (id, source, tags, captured_at). The note enters the raw state of the substrate's metabolism — subsequent myco_assimilate or myco_digest promotes it to integrated.

Use this the MOMENT a decision, friction point, or ingestible artifact appears (R4 of the Hard Contract — "capture insights immediately"). Pass exactly ONE of content/path/url; passing none or more than one is a UsageError. For URLs, install the myco[adapters] extras (PDF, HTML, URL fetchers); the SSRF guard refuses loopback/private/reserved IP ranges (use a text/code file instead when the target is non-public). For path= pointing at a directory, one note is produced per ingestible file found by the adapter registry.

Side effects: creates 1+ files under notes/raw/ (R6-gated by write_surface). Filename pattern: _.md where slug is derived from content/path basename. Atomic O_EXCL create prevents silent overwrites on same-second collisions. merged tags = union(tags, adapter-produced tags), sorted for deterministic output.

Returns (content mode): { exit_code, path, captured_at, tags, source }. Returns (path/url mode): { exit_code, adapter, notes_created, notes: [ { path, captured_at, title, source } ] }.

Inputs: content, path, url, tags, +2 more.

myco_excreteA

Remove a single raw note from notes/raw/ when it should never have been captured: typo-paste, accidental project_dir routing, duplicate ingest, test data. The note is NOT unlinked — excrete moves it to .myco/state/excreted/.md and annotates its frontmatter with excreted_at, excreted_reason, and excreted_from, preserving an audit trail.

Use this when: you just ran myco_eat and immediately realized the content was garbage, or myco_hunger shows a raw note that should not have been captured. Do NOT use this to remove integrated or distilled notes — those are protected (R4 eat- insights + R7 top-down layering: integrated is a stable lower layer, silent deletion would rewrite history). Attempts to target notes/integrated/ or notes/distilled/ are refused with UsageError. For substantive removal of integrated material, use a myco_fruit craft proposal + myco_winnow review cycle.

Side effects: moves one file from notes/raw/ to .myco/state/excreted/. Writes the moved file with augmented frontmatter. .myco/state/ must be in R6 write_surface (added to template write_surfaces in v0.5.24; existing substrates may need to add .myco/state/** manually to _canon.yaml). Excreted tombstones are gitignored by default.

Returns: { exit_code, note_id, from_path, to_path, reason, excreted_at, dry_run }. exit_code 3 on UsageError (missing note_id, missing reason, or note not in notes/raw/); 0 on success, including dry-run.

Inputs: note_id (required), reason (required), dry_run, project_dir.

myco_forageA

Enumerate every file under the given path that a Myco adapter can ingest — the "what could myco_eat do here?" preflight. Each returned item includes file path, size, suffix, and the matching adapter's name (text-file, pdf, html, tabular, code-repo, url-fetcher).

Use this before a bulk myco_eat --path= invocation to see what will actually get ingested (and what will be silently skipped because no adapter handles it). Also useful for "what's in this directory" inventory without reading every file's content. Do NOT use this on the substrate root itself recursively — for that, prefer myco_sense or direct filesystem access; forage is for potential-intake surveys.

Side effects: none. Pure read. Adapter registry is walked in import order; more-specific adapters (PDF, HTML, URL) win over the generic text-file adapter.

Returns: { exit_code, target, count, skipped, items: [ { path, size, suffix, adapter } ] }. skipped counts files that matched no adapter (binary blobs, non-text non-code non-document files).

Inputs: path, project_dir.

myco_fruitA

Scaffold a new 3-round craft proposal doc under docs/primordia/craft.md with the canonical three-round debate structure (Round 1 claim → 1.5 self- rebuttal → Round 2 revision → 2.5 counter-rebuttal → Round 3 reflection/decision). This is how Myco governs architectural change: every contract or doctrine evolution flows through a fruiting cycle before it lands.

Use this when: an architectural change needs governance (new verb / dimension / subsystem / contract rule). The agent fills in the tensions and revisions, then myco_winnow gates the shape. Do NOT use this for feature requests or bug reports (those go in notes/raw/ via myco_eat); fruit is for substrate-level evolution decisions only.

Side effects: creates one file at docs/primordia/craft.md. R6 write_surface must cover docs/primordia/. Filename collision with existing primordium at same slug+date is an error (bump date or pick a new slug). Agent is expected to fill in the template fields after scaffolding.

Returns: { exit_code, path, slug, kind, date, rounds, status }. status is 'DRAFT' on scaffold; agent flips to 'LANDED' once winnow passes.

Inputs: topic (required), kind, date, project_dir.

myco_germinateA

Bootstrap a new Myco substrate: creates _canon.yaml (contract + identity + subsystems), MYCO.md (or the named entry-point), and .myco/state/autoseeded.txt at the target project directory. Call this once per project — for every subsequent action, other verbs take over and this one raises "substrate already exists".

Use this when: starting a brand-new substrate for a project that does not yet have _canon.yaml. Do NOT use this when: the project already has a substrate (pulse reports substrate_id), when the workspace has _canon.yaml in a parent directory (you are already inside a substrate), or when you only want to ingest into an existing substrate (use myco_eat instead).

Side effects: writes 3 files (see germination doctrine for the exact canon shape); registers the substrate in ~/.myco/substrates.yaml so myco graft --list-substrates finds it. Honors R6 write_surface (the freshly-stamped canon includes notes/, docs/, src/, .myco/ by default).

Returns: { exit_code, files_created, preview, dry_run, project_dir, substrate_id }. The preview dict shows the first line and byte count of each written file; dry_run=true returns the same shape without writing.

Inputs: project_dir (required), substrate_id (required), tags, entry_point, +1 more.

myco_graftA

Introspect the substrate's plugin surface: list every loaded dimension / adapter / schema_upgrader / overlay_verb with (kind, name, source, scope), validate plugins by re-importing under isolation, or explain a single plugin (source path + docstring). Scope classifies each plugin as 'kernel' (shipped with myco package) or 'substrate' (loaded from /.myco/plugins/).

Use this when: debugging "why is my plugin not loading", auditing what's actually registered, or listing substrates across the machine (--list-substrates mode, reads ~/.myco/substrates.yaml). Do NOT confuse with myco_immune's dimension-listing mode — graft inspects plugin binaries, immune inspects findings.

Side effects: none. Pure read. --validate mode does re-import plugins, which executes their init.py; the execution occurs in an isolated module namespace and is idempotent — safe even for plugins that register into global registries.

Returns (by mode). --list: { exit_code, mode:'list', plugins: [...], count }. --validate: { exit_code, mode: 'validate', errors: [...] }. --explain: { exit_code, mode: 'explain', name, kind, source, scope, docstring }. --list-substrates: { exit_code, mode:'list-substrates', substrates: [...], count, live_count, stale_count }.

Inputs: list, validate, explain, list_substrates, +1 more.

myco_hungerA

Compose the substrate's hunger report: contract drift (canon version mismatch), raw-note backlog (integer count of notes/raw/*.md pending assimilation), active reflex signals (HIGH/MEDIUM/LOW), concrete next-action advice, and per-kind count of substrate-local plugins. This is the R1 BOOT RITUAL — the mandatory first substantive action every session per the Hard Contract.

Use this: as the FIRST tool call of every session without exception (R1 is a contract rule, not a suggestion). Use it again mid-session whenever the agent wants a fresh state snapshot — it's cheap and idempotent. Do NOT use it as a substitute for myco_brief (which is human-facing markdown, this is agent-facing structured data).

Side effects: none by default. When execute=true, patches <entry_point>'s <!-- MYCO-BOOT-SIGNALS:BEGIN ... END --> block with the current hunger signals, respecting R6 write_surface. On abrupt exit (~1.5s kill budget, SessionEnd hook) prefer myco_senesce with quick=true; hunger itself does not auto-trigger senesce.

Returns: { exit_code, report: { contract_drift, raw_backlog, reflex_signals, advice, local_plugins: { count, count_by_kind, errors, overlay_verbs } }, execute, entry_point_patched }. The substrate_pulse sidecar then tells you which rule to honor next (advances from R1 → R3 after first hunger call).

Inputs: execute, project_dir.

myco_immuneA

Run the substrate's 50 lint dimensions and report findings (severity + category + location + message per finding). Dimensions fall in four categories: mechanical (canon invariants, write-surface coverage, LLM-boundary), shipped (package version ↔ canon version parity), metabolic (raw-note backlog, stale integrated), semantic (graph connectedness, orphan detection). Per L2 homeostasis.md, this is the substrate's autonomic health check.

Use this: routinely during development (cheap, ~1-2s), at release time (R7 top-down layering checks); with fix=true to auto-repair mechanically-fixable findings (M2 entry-point, MB1 raw_backlog). Do NOT use this to validate external code hygiene — immune only checks substrate contract invariants, not application correctness (that's what pytest is for).

Side effects: none by default. With fix=true, applies safe repairs per each dimension's fixable contract: M2 creates missing entry-point stubs, MB1 can auto-assimilate raw notes over threshold. All fixes respect R6 write_surface. List-mode

  • explain-mode are pure read.

Returns: { exit_code, findings: [...], dimensions_run, skeleton_downgrade_applied, exit_on, fix, fixes: [...] }. exit_code 0 when no critical findings; non-zero otherwise.

Inputs: dimensions, fix, list, explain, +1 more.

myco_intakeA

Walk a directory, list every adapter-ingestible file via myco_forage, then call myco_eat on each. The atomic bulk-ingest composer that replaces the v0.5.x unimplemented forage --digest-on-read flag.

Single-responsibility composition: forage stays read-only; eat stays single-note; intake is the only verb that composes both with a write side-effect.

Use this when: a fresh substrate needs to absorb an existing directory tree (a paper archive, a code repository, a meeting-log folder). Use --filter regex to select a subset; --max to cap ingest count; --dry-run to preview.

Failure semantics: per-file ingest failures produce a status: failed stub note in notes/raw/ (NOT silent skip; see L0 P2 + AD1 dim) and are reported in the result payload's failures list. --strict mode raises on any failure (exit_code=2).

Side effects: writes 0+ notes to notes/raw/ (one per ingestible file, with frontmatter status=ok|failed). R6 write_surface gated.

Returns: { exit_code, ingested, failed, failures, notes, dry_run }. Use myco_assimilate afterwards to promote the successful raws to integrated.

Inputs: path (required), filter, max, dry_run, +2 more.

myco_moltA

Ship a contract-version bump: update _canon.yaml's contract_version and synced_contract_version fields to the new value, append a stub section to docs/contract_changelog.md with placeholders, and advance waves.current counter. The atomic molt keeps all three version knobs in lockstep and produces a reviewable one-commit diff.

Use this AT RELEASE TIME, not during development. Pair with .scripts/bump_version.py which orchestrates molt alongside the package-version bump in init.py, plugin.json, and CITATION.cff. Do NOT call this mid-session for ad-hoc experiments — the contract_changelog is append-only and reverting a molt requires an explicit down-bump.

Side effects: writes _canon.yaml + docs/contract_changelog.md. R6 write_surface must cover both. Dry-run prints the diff that would be applied. Skip-molt option in bump_version.py exists for cases where the version parity step is separate from the canon stamp.

Returns: { exit_code, new_version, synced_touched, waves_touched, canon_path, changelog_path, canon_preview_head }.

Inputs: contract (required), dry_run, date, project_dir.

myco_propagateA

Copy integrated and/or distilled notes from this substrate to a downstream target substrate's notes/raw/. The receiver's agent then chooses which to assimilate — propagate is the source-side push; the receiver's own metabolism filters. Today's integrated-in-A becomes tomorrow's raw-in-B (per L0 principle 4: 永恒迭代, today's conclusion is tomorrow's raw material).

Use this when: knowledge produced in substrate A should feed substrate B (cross-project knowledge sharing). Do NOT use this as a replacement for git (propagation is a knowledge artifact movement, not version-control). The receiver must have a valid _canon.yaml at dst; propagation refuses if dst is not a substrate (no auto-germinate).

Side effects: writes 1+ files under /notes/raw/ on the DOWNSTREAM substrate (not this one). R6 write_surface check is applied to the destination substrate's canon, not the source. Dry-run available.

Returns: { exit_code, select, src_substrate_id, dst_root, count, propagated: [...source paths...], compat_warnings, dry_run, commit }.

Inputs: dst (required), select, commit, dry_run, +1 more.

myco_ramifyA

Scaffold the code skeleton for a new extension point: a manifest verb, a lint dimension, or an ingestion adapter. Writes a stub file into the appropriate location — either src/myco/ (kernel, for core Myco evolution) or /.myco/plugins/ (substrate-local, for project- specific extensions). Auto-detects substrate-local mode when the substrate is not the myco-self kernel substrate.

Use this when: an agent or operator wants to add a new verb / dimension / adapter without hand-writing boilerplate. Exactly ONE of verb/dimension/adapter must be specified; combining raises UsageError. Do NOT use this to modify existing plugins — ramify is scaffold-only, refuses to overwrite unless --force.

Side effects: creates one Python file at the computed target path. R6 write_surface must cover the target; for substrate- local mode, .myco/plugins/ must be in the substrate's write_surface. Dimension mode also requires category + severity; adapter mode requires extensions list.

Returns: { exit_code, mode, , class, category, severity, path, written, overwritten, substrate_local }.

Inputs: verb, dimension, category, severity, +5 more.

myco_senesceA

Put the session into dormancy: run a reflect pass (which may promote raw notes, update integrated frontmatter, and patch boot_brief.md). In full mode (default), also run myco_immune --fix to repair any mechanically-fixable findings the session produced. This is the R2 SESSION-END RITUAL per the Hard Contract.

Use this: at session end BEFORE compaction (PreCompact hook calls this with quick=false — full mode). On abrupt exit with a tight kill budget (~1.5s, SessionEnd hook), pass quick=true — reflect only, skip immune; the next SessionStart catches up. Do NOT skip this at session end: without senesce, the raw queue backs up across sessions and reflex signals go stale.

Side effects: may write to notes/integrated/ (promotions), boot_brief.md (signal refresh), and trigger full immune --fix in default mode (which may write to various R6-allowed paths). In quick=true mode: reflect only, no immune.

Returns: { exit_code, findings: [...], reflect: { promoted, errors, outcomes }, immune: { dimensions_run, skeleton_downgrade_applied, exit_on, fix, fixes }, mode }.

Inputs: quick, project_dir.

myco_senseA

Perform a keyword substring search across the substrate's markdown + yaml surface and return ranked hits with file path, line number, and snippet. This is the R3 SENSE-BEFORE-ASSERT mechanism: before asserting a substrate fact from training memory, the agent calls this to check ground truth from the substrate itself (R3 of the Hard Contract).

Use this before making any claim about what the substrate contains — e.g. "the substrate says X" should always be preceded by a sense call that returned a hit for X. Fast (no embedding, no LLM, no network) — this is a literal substring scan over notes/, docs/, _canon.yaml, and MYCO.md. For broader semantic search, compose multiple sense calls with different keyword synonyms rather than expanding the query.

Side effects: none. Pure read. Does not touch .myco/state/ or any cache.

Returns: { exit_code, query, scope, hits: [ { path, line, snippet } ] }. hits is ordered by path then line number; snippet is the full matching line trimmed to reasonable width. Empty hits is a successful call with no matches — agent should treat "absence of hit" as "fact not in substrate" per R3.

Inputs: query (required), project_dir.

myco_sporulateA

Produce a dispersible proposal scaffold by bundling integrated notes into a notes/distilled/d_.md document. The output is a skeleton — frontmatter + source list + empty section headers — which the agent then fills with the actual synthesis prose. Sporulate prepares the substrate's knowledge for external dispersion (propagation to other substrates, or publishing as craft proposals).

Use this when: a body of integrated notes have accumulated that belong together and you want to produce a consolidated view. Do NOT use this expecting auto-synthesis — sporulate builds the container; the agent writes the content. For cross-substrate material sharing, pair with myco_propagate. For substrate-internal contract evolution, pair with myco_fruit (which produces a 3-round craft doc instead).

Side effects: creates 1 file at notes/distilled/d_.md. R6 write_surface must cover notes/distilled/. Filename collision with an existing distilled doc at the same slug is an error (no overwrite).

Returns: { exit_code, path, slug }.

Inputs: slug (required), sources, project_dir.

myco_traverseA

Walk the substrate's cross-reference graph and report health: node count, edge count, src-node count (code files under src/), orphan nodes (no inbound references), dangling edges (point at missing targets), and per-node proposals for reconnection. Anastomosis is the fungal analogy: hyphae (markdown files + references:) fuse into a connected network; orphans + dangling edges are the dead tissue signal.

Use this: periodically (weekly / per-release cadence) to detect knowledge islands forming; before a release to verify docs haven't drifted from code; when debugging "why can't I find X" — dangling edges show what the substrate thinks exists but doesn't. Cheap and read-only — safe to run often.

Side effects: none. Writes a cached graph JSON to .myco/state/graph.json for subsequent traverse calls (bypass with internal use_cache=false). The cache is invalidated by file mtime on re-entry.

Returns: { exit_code, scope, orphans: [...], dangling: [...], proposals: [...], node_count, edge_count, src_node_count, cached }.

Inputs: scope, project_dir.

myco_winnowA

Gate a docs/primordia/ craft proposal against the craft protocol shape: 3 (or 5) rounds present, required sections (Claim / Self-Rebuttal / Revision / Counter-Rebuttal / Reflection) populated, frontmatter keys complete, body is not mostly template boilerplate (> 40% boilerplate triggers G6), etc. Returns pass/fail verdict and specific violations.

Use this: after fruit scaffolds a craft doc and the agent fills in the tensions and revisions — winnow tells whether the proposal has enough substance to land. Do NOT use winnow as a content quality check (it checks STRUCTURE, not whether the argument is good). For content review, human judgment still applies.

Side effects: none. Pure read.

Returns: { exit_code, proposal, verdict: 'pass'|'fail', round_count, body_chars, violations: [ { gate, message } ], frontmatter_keys }. exit_code 0 on pass, 1 on fail. Agents typically fix violations and re-winnow until pass before declaring a craft 'LANDED'.

Inputs: proposal (required), project_dir.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.6/5.0

    Scored across 20 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose, with no overlap. For example, myco_assimilate and myco_digest both promote notes but differ in scope (bulk vs single), and myco_eat, myco_forage, and myco_intake each serve unique roles in ingestion. The descriptions are precise enough to avoid ambiguity.

    Naming Consistency5/5

    All tools follow a consistent `myco_<verb>` snake_case pattern. The verbs are unique and descriptive (e.g., germinate, assimilate, excrete, senesce), with no mixing of styles like camelCase or inconsistent prefixes. This makes the tool set predictable and easy to navigate.

    Tool Count4/5

    With 20 tools, the set is slightly above the typical 3-15 range, but each tool earns its place for a complex knowledge management system. The scope covers lifecycle, introspection, governance, and extension, so the count feels justified rather than bloated.

    Completeness5/5

    The tool surface is thorough, covering substrate creation, ingestion, promotion, removal, synthesis, propagation, governance, introspection, and extension. No obvious gaps exist for the stated purpose of agent-driven knowledge management. Tools like myco_senesce (session end) and myco_winnow (craft gating) show attention to edge cases.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers