docs(positioning): align docs with agent infrastructure

components/LandingPage.tsx

@@ -12,53 +12,39 @@ const startingPoints = [
     description: "Route model requests through one API.",
     href: "/gateway",
   },
-  {
-    name: "Agent Builder",
-    state: "Hosted-assistant preview",
-    description:
-      "Planned hosted path for assistant creation and approved channels.",
-    href: null,
-  },
 ];
 
 const LandingPage = () => {
   return (
     <main className="mx-auto max-w-5xl px-5 pb-20 pt-16 sm:px-8 sm:pt-24">
       <h1 className="max-w-3xl text-4xl font-normal leading-tight text-gray-900 dark:text-white sm:text-5xl">
-        Build and run assistants on Tangle
+        Build and run AI agents on Tangle
       </h1>
       <p className="mt-6 max-w-3xl text-lg leading-relaxed text-gray-700 dark:text-gray-300">
-        Tangle provides isolated sandboxes, agent runtime, model routing,
-        integrations, and evaluation tools. Agent Builder is becoming the hosted
-        path for creating an assistant and connecting approved channels. That
-        hosted path is in preview while Builder adopts the shared kit.
+        Tangle provides five layers for AI agents: Sandbox, Runtime, Router,
+        Integrations, and observability through Intelligence. Evaluation is part
+        of each layer and the products built on them.
       </p>
 
       <section className="mt-16" aria-labelledby="start-here">
         <h2
           id="start-here"
           className="text-2xl font-semibold text-gray-900 dark:text-white"
         >
-          Choose where to start
+          Start with a live service
         </h2>
         <ul className="mt-5 divide-y divide-gray-200 border-y border-gray-200 dark:divide-gray-800 dark:border-gray-800">
           {startingPoints.map((point) => (
             <li
               key={point.name}
               className="py-6 sm:grid sm:grid-cols-[12rem_1fr_9rem] sm:gap-6"
             >
-              {point.href ? (
-                <a
-                  href={point.href}
-                  className="text-lg font-semibold text-blue-700 underline-offset-4 hover:underline dark:text-blue-300"
-                >
-                  {point.name}
-                </a>
-              ) : (
-                <span className="text-lg font-semibold text-gray-900 dark:text-white">
-                  {point.name}
-                </span>
-              )}
+              <a
+                href={point.href}
+                className="text-lg font-semibold text-blue-700 underline-offset-4 hover:underline dark:text-blue-300"
+              >
+                {point.name}
+              </a>
               <p className="mt-2 text-gray-700 dark:text-gray-300 sm:mt-0">
                 {point.description}
               </p>
@@ -70,14 +56,29 @@ const LandingPage = () => {
         </ul>
       </section>
 
-      <p className="mt-10 max-w-3xl text-gray-700 dark:text-gray-300">
-        The hospitality preview is designed to turn a guest message into an
-        assigned task and bring overdue work to a person. The complete
-        request-to-resolution flow is still being verified with a design
-        partner.
-      </p>
+      <section className="mt-10 max-w-3xl" aria-labelledby="hosted-assistants">
+        <h2
+          id="hosted-assistants"
+          className="text-2xl font-semibold text-gray-900 dark:text-white"
+        >
+          Hosted assistants are a preview
+        </h2>
+        <p className="mt-4 text-gray-700 dark:text-gray-300">
+          Tangle&apos;s first packaged use case is a hospitality assistant.
+          Agent Builder is expected to provide the creation and approved channel
+          setup path. The first completed text reply and full
+          request-to-resolution flow have not yet been verified.
+        </p>
+      </section>
       <p className="mt-5 max-w-3xl text-gray-700 dark:text-gray-300">
-        For an in-browser coding workspace, see the{" "}
+        See how the five layers fit in the{" "}
+        <a
+          className="text-blue-700 underline dark:text-blue-300"
+          href="/vision/architecture"
+        >
+          infrastructure architecture
+        </a>
+        . For an in-browser coding workspace, see the{" "}
         <a
           className="text-blue-700 underline dark:text-blue-300"
           href="/blueprint-agent/introduction"

pages/ai/index.mdx

@@ -5,9 +5,11 @@ description: Shared infrastructure for Tangle assistants and developer-built age
 
 # Agent infrastructure
 
-Tangle uses isolated sandboxes, model routing, integrations, and evaluation tools to run its hosted assistant preview.
-Developers can use the same services for their own agents.
-The managed services are live; the hospitality request-to-resolution flow is still being verified.
+Tangle builds five layers for AI agents: Sandbox, Runtime, Router, Integrations, and observability through Intelligence.
+Evaluation belongs inside each layer and product.
+Developers can use the live [Sandbox](/sandbox) and [Router](/gateway) services for their own agents.
+Hosted assistants are the first packaged use case and remain a preview.
+The first completed text reply and hospitality request-to-resolution flow have not yet been verified.
 
 ## Blueprint Agent
 
@@ -21,7 +23,7 @@ Key traits:
 - **Simulations** for evaluating workflows across many tasks.
 - **Integrations** for connecting internal tools and data.
 
-## Sandbox Runtime
+## Sandbox and Runtime
 
 Work executes inside isolated sandboxes so tasks are contained and repeatable. The runtime separates lifecycle control from execution through an orchestrator and sidecar, then applies policy and resource limits before the task runs.
 
@@ -31,14 +33,15 @@ Core capabilities:
 - **Task isolation** so background work can be reviewed and accepted before merge.
 - **Orchestrator + sidecar** separation for lifecycle control and execution.
 
-## Evaluation Loop
+## Evaluation across the layers
 
-Instrumented runs can produce traces and evaluations.
-Teams review that evidence before changing prompts, policies, and workflows.
+Instrumented runs can produce traces and evaluations from the same execution path.
+Teams can review that evidence before changing prompts, policies, and workflows.
 
 ## Router
 
-The [Tangle Router](/gateway) is the hosted inference routing layer. Agents and applications call one API, and the router applies provider policy, model selection, compliance filters, billing, and settlement rules before forwarding the request.
+The [Tangle Router](/gateway) handles model requests through supported provider APIs.
+An operator-pinned or SpendAuth request can use a registered operator route.
 
 Key capabilities:
 

pages/gateway/index.mdx

@@ -1,16 +1,18 @@
 ---
 title: Router
-description: One OpenAI-compatible API key to every model, routed across providers and Tangle operators on price, latency, and reputation.
+description: One API for supported models, with standard provider routes and explicit Tangle operator routes.
 ---
 
 # Router
 
-Tangle Inference is one OpenAI-compatible endpoint for every model. A single API key routes each request across provider APIs and registered Tangle operators, chosen on price, latency, and reputation.
+Tangle Router provides an OpenAI-compatible endpoint for supported models.
+Standard requests use supported provider APIs.
+An operator-pinned or SpendAuth request can use a registered Tangle operator.
 
-## One key for every provider and operator
+## One key for supported models
 
-- **One key, any model.** Reach OpenAI, Anthropic, Google, Groq, Mistral, and every other supported provider through a single API key. The live catalog is at [`/v1/models`](https://router.tangle.tools/v1/models).
-- **Operator network.** Route to operators registered for [Blueprints](/developers/blueprints/introduction); the gateway selects from their advertised endpoint, model support, price, latency, and reputation data.
+- **Supported provider routes.** Use one API key for models in the live [`/v1/models`](https://router.tangle.tools/v1/models) catalog.
+- **Explicit operator routes.** Use an operator-pinned request or SpendAuth for a registered [Blueprint](/developers/blueprints/introduction) operator.
 - **Compliance routing.** Zero Data Retention and no-train filtering with verified provider agreements.
 - **BYOK.** Bring your own provider keys for zero-markup access.
 - **On-chain payments.** Pay operators directly via SpendAuth, no credit card required.
@@ -28,26 +30,29 @@ curl -X POST "https://router.tangle.tools/v1/chat/completions" \
   }'
 ```
 
-Works with any OpenAI-compatible SDK. Change the base URL and you're done.
+Use an OpenAI-compatible SDK with the Router base URL for supported routes.
 
 ## Architecture
 
-The gateway routes through two tiers, in order:
+Router uses two request paths:
 
-| Tier          | What                                                            | When                                                           |
-| ------------- | --------------------------------------------------------------- | -------------------------------------------------------------- |
-| **Operators** | Tangle-registered inference operators with advertised endpoints | Default for operator-pinned requests and SpendAuth             |
-| **Direct**    | Straight to provider API (OpenAI, Anthropic, etc.)              | Default for standard requests, and when compliance is required |
+| Tier          | What                                                            | When                                    |
+| ------------- | --------------------------------------------------------------- | --------------------------------------- |
+| **Direct**    | Supported provider APIs                                         | Standard requests and compliance routes |
+| **Operators** | Tangle-registered inference operators with advertised endpoints | Operator-pinned requests and SpendAuth  |
 
 When [Zero Data Retention](/gateway/zdr) or [no-train](/gateway/no-train) is requested, operators are skipped. The gateway routes directly to verified providers only.
 
 ## Where the gateway sits
 
 ```
-Workbench (agents) → Gateway (inference) → Operators (serving) → Protocol (settlement)
+Standard request → Router → supported provider API
+Explicit route   → Router → registered operator
 ```
 
-The gateway sits between the [Workbench](/blueprint-agent/introduction) where agents run and the [Protocol](/network/overview) where operators get paid. Agents in the workbench call the gateway for model access. The gateway selects a provider or operator by price, latency, and reputation, routes the request, tracks usage, and settles payment.
+Agents can call Router for model access.
+Standard requests use supported provider APIs.
+Explicit operator routes use a registered operator and may use the [protocol](/network/overview) for settlement.
 
 ## Next steps
 

pages/index.mdx

@@ -1,6 +1,6 @@
 ---
 title: Tangle Docs
-description: Build and run assistants on Tangle with live Sandbox and Router services and a hosted-assistant preview.
+description: Tangle provides Sandbox, Runtime, Router, Integrations, and Intelligence for AI agents. Start with live Sandbox and Router services.
 ---
 
 import LandingPage from "../components/LandingPage";

pages/vision/_meta.ts

@@ -1,9 +1,9 @@
 import type { Meta } from "nextra";
 
 const meta: Meta = {
-  introduction: "Mission",
+  introduction: "Overview",
+  architecture: "Infrastructure Architecture",
   "use-cases": "Use Cases",
-  architecture: "Architecture and Design Pillars",
   "core-concepts": "Core Concepts and Terminology",
 };
 

pages/vision/architecture.mdx

@@ -1,72 +1,37 @@
-# 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.
-
-<figure>
-  <img
-    src="/images/architecture/autonomous-work-loop.svg"
-    alt="Build, run, improve loop"
-  />
-  <figcaption>
-    Build, run, improve loop: workbench -> sandbox runtime -> protocol (payments +
-    evaluation).
-  </figcaption>
-</figure>
-
-**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](/gateway) routes inference requests across provider APIs and registered operators. It handles model selection, compliance filtering ([ZDR](/gateway/zdr), [no-train](/gateway/no-train)), [BYOK](/gateway/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](https://github.com/tangle-network/blueprint/tree/main). 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.
+# Infrastructure Architecture
+
+Tangle builds five infrastructure layers for AI agents.
+Products and research systems use the same layers.
+Evaluation belongs inside each layer and product.
+
+| Layer                        | Responsibility                                                                     | Start here                                                         |
+| ---------------------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
+| Sandbox                      | Give an agent an isolated computer with files, a shell, and browser access.        | [Sandbox](/sandbox)                                                |
+| Runtime                      | Control agent sessions, execution, and streaming events in sandboxes.              | [Runtime](/infrastructure/introduction)                            |
+| Router                       | Send model requests to supported providers or explicitly selected operator routes. | [Router](/gateway)                                                 |
+| Integrations                 | Connect agents to supported tools, data, and external events.                      | [Protocol job triggers](/developers/blueprint-runner/job-triggers) |
+| Observability (Intelligence) | Collect traces so teams can inspect runs and compare changes.                      | [Intelligence](/intelligence)                                      |
+
+An application can start a session through Runtime in a Sandbox.
+The agent can call models through Router and use integrations permitted by that application.
+Intelligence can record the run's trace.
+Evaluation can check execution, routing, tool use, and the resulting product behavior against the evidence each surface produces.
+
+## Products and research
+
+The product lab builds Agent Builder, Braid, vertical apps, and hosted assistants on this infrastructure.
+Hosted assistants are the first packaged use case and remain a preview.
+The first completed text reply and request-to-resolution flow have not yet been verified.
+The research lab uses the same infrastructure for discovery and the software factory.
+
+## Managed and operator paths
+
+The managed [Sandbox](/sandbox) and [Router](/gateway) services are live.
+Standard Router requests use supported provider APIs.
+An operator-pinned or SpendAuth request can use a registered operator route.
+The [protocol](/network/overview) separately supports operator-hosted Blueprint services and on-chain settlement.
+That path requires a registered service instance and a reachable operator endpoint.
+Access to a managed service does not establish an operator service or an on-prem installation.
+
+Tangle plans to offer infrastructure that can be hosted on-prem.
+These docs do not provide an on-prem installation path today.

pages/vision/core-concepts.mdx

@@ -3,10 +3,14 @@
 Definitions for the terms used throughout Tangle's docs.
 
 - **Blueprint Agent**: An in-browser IDE where you describe a project and an AI agent builds it with you.
-- **Sandbox runtime**: The isolated execution environment where agents and services run in isolation from the host and each other.
+- **Sandbox**: An isolated computer for agent work.
+- **Runtime**: The session and execution controls for agents running in sandboxes.
+- **Router**: The model request path for supported providers and explicitly selected operator routes.
+- **Integrations**: Connections between agents and supported tools, data, or external events.
+- **Intelligence**: Observability for inspecting traces and comparing agent runs.
 - **Agent**: An AI worker running inside a sandbox.
 - **Agent profile**: A configuration that defines models, tools, budgets, and policies for an agent.
-- **Evaluation**: A structured assessment of task results, cost, and policy compliance.
+- **Evaluation**: A structured assessment of task results, cost, or policy compliance, built into layers and products.
 - **Simulation run**: A multi-variant evaluation of an agent or workflow across many tasks.
 - **Blueprint**: A reusable service template that defines interfaces, execution requirements, and expected outputs.
 - **Service instance**: A live deployment of a Blueprint, launched on demand and run by operators.