Infrastructure for Agent Intelligence
Build AI agents with composable capabilities.
Memory, reasoning, time, and space are not features — they are infrastructure primitives composed through the [&] protocol. Define what your agent knows, how it decides, when it acts, and where it operates.
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.) 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 publishedA continual learning engine that makes small language models (1B–8B) get smarter over time in their deployment context. Self-evolving knowledge graphs that learn, consolidate, and prune at inference time — no retraining, no cloud dependency, no catastrophic forgetting.
Graph-based memory that grows with every interaction. Episodic, semantic, procedural, and temporal knowledge — structured relationships, not flat vectors.
Multi-timescale consolidation inspired by the brain's sleep cycles. Fast memory promotes to slow memory. Weak connections decay. Strong patterns crystallize.
MCP-first API means any AI client can connect directly. Graph-aware context injection makes every inference smarter than the last.
An open-source deliberation protocol for multi-agent AI. Structured argumentation, Byzantine fault-tolerant consensus, constitutional guardrails, and Merkle-chained evidence chains — giving agent clusters auditable, principled decisions instead of opaque confidence scores.
Extends Dung's argumentation framework into a weighted bipolar system. Agents submit formal positions with typed evidence. Attack and support relations are explicit, not implicit.
Two-phase adaptive consensus — Raft fast-path when the winner is clear, PBFT conflict-path when positions are close. Byzantine fault tolerant.
Merkle-chained evidence logs, constitutional governance with hard boundaries and soft preferences, and vindicated dissent tracking. Every decision ships a proof.
Every product connects. Every domain has a role. Together they form the operating system for agent intelligence.
COGNITIVE PRIMITIVES —
&memory &reason &time &space
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 →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.