← Frameworks

Brick Contract

framework·published·Patent Pending· investor· academic

What It Is

A universal composable interface for agentic systems. Flat, semantically typed — identical regardless of what it wraps. A single agent, a cluster, and a value stream all expose the same I/O contract: confidence annotations, rationale fields, lifecycle metadata. The Kernel orchestrates Bricks. What is inside a Brick is irrelevant to the Kernel.

Why It Matters

Level-specific interfaces (agents, tools, chains, crews, nodes, edges) require new orchestration logic, new failure handling, and new observability at every scale transition. A scale-invariant contract collapses all levels into a single concern.

Existing frameworks use different abstractions at different levels: agents, tools, chains, crews, nodes, edges. Each transition requires new orchestration logic, new failure handling, new observability. The Brick Contract collapses all levels into a single concern. Same contract, same orchestration, same observability — at every scale. This is the Unix pipe principle with semantic structure: the pipe was powerful because it unified the interface; the Brick Contract is powerful because it unifies the interface while carrying the metadata (confidence, rationale, lifecycle) that governance requires.

Proof Points

  • Fractal invariance: identical I/O at single agent, cluster, and value stream scales
  • Semantically typed: confidence, rationale, lifecycle metadata — expressive without hierarchy
  • Challenges LangGraph, CrewAI, AutoGen interface hierarchies as accidental complexity
  • Unix pipe structural parallel with semantic governance metadata added
  • Eliminates integration tax between agent frameworks
  • Kernel orchestration is contract-based — internal implementation is opaque
  • AgentOS: 76 tests passing, TypeScript + SQLite + MCP-native
  • Patent-protected: USPTO 19/418,922

Market Position and IP

Patent-protected (USPTO 19/418,922). The only universal composable interface for agentic systems. The proliferation of agent frameworks (LangGraph, CrewAI, AutoGen, Semantic Kernel) has created a combinatorial explosion of integration surfaces. The Brick Contract establishes the interface primitive that eliminates this explosion — a single contract that subsumes all framework-specific abstractions.

Novel Research Contribution

Formalizes the conditions under which an agent interface achieves fractal invariance — the same contract at every organizational scale without information loss. Published in the brick-contract paper, this establishes that the minimum viable interface requires three semantic fields (confidence, rationale, lifecycle) beyond raw I/O to support governance composition. Fewer fields lose governance information; more fields couple the interface to implementation.

Implementation and Impact

Delivered as the core architectural principle of AgentOS. Every component — from individual tool calls to enterprise value streams — exposes the Brick Contract. Clients receive a composition architecture that does not require refactoring when scaling from prototype to production. The integration tax that dominates multi-framework deployments is eliminated at the interface level.

Links

  • Paper: brick-contract
  • Spec: AgentOS Brick Contract
  • Patent: USPTO 19/418,922

Connections

  • Imperatives: Fractal Design
  • Builds: AgentOS
  • Papers: brick-contract