Architecture and Design Pillars
Tangle ties together four layers most platforms separate: the workbench where work is created, the gateway that routes and bills inference, the sandbox runtime where it executes, and the protocol that pays the operators who run it.
Build, run, improve loop: workbench -> sandbox runtime -> protocol (payments + evaluation).
Flow: design -> execute -> evaluate -> pay. Each run captures evaluation metadata that reviewers and later runs can draw on.
What Runs Where
| Layer | Runs here | Examples |
|---|---|---|
| Workbench | Human and agent collaboration | Workflows, profiles, simulations, reviews |
| Gateway | Inference routing and billing | Model access, BYOK, ZDR compliance, operator selection |
| Sandbox runtime | Executed tasks and tools | Agent sessions, tool calls, file edits |
| Protocol | Coordination and settlement | Service registry, operator payments, staking, incentives |
The Four Layers
1) Execution Layer
Sandboxed runtimes with isolation, resource limits, and audit logs. This is where tasks actually run.
2) Inference Layer
The Gateway routes inference requests across provider APIs and registered operators. It handles model selection, compliance filtering (ZDR, no-train), BYOK credential management, and billing.
3) Protocol Layer
The coordination plane. It handles operator discovery, payment routing, and incentive enforcement.
4) Experience Layer
The Blueprint Agent and Blueprint SDK. This is where teams design workflows, run simulations, and ship services.
The SDK also includes optional gateways for integrating external events and payment-driven HTTP job execution (webhooks, x402).
Interfaces and Integration Points
Not every service fits a pure on-chain request flow. Tangle supports multiple integration styles:
- On-chain triggers: jobs and services can be created and invoked through protocol transactions.
- External triggers: operators can expose HTTP ingress (webhooks) that translate external events into job executions.
- Alternative settlement: operators can optionally accept paid HTTP job calls via x402 (stablecoin settlement on EVM chains), then translate them into job executions.
- Multi-tenant APIs: when services expose off-chain HTTP or gRPC endpoints, operators can front them with an auth proxy that injects tenant identity and enforces scopes.
Developer references:
- Job triggers map:
/developers/blueprint-runner/job-triggers - Webhooks:
/developers/blueprint-runner/webhooks - x402:
/developers/blueprint-runner/x402 - Auth proxy:
/developers/blueprint-auth
Trust and Delegation
Agents only reach production when delegation is safe. Tangle enforces policy gates before execution, emits logs and execution metadata for every run, and keeps results reviewable so teams can decide what reaches production.
What we optimize for
- Isolation first: Every workload runs inside a sandbox with explicit permissions.
- Reviewable outcomes: Logs, metadata, and evaluations give reviewers evidence about what ran and how it performed.
- Composable services: Blueprints define reusable services that can be instantiated on demand.
- Economic alignment: Operators and developers earn based on usage and reliability.
- Developer speed: Workflows are testable, repeatable, and easy to ship.