Governed Agent Runtime

Agents can act.
Can they account
for themselves?

Most agent systems were built to be capable. Pea was built to be accountable. There is a difference — and in high-stakes environments, that difference is everything.

Become a design partner Learn more
Scroll
01

Not a framework.
Not a wrapper.
A runtime.

The distinction matters. Frameworks give you components to assemble. Wrappers give you convenience over existing models. A runtime gives you a governed execution environment — one where every tool invocation, every retrieval, every decision exists inside a bounded, auditable, replayable structure.

Pea owns the lifecycle, the memory boundary, the policy gates, and the evidence trail. The agent operates inside that structure. The structure does not operate inside the agent.

"Turns prefill from loose prompt stuffing into a controlled state-management interface."

Pea treats each turn as a state transition. A thin versioned runtime signal block enters the prompt. Structured outputs return alongside user-facing text. Reducers — not the model alone — remain the canonical authority for committed state.

Memory boundary
Narrow, prompt-safe hot context with explicit governed retrieval layers
Tiered state
L1 live continuity · L2 governed current state · L3 deep evidence
Capability dispatch
One envelope, one policy gate, one telemetry schema across all tools and MCP surfaces
Transport
MCP-first with first-class open capability surface
02

Built for environments where the work has consequences.

Pea separates hot working memory from governed retrieval from deep evidence storage. It scores episodes across examination, introspection, and time — not to grade itself, but to get better slowly and reliably rather than fast and unpredictably.

Its operator surfaces let you see not just what the agent did but why, with enough context to reconstruct any decision without forensic archaeology. Every action traceable. Every retrieval governed. Every outcome scored against prior episodes so the system compounds rather than drifts.

Pea is being built to decide what should stay hot, what should become reusable current state, what should be retrieved only on demand, and how prior episodes should influence future action. That is what turns an agent into an operational layer.

"Gets better slowly and reliably rather than fast and unpredictably."

Episode evaluation
Examination · Introspection · Temporal scoring composed per episode
Sedimentation
Adaptive values shaped by repeated weighted evidence not single-event mutation
Temporal binding
Shared clock across agent family for coherent multi-agent coordination
Planning
First-class bounded plan objects with checkpoint supervision and horizon-aware cadence
03

Governance was never an afterthought.
It was the reason.

Most agent frameworks are going to face a painful retrofit moment. The enterprise market is beginning to require AI governance in earnest — auditability, traceable decision custody, bounded capability execution, human oversight surfaces. Systems built without those properties will have to add them later. That is an expensive, trust-destroying process.

Pea will not have that problem. The governance is load-bearing architecture, not cladding. Every structural decision — the unified capability envelope, the operator surfaces, the memory boundary, the policy gates, the replay architecture — maps directly onto a formal control requirement.

Pea is being built against a control matrix aligned with ISO/IEC 27001 and ISO/IEC 42001 — the information security and AI management system standards that enterprise procurement teams and regulators will increasingly require. The architecture was designed this way from the start. The certification programme formalises what was already true.

ISO/IEC 27001
ISO/IEC 42001
ISO/IEC 27701
ISO 22301

"Designed, developed, and operated within certified management systems for security and AI governance."

Audit trail
Every decision reconstructable without raw database forensics
Telemetry bundles
Structured evidence packs — not scattered logs — at hourly, daily, weekly cadence
Capability governance
Write gates, policy denials, budget controls, operator approval ledger
Human override
Explicit override ledger with refusal taxonomy and bounded degraded-mode governance
04

The runtime is real.

Not a roadmap. Not a set of architecture documents. A running system -- with real schemas, real memory stores, real operator surfaces, and real governance primitives executing against real workloads.

Development is moving fast. What is named here reflects the system at near-goals rather than a version-stamped snapshot. The primitives in the left column are live. The right column is the active build frontier.

"Gets better slowly and reliably rather than fast and unpredictably."

That principle applies to the build too. Every addition lands behind a stable seam. Nothing built now will require dismantling when the next phase arrives.

What's live
Agent runtime core
Stable layering, memory boundary, capability dispatch, transport normalization. Running on canonical SQLite and Qdrant paths.
Governed memory -- L1, L2, L3
Physical L1/L2 separation with one-way promotion and lineage tracking live. L3 vector retrieval running with governed source-class constraints and authority markers.
Decision and cache runtime
Policy snapshots, adjustment cycles, override events, cache lifecycle, and operator control surface implemented and validated.
Forward reasoning layer
Prospective horizon, planning, cadence, prefill, and tick accounting substantially complete. Episode evaluation foundations live.
What's building now
Evidence bundle exports
Structured audit packets -- traces, policy snapshots, approval records -- assembled into exportable, integrity-stamped bundles.
Enterprise onboarding programme
Shadow mode, constrained execution gates, tenant roles and approval semantics. The structured path from baseline to governed production deployment.
Vertical-specific surfaces
Jurisdiction rulesets (construction), playbook layer (legal), ITSM connectors (IT ops). Being built against stable runtime seams.
ISO certification programme
Control matrix against ISO/IEC 27001 and 42001. Architecture is aligned. Operational controls and the evidence library are the next programme.

Development velocity means this reflects near-goals rather than a precise point-in-time snapshot. The runtime primitives named here are at or approaching production readiness.

Design Partners

We are looking for a
small number of
design partners.

Not pilots. Not demos. Design partnerships — organisations who have already felt the gap between what current agent systems promise and what they deliver in production, and who want to shape the solution rather than wait for it.

If your team has hit the wall on traceability, memory integrity, or runtime control, that is exactly the problem Pea is being built to solve. The conversation starts with your problem, not our pitch.