EMT BrAIn Edge

Cortex

Filtration, suppression and compression before the model sees context. Context budget checked every turn: 50% warn → 60% advisory → 70% block. Session traces, per-minute burn, context health and value, all read from one dataset — savings always reported net of EMT's own overhead.

Motor

Every capability is a plugin with one install lifecycle. Runtime policy gate mapped to twelve frameworks, fail-closed on error. Outcome scoring, anti-patterns, and a skill finder that proposes new skills from real usage — a person signs them off. Only 2–3 relevant capabilities surface at session start.

Memory

Tool events distilled into observations, then lessons and crystals. Fused BM25 + vector + graph recall injected before the first prompt, with on-device embeddings — no API key, no network call, no per-token cost. <private> content stripped and path rules enforced at the hook layer.

Synapse

Layer 1, deterministic: same commit in, same graph out — tree-sitter AST for TS/JS/Java/Py/Go/C#. Layer 2, model-assisted: labels stored as annotations, never merged in as parsed facts. Provenance badge on every edge; impact in seconds — what calls X, who uses Y, what a rename touches.

Stem

Passthrough to Anthropic by default; eleven upstreams (p0–p10) with a per-upstream force switch. Catalog of 31 models from 7 vendors, priced per million tokens on one editable table. The on-device pair — Kompressor and the embedding model — costs nothing per token.

• Observability Hub
  • Session browser (N instances)
  • Cost + Anomaly dashboard
  • Quality scores
  • Skill topology
  • Agent fleet
• Autonomous agents
  • Motor (300+ skills)
  • Stem (AI Studio)
  • Memory (org graph)
  • Synapse (legacy+modern)
  • Cortex (program strategy)

• Integration surface
  • 10 hook types
  • MCP stdio (5 modules)
• Orchestrated AI agents
  • Claude Code (Production — stdio MCP + 10 hooks)
  • GitHub Copilot (In progress — VS Code extension hooks)
  • OpenAI Codex (Planned — stdio MCP, hooks TBD)

• Three layers, before the model sees context.
• Filtration — cache stabilizer and shell filtration strip banners, progress noise and repeated reads.
• Suppression — sandbox execution and output suppression keep long-running processes out of the agent loop.
• Compression — code, search, log, HTML, JSON and Markdown compressed before they reach the model.
• Savings always reported net of EMT's own overhead, per pipeline layer.

• Usage — tokens, cost, cache analytics, model/language breakdown, over any range.
• Context budget — checked every turn: 50% warn → 60% advisory → 70% block.
• Cache economics — prefix cache discount tracked separately from EMT compression saving.

• Session traces — model attribution, duration, idle time, size and cost for every session.
• Session detail — per-minute burn, sub-agent transcripts, linked commits, memory captured.
• Context health — utilization and compaction behaviour by week and workspace.
• Burn report — spend attributed per model and token type, priced from the Stem catalog.
• Value — amplification, trends, session ledger and calibration — the same sessions, priced.

Everything is a plugin: Workflow → Agent(s) → Skill(s), one resolve · link · check · remove lifecycle. Semantic delivery surfaces 2–3 relevant capabilities at session start; progressive disclosure ranks by track record; every artifact is a slash command through MCP prompts.

Twelve frameworks mapped (OWASP ASI and MCP Top 10, LLM Top 10, EU AI Act, NIST AI RMF, ISO 42001/27001, SOC 2, GDPR, NSA/CISA MCP, CIS v8.1, CSA ATF). Runtime policy gate, fail-closed on error — never fail-open. Every allow/review/deny recorded; waivers carry a ticket and an expiry.

Outcome per capability (success/failed/partial, with token cost, tool calls, errors, duration), practice patterns and anti-pattern scoring, and a skill finder whose proposals a person signs off.

Tool events batched to the local model and distilled into readable observations, asynchronously, off the critical path. Repeated observations promote into lessons, then crystallize with review.

The most relevant past knowledge is injected at session start, before the first prompt. Lexical BM25, vector semantics and graph relations fused and attributed on screen.

Anything inside <private> stripped before an observation is written; privacy_rules globs permanently blocked; enforced at the hook layer, not by convention. Every write auditable in a store log.

Same commit in, same graph out. Extraction, resolution, communities, flows, impact and layering violations, offline and repeatable. Tree-sitter AST for TypeScript, JavaScript, Java, Python, Go, C#. Incremental: synapse_sync re-indexes only changed files.

Domain labels, flow confirmation and narrative stored as annotations keyed by node, never merged into the graph as parsed facts. Every annotation carries the Layer 1 fingerprint it was generated from. No key, no network, or a refused request yields unnamed domains — it degrades, it never errors.

Parsed (read directly from syntax) or inferred (resolver rule: dynamic CALL, CICS XCTL, ORM binding — about 18% of edges). The badge travels with the edge across all five screens and means the same on each.

Passthrough by default (primary option goes straight to Anthropic; every alternative is opt-in). Eleven upstreams, p0 to p10, each with its own API style and token. Per-upstream force switch on demand; overflow falls to the lowest priority still active.

31 models from 7 vendors (Anthropic, OpenAI, Google, DeepSeek, Zhipu, Moonshot, Alibaba) on one table, priced per million tokens: input, output, cache read, cache write. A model is linked to a provider from one tab only, so price and route never disagree.

Kompressor (model_int8.onnx) compresses prompt input for Cortex; an embedding model (all-MiniLM-L6-v2, Q8, 384 dimensions) embeds memory, lessons and the Synapse graph. Weights shipped by the installer (22.6 MB), nothing fetched while you search.