Engineering

The architecture in one sentence

Mycelium is a productized implementation of the architectural pattern Andrej Karpathy and Garry Tan named in 2026: plain-text portability, deterministic routing over a typed graph, skills as units of work with reproducible side effects, write-back discipline as the feedback loop, and separation of context from compute.

1. Memory store · plain-text typed graph

The memory layer is a directory of Markdown files with YAML frontmatter, version- controlled with Git. Each file carries a typed memory category (decision, exception, person, project, policy, learning, workflow, runbook) and links to other files via wikilinks. The result is a queryable typed graph.

• Storage: filesystem-native; works on any POSIX layer, any object store, any Git provider.
• Schema: JSON Schema definitions per typed category; runtime-validated on every write.
• Portability: nothing proprietary; you can clone the substrate to disk and read every byte.
• Auditability: Git log is the canonical change history; git blame answers who decided this and when.

2. RESOLVER · bi-temporal routing

Every fact in the substrate carries two timestamps: validity time(when it became true in the world) and transaction time (when it was recorded in the substrate). Queries can scope to either axis.

• What did the team know on the day the audit observation happened? Resolves over transaction time.
• What did the policy actually say last quarter? Resolves over validity time.
• How has our view of last quarter’s policy changed since? Diffs both axes.

Routing is deterministic. The same query against the same revision returns the same answer. Drift is legible because the substrate is version-controlled.

3. Skills · units of work

A skill is a directory containing a SKILL.md spec, a tool contract, and a reproducible side effect. Skills are composable: one skill can call another. Skills are testable: the eval framework runs golden-pair fixtures against every skill on CI.

• Each skill declares: trigger, input contract, output contract, and side-effect surface.
• Side effects are confined: a skill cannot write outside the typed memory directory or call out to systems beyond what its declared toolset allows.
• Compounded into workflows via the Synthesis layer (see Section 4).

4. Synthesis · autonomous SOP and memory generation

Two synthesizers ship: PR-merge to workflow SOP, and Slack-thread to typed memory entry. Each runs on a deterministic baseline with optional LLM refinement. The LLM path uses prompt caching with a 1-hour TTL on the system block; the deterministic path is the fallback when the API key is unset, the rate limit is hit, or the customer opts out of cloud LLM use entirely.

Verifiability:

• Eval framework: 5 golden-pair fixtures averaging 97.8 / 100 on the deterministic synthesizer baseline.
• CI exits non-zero if any fixture drops below threshold.
• Eval inputs and expected outputs are checked into the repository.

5. Closed-loop write-back · the feedback loop

A daemon watches a Learnings/ folder. When a refined answer or an approved decision lands there, the daemon promotes it into the appropriate procedural memory location with the right typing, the right linkage, and the right validity window. Cron-based fallback runs the same promotion path nightly as a belt-and- suspenders.

6. Multi-tenant runtime · production endpoints

The productized runtime is a private repository (commercial license). Public surface is documented; the source is available to paying pilot customers under engagement letter.

• Auth: bearer JWT scoped per tenant. Every request, every tool call, every webhook carries a tenant identifier. No cross-tenant reads, no shared state.
• Audit: append-only log of every read, write, and synthesis event with actor, tenant, timestamp, and source. Default retention 12 months, extendable to 7 years for SOX or HIPAA-adjacent buyers. Audit exports are gzipped JSONL signed with a tenant key.
• Real-time: per-tenant Server-Sent Events stream emitting ingestion, synthesis, and decision events. Backpressure-aware; reconnect-resumable.
• Webhooks: 5 receivers with HMAC validation. Async retry queue with exponential backoff. Dead-letter folder per tenant. Admin-only replay endpoint.
• Isolation:tenant data never leaves the tenant boundary. Prompts to shared LLM providers carry no other tenant’s data. Per-tenant encryption keys available on the Enterprise Pilot tier.
• Reliability: 59 of 59 pytest tests passing on CI; 11-step end-to-end integration test green on every push.

7. Connectors · current and roadmap

Six connectors live in production today: Slack, GitHub, Notion, Linear, Gmail, WhatsApp. Each connector is a skill (Section 3) that subscribes to an external system, normalizes events into the typed memory schema, writes them into the substrate idempotently, and creates decision-stub files on trigger keywords.

Three enterprise connectors ship next: Salesforce, Microsoft 365, Confluence. The Salesforce connector indexes account history, opportunity activity, and case notes. The Microsoft 365 connector indexes email, OneDrive documents, and Teams threads. The Confluence connector indexes pages, comments, and the page graph itself.

Roadmap: ServiceNow (ITSM), Workday (HR + Finance), SAP (ERP), Box (files), Google Workspace (email + docs + drive), Snowflake (data warehouse), Databricks (data + ML).

Custom connector builds are scoped on Week 0 of an Enterprise Pilot. The connector becomes a skill in your tenant; the source is shared as part of the pilot deliverable.

8. Open core · what's MIT and what's commercial

The substrate (typed-memory schemas, RESOLVER spec, skill contract, eval framework, and the open connector implementations) is open source under MIT at github.com/adelaidasofia/ai-brain-starter. You can fork it, install it, run it on a laptop in two hours.

The productized runtime (multi-tenant scoping, audit log, SSE, webhook receivers, retry queue, dead-letter routing, admin replay endpoint, the enterprise connectors) ships under a separate commercial license. Same shape as Vercel and Supabase.

9. Technical evaluation checklist

If you’re evaluating Mycelium against your existing stack, here’s the spec sheet:

• Plain-text portability. Tenant data is auditable Markdown; you keep an exportable copy.
• Bi-temporal queries. Validity time + transaction time per fact.
• Multi-tenant from day one. Per-tenant JWT, per-tenant audit, per-tenant SSE.
• HMAC-validated webhooks with exponential-backoff retry and dead-letter routing.
• Compute separation. Substrate is portable across model providers (Claude, GPT, Gemini, Llama, customer-owned).
• Public reliability artifacts: Reliability Manifesto, Three Gaps Roadmap, recovery procedure runbook.
• Eval framework with golden-pair fixtures and CI gating.
• SOC 2 Type II audit on the calendar.

10. Reach the engineering team directly

Architecture review with the founders: team@myceliumai.co. Security questionnaires and vulnerability reports: security@myceliumai.co.

← Back to the marketing site