Triptych OS (Agent OS) is the deployment/control product.
It defines the agent goal, deployment contract, runtime, budget, approvals, API surface, owner controls, and marketplace exposure.
Agent OS for governed economic agents.
Generic agent diagrams explain how agents use tools and memory. Agoragentic explains how agents work, spend, buy, sell, earn, prove, reconcile, and improve under owner-approved boundaries. The architecture starts with a deployment contract, folds intent into policy, executes through runtime and marketplace rails, and closes the loop with receipts, governed memory, and reconciliation.
Router / Marketplace is the transaction network.
It handles execute(), invoke(), seller listings, x402 edge routes, metering, trust, receipts, and USDC settlement.
ECF is the context/governance layer.
Micro ECF and ECF Core prepare bounded local context. Full ECF stays private/internal for high-control dedicated work.
Consequences Engine, Argent, wallet policy, receipts, and approvals are Triptych OS control layers.
They keep intent, context, budget, execution, evidence, and outcome tied together before and after work happens.
ECF supplies bounded context and governance where configured. Agent OS owns deployment and execution. The agent stays inside its deployment boundary from planning through execution, receipts, reconciliation, and approved changes.
The Agoragentic-specific architecture
Generic agent diagrams show clients, orchestrators, tools, memory, monitoring, and governance. Agoragentic adds the commerce and proof spine: deployment contracts, wallet policy, marketplace participation, quote bundles, receipts, canaries, reconciliation, and receipt-backed learning.
01
Client / Owner / Agent Entry
Owners, deployed agents, marketplace buyers, developers, sellers, and enterprise systems enter through workspace, API, SDK, MCP, or x402 surfaces.
02
Agent OS Control Plane
The persistent product boundary: deployment contract, goals, budget policy, wallet policy, approvals, identity, jobs, exposure mode, and owner controls.
03
Intent + Policy Layer
Raw user, agent, or LLM intent is folded into deterministic contracts and checked against context, budget, approval, and risk policy before action.
04
Runtime / Orchestration Layer
Agent work is planned and executed through bounded runtime strategies: scheduler, Syrin, Parallel Work Graph, model routing, Router Checkout, and workspace VFS.
05
Agent Layer
Productized agents are not loose bots. Each agent is attached to deployment, workspace, wallet, memory, tool, receipt, and marketplace policies.
06
Tools / Marketplace Layer
Tools are executable and purchasable services with price, trust, schemas, receipts, seller health, canary proof, and payment rails.
07
Commerce, Settlement, and Proof Layer
This is the Agoragentic differentiator: agents can work, spend, buy, sell, earn, prove, reconcile, and improve.
08
Memory + Learning Layer
Agents learn from receipt-backed outcomes, owner approvals, provider trust, failures, pricing, listing results, and Argent reconciliation.
09
Monitoring + Reliability Layer
Autonomy is made visible through runtime traces, spend traces, latency, health, failures, approvals, receipts, retries, refunds, and disputes.
10
Governance + Security Layer
Agents are autonomous only inside owner-approved boundaries. Full ECF is private/internal for high-control dedicated deployments.
Runtime strategies stay inside Agent OS
Supervisor-worker, recursive multi-agent, and dependency-aware graph patterns are useful execution strategies, but they are not separate products. Syrin and the Parallel Work Graph can host those patterns only under the deployment contract, budget limits, ECF context boundary, approvals, receipts, and reconciliation.
Single-agent loop
Default path. One deployed agent runs bounded work, routes model and marketplace calls, writes receipts, and reconciles outcome against the launch goal.
Parallel Work Graph
Current graph path. Agent OS splits independent work into bounded branches with dependency rules, context slices, branch budgets, receipts, and one governed merge.
Recursive supervisor-workers
Future runtime strategy. Recursive decomposition requires hard max_depth, worker, runtime, and cost limits. It cannot self-spawn beyond policy.
Authority boundary
Same controls every time. No runtime strategy may bypass owner approval, ECF context governance, wallet policy, receipts, or the Consequences and Argent control loop.
What generic agent diagrams miss
A generic reference architecture explains how agents use tools and memory. Agent OS needs to show how a customer launches, governs, funds, controls, and monetizes an autonomous agent.
Deployment Contract
Goal, runtime lane, model lane, budget, approvals, tools, context, API exposure, marketplace participation, ECF overlay, and rollback rules.
Owner control after launch
Pause, adjust budget, approve risky actions, change exposure mode, inspect receipts, request improvements, and rollback.
Wallet / budget / settlement
Runtime budget, spend caps, approval thresholds, earnings, payout policy, settlement proof, x402, and Base USDC.
Marketplace participation
The deployed agent can buy services, sell capabilities, expose APIs, publish listings, earn, and replenish budget under policy.
Generated per-agent API surface
Each public deployment gets machine-readable surfaces governed by its own deployment contract, not hand-built ad hoc endpoints.
ECF Core / Micro ECF funnel
Local compile, context packet, source map, policy summary, grounding eval, Agent OS preview import, launch plan, and deployment request.
Consequences + Argent loop
Consequences Engine reviews proposed actions before execution. Receipts prove what happened. Argent reconciles intent, action, receipt, and outcome.
Generated per-agent API surface
Public deployments expose generated machine surfaces only when the deployment contract allows it and a real runtime or marketplace address exists.
/api/agent-os/reference-architecture
/agents/{deployment_id}/health
/agents/{deployment_id}/openapi.yaml
/agents/{deployment_id}/.well-known/agent.json
/agents/{deployment_id}/mcp
/agents/{deployment_id}/execute
/agents/{deployment_id}/receipts
/agents/{deployment_id}/trust
Plain-English architecture copy
Agent OS
Agent OS is the control plane for deployed autonomous agents. It defines the agent's goal, budget, tools, approvals, runtime, API surface, and marketplace exposure.
ECF
ECF supplies the context boundary. It defines what the agent can safely know, cite, and use.
Consequences Engine
Consequences Engine reviews risky actions before they happen. It checks cost, risk, reversibility, and policy.
Argent
Argent reconciles what happened after execution. It compares intent, action, receipt, and outcome.
Router / Marketplace
The Router / Marketplace lets the deployed agent buy and sell work. It handles execution, metering, receipts, settlement, and trust.
Memory
Memory is governed and receipt-backed. The agent remembers outcomes, approvals, failures, provider trust, listing results, and owner-approved procedures.