[&] · PULSE · PRISM — the three-protocol stack
Compose capabilities. Declare loops.
Measure
learning.
[&] composes memory, reason, time, space, and govern into a single spec. PULSE declares how those capabilities cycle — retrieve, route, act, learn, consolidate — and how loops nest across agents. PRISM measures whether those loops are actually getting sharper over time. Every portfolio product ships as a PULSE-conforming, PRISM-evaluable loop.
ONE PROMPT INSTALL
Drop this prompt into Claude Code, Codex, Cursor, Zed, or any MCP-capable agent. Four npm packages, four MCP servers, four SQLite databases — box-and-box for [&] capability composition, graphonomous for the memory loop, os-prism for the diagnostic loop, os-pulse for the manifest registry. Everything installs the same way and runs fully local.
## Install the [&] three-protocol stack # 1. [&] Protocol — capability composition MCP server (validate → compose → compile) npm i -g box-and-box # 2. Memory loop — Graphonomous MCP server (retrieve → route → act → learn → consolidate) npm i -g graphonomous # 3. Diagnostic loop — PRISM MCP server (compose → interact → observe → reflect → diagnose → config) npm i -g os-prism # 4. Temporal algebra — PULSE manifest registry MCP server npm i -g os-pulse # 5. Add all four to your MCP config (~/.mcp.json or project .mcp.json) { "mcpServers": { "ampersand": { "command": "npx", "args": ["-y", "box-and-box", "--db", "~/.box-and-box/specs.db"] }, "graphonomous": { "command": "npx", "args": ["-y", "graphonomous", "--db", "~/.graphonomous/knowledge.db"] }, "prism": { "command": "npx", "args": ["-y", "os-prism", "--db", "~/.os-prism/benchmarks.db"] }, "pulse": { "command": "npx", "args": ["-y", "os-pulse", "--db", "~/.os-pulse/manifests.db"] } } } # 6. Restart your agent. [&] composes the capabilities. PULSE declares the # loops. PRISM measures them. Graphonomous remembers. No bespoke # integration, no cloud dependency, no drift.
~/.box-and-box/specs.db
·
~/.graphonomous/knowledge.db
·
~/.os-prism/benchmarks.db
·
~/.os-pulse/manifests.db. All data stays on your machine.
Our Thesis
"Models generate answers. Systems accumulate
intelligence.
Durable intelligence requires memory, evidence,
time, and interaction with the world.
(The ampersand represents composition:
agent & memory & reasoning & time & space &
govern.) Intelligence does not come from a model. It
emerges from the system those components create."
— The [&] thesis
MARKET CONVERGENCE
Every major lab and analyst firm is independently arriving at the same conclusion: AI needs memory, deliberation, and edge-native architecture. Here's what they're saying.
AI systems require multi-timescale memory: fast modules for immediate context, slow modules for long-term knowledge. Catastrophic forgetting is solved by architecture, not retraining.
Behrouz & Mirrokni, NeurIPS 2025
Multi-agent deliberation protocols — where agents argue, critique, and iterate — consistently outperform voting and single-agent approaches. Decisions need evidence chains, not scores.
Kaesberg et al., ACL 2025
Anthropic's MCP (agent-to-tool) and Google's A2A (agent-to-agent) are the foundational protocols. 40% of enterprise apps will embed AI agents by end of 2026. The [&] stack speaks both natively.
Gartner 2025; Linux Foundation AAIF
VentureBeat (Jan 2026): "Continual learning shifts rigor toward memory provenance and retention… The winners will not only pick strong models, they will build the control plane that keeps those models correct, current, and cost-efficient." — That control plane is what we're building.
THE [&] PROTOCOL
An Elixir macro DSL where agent capabilities are
compose-time verified, MCP-bound, and deployable.
The & isn't
branding — it's an operator.
capabilities [
&memory(:graphonomous),
&time(:ticktickclock),
&space(:geofleetic),
&reason(:deliberatic)
]
Each
& is a
macro that expands at compile time into an MCP
capability binding. Mismatches are caught before
deployment.
context
|> &memory.recall("incidents")
|> &time.predict(:load)
|> &space.enrich(:regions)
|> &reason.deliberate()
|> &memory.learn()
Elixir's pipe operator
|>
flows data through composed capabilities. Two
symbols for agent intelligence:
&
composes,
|>
flows.
QUICKSTART
agent "support-ops" do
capabilities [
&memory.graph(:graphonomous),
&reason.argument(:deliberatic),
&time.anomaly(:ticktickclock)
]
end$ mix ampersand.check
✓ capabilities valid
✓ contracts satisfied
✓ governance compiled
$ mix ampersand.deploy
→ deployed to webhost.systems
→ agent card published
The memory loop of the [&] stack. Five
loop-phase machines —
retrieve, route,
act, learn,
consolidate — exposed as one
MCP server with embedded SQLite + sqlite-vec.
Every turn retrieves prior context, routes on
topology, mutates the graph, learns from
outcomes, and consolidates at session
boundaries. No retraining, no cloud, no
forgetting.
Hybrid vector + graph recall returns
context plus a topology signal. When
κ > 0, route
escalates to deliberation instead of
flat generation.
Store nodes, edges, and provenance in the graph; then close the loop by reporting outcomes so confidence, reputation, and belief revision are tracked per node.
Multi-timescale consolidation merges similar nodes, strengthens recurring edges, prunes stale ones, and promotes fast memory into durable semantic structure.
The deliberation loop of the [&] stack. When
Graphonomous's route phase detects
cyclic topology
(κ > 0), it escalates
into Deliberatic — a PULSE-conformant
inner loop with its own five domain phases
gather → argue → vote → credit → seal
that runs structured argumentation, consensus,
and Merkle-chained proof before control returns
to the outer loops.
Collect typed positions and evidence from every participating agent, then run a weighted bipolar DAF to expose attack and support relations explicitly — no implicit confidence averaging.
Two-phase adaptive consensus — Raft fast-path when the winner is clear, PBFT conflict-path when positions are close. Per-agent reputation updates from outcome signals so reliable voices weigh more next round.
Archive the decision into a
Merkle-chained evidence log, emit a
DeliberationResult
CloudEvent back to Graphonomous, and
preserve vindicated dissent for review.
MACHINE LOOPS
Every [&] portfolio loop declares its own domain
phases in a PULSE manifest and groups its MCP tools
by loop-phase machine. PRISM benchmarks
Graphonomous. Graphonomous's route
phase drives Deliberatic. Each loop runs its own
vocabulary — PRISM speaks
compose/interact/observe/reflect/diagnose/config, Graphonomous speaks
retrieve/route/act/learn/consolidate,
Deliberatic speaks
gather/argue/vote/credit/seal —
but all phases map to the same five canonical PULSE
phase kinds, so composition is algebraic,
not ad-hoc.
TopologyContext,
DeliberationResult,
OutcomeSignal,
ReputationUpdate,
ConsolidationEvent). Seven invariants. A 12-test conformance suite.
Unbounded nesting depth — OS-008 Agent Harness
will add a fourth outer layer by shipping a manifest
with
inner_loops: [prism.benchmark]
— no code changes required.
Every product connects. Every domain has a role. Together they form the operating system for agent intelligence.
COGNITIVE PRIMITIVES —
&memory &reason &time &space &govern
Continual learning knowledge graphs. Self-evolving memory that makes small models brilliant — no retraining, no cloud, no forgetting.
Explore →Structured argumentation, Byzantine-tolerant consensus, and Merkle-chained evidence chains. Every decision ships a proof.
Explore →Temporal intelligence — anomaly detection, pattern prediction, and time-series continual learning via Mamba SSM.
Explore →Spatial intelligence — fleet tracking, geo-routing, and delta-CRDT state sync across distributed edge locations.
Explore →AGENT PLATFORM — build, orchestrate, distribute
Spec-driven agent development. Define
capabilities, contracts, and criteria before
building. Generates ampersand.json.
Visual agent creation. Build, test, and deploy agents with drag-and-drop capability composition.
Explore →Multi-agent coordination. Agents bid on tasks, argue fitness, and self-organize — no human orchestrator required.
Explore →
Skill marketplace. Install capabilities as
versioned packages — each skill is a packaged
ampersand.json.
RUNTIME — deploy and operate
The infrastructure agents operate on. Multi-runtime execution, immutable deploys, signed telemetry, MCP-native. The people who run the internet are becoming agents.
Explore →Agent lifecycle, permissions, tool routing, and MCP connections. Open research into machine cognition foundations.
Explore →COMPONENTS & INTEGRATIONS
The [&] stack is not a walled garden. Every portfolio loop, every third-party MCP server, and every standards body touches one of four surfaces: capability composition ([&] JSON), loop manifests (PULSE), tool interfaces (MCP + A2A), or cross-loop envelopes (CloudEvents v1). Anything that speaks those protocols plugs in.
[&] JSON · The structural core. Composes memory, reason, time, space, and govern into a single capability declaration. Validates against JSON Schema 2020-12.
PULSE manifest · Declares phases, cadence, nesting, substrates, invariants. Five canonical phase kinds. Five canonical cross-loop tokens as CloudEvents v1 envelopes.
MCP + A2A · [&] compiles into Anthropic MCP for agent-to-tool and Google A2A for agent-to-agent. Anubis MCP ships the Elixir reference server; any MCP client connects.
PRISM benchmark · Reads
any PULSE-conforming manifest, injects scenarios
at the declared retrieve
boundary, judges on 9 CL dimensions with IRT
calibration. BYOL — bring your own loop.
ARCHITECTURE
Every product in the portfolio occupies a specific layer. Together they form a complete infrastructure for AI that learns, decides, and acts.
Macro-based composition
Fault-tolerant concurrency
Real-time LiveView
Edge to enterprise
Industry-standard protocol
Local ML inference
Global edge deployment
PHILOSOPHY
"Intelligence without memory is just expensive pattern matching."
Real learning requires structured, persistent, evolvable knowledge — not bigger context windows. We build memory as a first-class infrastructure layer, not a bolted-on retrieval system.
When agents make decisions, you deserve to know why. Not a confidence score — an auditable chain of evidence, arguments, and constitutional constraints. Deliberatic exists because opacity is a liability, not a feature.
The future isn't a single trillion-parameter model running in a datacenter. It's millions of small, specialized models that get smarter in their deployment context over weeks, months, and years. Edge-native. Always learning. Never forgetting.
MCP-first. A2A-ready. Apache 2.0 where possible. We build on open standards because vendor lock-in is the opposite of interoperability, and interoperability is the whole point of an ecosystem.
The ampersand isn't branding. It's an Elixir
macro that compiles to MCP bindings, OTP
supervision trees, and WHS deploy configs.
&memory & &time & &space &
&reason
isn't a tagline — it's executable code that
produces a running, metered, fault-tolerant
agent system.
Governance doesn't come from role hierarchies — it comes from feedback structure. The κ invariant detects where mutual influence exists in a knowledge graph. Where κ = 0, data flows one way: retrieve and move on. Where κ > 0, feedback loops demand deliberation. Deliberation rights are earned by topology, not assigned by permission. Each portfolio company is a node in this governance topology — a cell with local autonomy, composed into a coherent system through the [&] Protocol.