Protocol-first infrastructure for persistent AI memory and adaptive code intelligence.
Language models are stateless by default, and codebases are harder to understand than they should be. instrumenta is a collection of open instruments built to address both problems without hiding the machinery behind vague magic.
Some parts of this repository help conversations survive across sessions and models. Other parts help developers and agents reason about real codebases as living systems.
Licensed under Apache-2.0. See LICENSE.
instrumenta currently ships two independent instruments:
sttp: Spatio-Temporal Transfer Protocol, a full stack for persistent AI memory.acc: Adaptive Codec Context, a dimensional code-intelligence system for repository indexing and analysis.
Each instrument is standalone and can be used independently.
| Instrument | Current Line | What It Does |
|---|---|---|
sttp |
1.2.x |
Persistent AI memory across MCP, network services, shared cores, and UI |
acc |
0.3.x |
Turns codebases into a dimensional graph you can query for risk, structure, and patterns |
If you only read one extra document, read the one for the instrument you care about most:
- Want the STTP overview: src/sttp/README.md
- Want STTP inside an AI assistant through MCP: src/sttp/sttp-mcp/README.md
- Want STTP as an HTTP/gRPC service: src/sttp/sttp-gateway/README.md
- Want the Rust STTP core: src/sttp/sttp-core-rs/README.md
- Want the ACC overview: src/acc/README.md
- Want ACC in VS Code: src/acc/acc-vscode/README.md
- Want ACC in Neovim: src/acc/acc-nvim/README.md
- Want ACC via CLI or MCP: src/acc/acc-cli/AccCli/README.md and src/acc/acc-mcp/AccMcpServer/README.md
This README is meant to orient you, not exhaust you.
STTP is a memory substrate for AI conversations.
The short version:
- it lets models store compressed state instead of raw chat logs
- it lets later sessions retrieve that state by relevance to the current reasoning posture
- it works across transports: MCP, HTTP, gRPC, UI, and shared libraries
- it is now sync-ready at the storage layer, but sync is still optional
If you are curious but not ready to dive deep, the main thing to understand is this: STTP is trying to preserve what remains true about a conversation, not just what was said.
| Component | What It Is |
|---|---|
| src/sttp/sttp-core | Reusable C# core library for parsing, storage, retrieval, rollups, and sync-ready primitives |
| src/sttp/sttp-core-rs | Reusable Rust core library with the same STTP and sync-ready semantics |
| src/sttp/sttp-mcp | MCP server for AI clients that want memory over stdio |
| src/sttp/sttp-gateway | Deployable C# HTTP + gRPC host |
| src/sttp/sttp-gateway-rs | Deployable Rust HTTP + gRPC host |
| src/sttp/sttp-ui | Mobile-friendly browser UI for browsing sessions and nodes |
One architectural line matters a lot:
- the STTP cores own storage and sync mechanics
- the host application owns sync policy
That means the cores can handle things like deterministic node identity, incremental changes, checkpoints, and typed provenance metadata without forcing every consumer to adopt cloud/local sync, conflict resolution rules, or connector logic.
If you never need synchronization, STTP still behaves like a normal persistent memory stack.
ACC is a code-intelligence system built around a dimensional graph model.
The short version:
- it indexes code entities and relationships into a structured graph
- it measures code along four AVEC dimensions: stability, logic, friction, and autonomy
- it exposes that graph through editor integrations, CLI tools, MCP, and dashboards
- it is built to help people and tools reason about codebases instead of treating them like opaque blobs
ACC is useful when you want answers like:
- what parts of this codebase are risky to touch?
- what depends on this symbol?
- where is complexity concentrated?
- which nodes look structurally similar?
| Surface | What It Is |
|---|---|
| src/acc/acc-vscode | VS Code extension for graph workflows inside the editor |
| src/acc/acc-nvim | Neovim plugin for terminal-native workflows |
| src/acc/acc-cli | CLI for scripts, automation, and direct querying |
| src/acc/acc-mcp | MCP server for agent integrations |
You do not need to understand the whole repository before getting value from it.
If you want persistent conversational memory inside an MCP-capable AI client, start with src/sttp/sttp-mcp/README.md.
Fast path:
docker run --rm -i -v "$PWD/sttp-data:/data" ghcr.io/entasislabs/sttp-mcp:1.2.1If you want a network host and UI, start with src/sttp/README.md.
Fast path:
cd src/sttp
docker compose upThat brings up the gateway and UI together.
If you want repository analysis, start with src/acc/README.md.
That doc will point you to the best entry path depending on whether you want VS Code, Neovim, CLI, or MCP.
git clone https://github.com/EntasisLabs/instrumenta.git
cd instrumenta- For persistent AI memory: go to src/sttp/README.md
- For code intelligence: go to src/acc/README.md
STTP full stack:
cd src/sttp
docker compose upSTTP MCP only:
docker run --rm -i -v "$PWD/sttp-data:/data" ghcr.io/entasislabs/sttp-mcp:1.2.1For anything deeper than that, the component readmes are the better source of truth.
instrumenta uses namespaced release tags per component so each stream can evolve independently.
sttp-mcp/v...sttp-gateway/v...sttp-ui/v...acc-engine/v...acc-cli/v...acc-mcp/v...acc-vscode/v...
Published examples:
- STTP images are published on GHCR
- ACC binaries and VS Code extension are published through GitHub Releases
There are three common paths:
Use src/sttp/sttp-mcp/README.md when you want an assistant to:
- calibrate its current reasoning state
- store context checkpoints
- retrieve prior context later
- list memory nodes and create rollups
Use src/sttp/sttp-gateway/README.md or src/sttp/sttp-gateway-rs/README.md when you want STTP as a service behind HTTP or gRPC.
Use src/sttp/sttp-ui/README.md when you want a session browser and node viewer on top of the gateway.
ACC has four main usage surfaces:
- VS Code for in-editor exploration
- Neovim for terminal-native workflows
- CLI for scripting and automation
- MCP for agent-facing queries
Start at src/acc/README.md, then branch into the surface you care about.
Track your sessions on the go:
Visualize your thoughts as a spider web
Add nodes on the go
Get a summary of where your mind was during that moment
Real-time ACC health tracking (Grafana):
instrumenta is organized around instruments rather than one monolithic platform.
- STTP is about persistent conversational state.
- ACC is about queryable code understanding.
- They share some conceptual language, especially AVEC, but they are not forced into one deployment or one workflow.
That separation is deliberate. You should be able to adopt one without buying into the whole universe.
- Protocol first: contracts are explicit and reusable.
- Model agnostic: the instruments are not tied to one provider or one interface.
- Infrastructure, not ideology: the goal is to give people and tools better substrate, not to bury decisions behind hype.
EntasisFlux Herald. Orchestration layer.
EntasisMemento Memory. Persistence substrate.
EntasisCortex Mind. Multi-agent intelligence.
instrumenta Tools. You are here.
AVEC is the shared dimensional vocabulary used across STTP and ACC.
- Stability: steadiness vs volatility
- Friction: resistance vs flow
- Logic: structured reasoning vs intuitive association
- Autonomy: self-directed vs guided execution
- Psi (
Psi): a scalar derived from the vector, often used as a compact signal summary - Drift class: interpretation of movement between attractor states
You do not need to master AVEC to use the tools, but it is the language the instruments use to talk about state in a compact way.
Contributions are welcome across instruments, adapters, docs, and integrations.
- Contributing guide: CONTRIBUTING.md
- STTP changelog: src/sttp/CHANGELOG.md
- Component-level docs live beside the code for each instrument
Part of the Entasis ecosystem.