Architecture and Design Pillars
Tangle ties together three layers most platforms separate: the workbench where work is created, the sandbox runtime where it executes, and the protocol that pays the operators who run it.
Autonomous work loop: workbench -> sandbox runtime -> protocol (payments + evaluation).
Flow: design -> execute -> evaluate -> pay. Each run generates evaluation data that feeds the next run.
What Runs Where
| Layer | Runs here | Examples |
|---|---|---|
| Workbench | Human and agent collaboration | Workflows, profiles, simulations, reviews |
| Sandbox runtime | Executed tasks and tools | Agent sessions, tool calls, file edits |
| Protocol | Coordination and settlement | Service registry, operator payments, staking, incentives |
System Architecture
1) Execution Layer
Sandboxed runtimes with isolation, resource limits, and audit logs. This is where tasks actually run.
2) Protocol Layer
The coordination plane. It handles operator discovery, payment routing, and incentive enforcement.
3) Experience Layer
The agentic workbench 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
Autonomous work only scales 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.
Design Pillars
- Isolation first: Every workload runs inside a sandbox with explicit permissions.
- Verifiable outcomes: Logs, metadata, and evaluations make results auditable.
- Composable services: Blueprints define reusable services that can be instantiated on demand.
- Economic alignment: Operators and developers earn based on usage and reliability.
- Developer leverage: Workflows are testable, repeatable, and easy to ship.