Foundations
01 · 4 projectsUnderstand the evidence, principles, protocols, and executable specifications that explain what an agent system should do and what it can prove.
START HEREBEYOND10X
From a principle
to an action in the world.
Autonomous systems become dependable when their important decisions stop hiding in prompts and glue code. Read four ideas from the bottom up: evidence-backed principles, deterministic state, executable specifications, then governed reach.
READ BOTTOM-UP
04ConnectorsGoverned reach03AEP + ESSExecutable specifications02Entity RuntimeDeterministic mechanism01Agentic PrinciplesEvidence-backed directionEvery layer makes a different decision explicit.
ECOSYSTEM MAP
Choose a clear place to begin.
Each family answers a different question. Start with one concrete path, then follow the next boundary only when you need it.
Agent tooling & build
02 · 10 projectsBuild and test agent loops with shared libraries, plugins, isolated execution, documentation tools, and clean workspaces.
Services
03 · 10 projectsIntegrate authenticated, auditable capabilities for commands, identity, events, secrets, governed workspaces, workflows, and external systems.
Products
04 · 1 projectPreview Devcenter while it remains in active development. Start with its credential-free review mode to inspect the emerging product direction and readiness—not as a production adoption promise.
CHOOSE AN OUTCOME
Leave with something verified.
Start from what you need to accomplish. Each path names the result, the public surface that owns it, and a realistic first-run time.
Choose a rule the evidence supports
Inspect one principle, its maturity, counterevidence, and underlying study.
about 8 minStart this journeyTurn engineering intent into governed work
Install focused guidance, then create a typed planning artifact through AEP.
about 12 minStart this journeyMake system intent executable
Validate an ESS model and generate deterministic contract artifacts.
about 12 minStart this journeyRun an explicit, evidenced agent loop
Complete a read-only Harness run and retain its session evidence.
about 12 minStart this journeyExercise the governed service boundary
Submit an authenticated AEP command and inspect its state and evidence.
about 15 minStart this journeyRUN AND COMPARE AGENTS
The loop and the outside view.
Harness owns the provider-neutral agent loop. Metaharness drives harnesses from outside so their runs can be observed, steered, isolated, and compared through one interface.
developmentdocumentation
Harness
A provider-neutral agent loop with explicit tools, effects, approvals, budgets, and durable session evidence.
- agent loop
- tool approvals
- workflows
- session evidence
experimentaldocumentation
Metaharness
Drive and compare multiple agent harnesses through one observable, steerable, hermetic interface.
- harness comparison
- hermetic runs
- steering protocol
THE READING PATH
Start with what the evidence supports.
The layers grow in scope, not in ambiguity. Each owns a different question and leaves the answer inspectable for the next system—or the next human—to use.
- 01
Agentic Principles
What has the evidence earned the right to claim?
Evidence-backed direction → - 02
Entity Runtime
May this entity change state?
Deterministic mechanism → - 03
AEP + ESS
Was the work governed, and is the result conformant?
Executable specifications → - 04
Connectors
May this exact external action run?
Governed reach →
01 / EVIDENCEPUBLIC · RESEARCH
AGENTIC PRINCIPLES
Before a rule is executable, it has to earn belief.
Agentic Principles studies how agents can plan, use tools and change external state without outrunning their authority, evidence or ability to recover. The result is a reviewable research catalogue—not a list of commandments.
- Observations, reports, inferences and hypotheses remain distinct.
- Every mature claim names its mechanism, scope, counterevidence and falsifier.
- No principle is promoted from one source, transcript, benchmark or successful run.
- Product impact arrives as a testable handoff, not a silent implementation change.
Confidence is a property of the evidence trail, never the fluency of the claim.
02 / MECHANISMPUBLIC · AVAILABLE
ENTITY RUNTIME
State changes are decisions, not assignments.
Declare an entity as data: its fields, lifecycle, named operations, rules and events. An IO-free Rust kernel takes the current instance and an operation, then returns either a complete decision or a typed refusal.
definition+instance+operation+arguments→Decision
- Same inputs, same decision, same bytes.
- The kernel reads no clock, filesystem, network or random source.
- A refusal leaves the caller-owned instance untouched.
- The shell—not the kernel—persists state and publishes events.
03 / METHODPUBLIC · AVAILABLE
AEP + ESS
The work and its result become separate, testable claims.
Prompts can ask an agent to test first, protect an API or wait for approval. They cannot prove any of it happened—or that the result matches the intended system. AEP governs the engineering work; ESS specifies and checks the system. Each keeps its own model and command.
Was this built properly?
Typed workflows, capabilities, approvals, evidence, and completion predicates.
EVIDENCE↔
Is this what we meant to build?
Validated system models, deterministic artifacts, generated contracts, and conformance.
The model still reasons. AEP decides what the work's evidence permits; ESS decides whether the implementation conforms to declared system intent.
AEP Service is the public developer-preview deployment surface: a multi-tenant HTTP service for central protocol entities, activity and projections. It hosts AEP contracts over Entity Runtime. ESS remains standalone; only its closed conformance report crosses an optional AEP-side evidence adapter.
04 / REACHPUBLIC · PRE-V1
CONNECTORS
An integration is more than an HTTP request.
Connectors turns reviewed provider specifications into a deterministic catalogue, then owns the boundary an agent needs to cross: connections, credential custody, grants, bounded invocation and event delivery.
- Every operation has stable identity, declared effects and an explicit risk.
- Catalogued does not mean exposed to a model; exposure is curated.
- Credentials are requirements in contracts, never values returned to callers.
- Effect-bearing hosted calls require both identity authority and a grant.
The catalogue family, personal-local runtime and bounded hosted APIs are implemented. The full SaaS and satellite surface is not claimed. The public implementation repository owns the detailed architecture, guides, and current maturity statement.
CURRENT BOUNDARIES
A reading stack, with explicit seams.
The progression is useful because it separates concerns. Its value does not depend on pretending integrations have shipped before they have.
Principles → AEP
The research repository supplies evidence-backed principles and explicit product handoffs. AEP is one place those ideas can become executable; research maturity and implementation status remain separate claims.
Follow the evidence ↗AEP → Entity Runtime
AEP uses one pinned Entity Runtime release for its IO-free entity kernel and providers. Entity Runtime does not depend on AEP.
Explore Entity Runtime ↗ESS → optional AEP evidence
ESS emits a standalone closed conformance report. An optional AEP adapter can translate it into evidence without either core model depending on the other.
Explore ESS ↗Runtime + AEP → service
aep-service combines the published protocol contracts and runtime store interface behind a multi-tenant REST API. The service, generated OpenAPI description and operations guide are public; production identity is deliberately not claimed yet.
AEP and ESS ↛ connectors
Connectors has its own domain and authority model. It does not currently consume AEP, ESS, or Entity Runtime. Here it is the next idea in the reading path: governed work eventually needs governed reach.
CHOOSE YOUR ENTRY
Begin where your ambiguity lives.
I need to know which rule the evidence supportsStart with Principles ↗My lifecycle is hidden in codeStart with Entity Runtime ↗My engineering rules live in promptsStart with AEP ↗My system intent is proseStart with ESS ↗My protocol data needs one shared serviceTry AEP Service ↗My agents need bounded external toolsUnderstand Connectors ↑