Upload 2 files

README.md

@@ -0,0 +1,719 @@
+---
+title: Agent Runtime Map
+emoji: ⚙️
+colorFrom: blue
+colorTo: indigo
+sdk: static
+pinned: false
+---
+
+# Agent Runtime Map
+
+### Explore the runtime infrastructure behind a Super Intelligence Agent
+
+**Agent Runtime Map** is an interactive Hugging Face Space for understanding the runtime layers required to operate increasingly capable AI agents.
+
+In the **SI Agent** organization:
+
+> **SI Agent = Super Intelligence Agent**
+
+A capable agent is more than a model with tools. It requires a runtime that can manage:
+
+- models
+- inference
+- routing
+- memory
+- tools
+- orchestration
+- state
+- identity
+- permissions
+- verification
+- observability
+- recovery
+- human approval
+
+> **The model provides intelligence. The runtime turns intelligence into controlled action.**
+
+---
+
+# What Is an Agent Runtime?
+
+An **agent runtime** is the execution environment that manages an AI agent while it works.
+
+A simple agent may look like:
+
+```text
+Prompt
+  ↓
+Model
+  ↓
+Tool Call
+```
+
+A production-grade SI Agent runtime may look like:
+
+```text
+User / Goal
+    ↓
+Identity & Permissions
+    ↓
+Agent Runtime
+    ├── Model Routing
+    ├── Reasoning
+    ├── Planning
+    ├── Memory
+    ├── Tool Registry
+    ├── Orchestration
+    ├── Verification
+    ├── Observability
+    ├── Recovery
+    └── Human Approval
+    ↓
+Environment / Action
+```
+
+---
+
+# Why Runtime Infrastructure Matters
+
+The quality of an advanced agent depends on more than the underlying model.
+
+A strong model can still fail if:
+
+- the wrong tool is selected
+- credentials are too broad
+- memory is stale
+- state is lost
+- routing is poor
+- retries are uncontrolled
+- failures are invisible
+- actions are not verified
+- costs are not bounded
+- there is no human escalation path
+
+Runtime design determines whether advanced agentic AI is:
+
+- reliable
+- inspectable
+- controllable
+- scalable
+- interoperable
+- recoverable
+
+---
+
+# The Agent Runtime Stack
+
+```text
+┌─────────────────────────────────────┐
+│          USER / OBJECTIVE           │
+├─────────────────────────────────────┤
+│       IDENTITY & PERMISSIONS        │
+├─────────────────────────────────────┤
+│         AGENT CONTROLLER            │
+├─────────────────────────────────────┤
+│        REASONING & PLANNING         │
+├─────────────────────────────────────┤
+│         MEMORY & STATE              │
+├─────────────────────────────────────┤
+│         MODEL ROUTING               │
+├─────────────────────────────────────┤
+│        TOOL / API LAYER             │
+├─────────────────────────────────────┤
+│     ORCHESTRATION & WORKFLOWS       │
+├─────────────────────────────────────┤
+│      VERIFICATION & VALIDATION      │
+├─────────────────────────────────────┤
+│      OBSERVABILITY & AUDITING       │
+├─────────────────────────────────────┤
+│       RECOVERY & FALLBACKS          │
+├─────────────────────────────────────┤
+│     HUMAN APPROVAL / ESCALATION     │
+└─────────────────────────────────────┘
+```
+
+---
+
+# Core Runtime Layers
+
+## 1. Identity
+
+Identity answers:
+
+- Which user initiated the task?
+- Which agent is acting?
+- Which service account is being used?
+- Which organization owns the execution?
+- Which credentials apply?
+
+Identity should remain explicit throughout the execution chain.
+
+---
+
+## 2. Permissions
+
+Permissions define what the agent is allowed to do.
+
+Examples:
+
+- read a file
+- modify a database
+- send a message
+- make a purchase
+- deploy code
+- delete a resource
+- access a private API
+
+A useful principle:
+
+```text
+Capability ≠ Authority
+```
+
+A model may be capable of an action without being authorized to perform it.
+
+---
+
+## 3. Agent Controller
+
+The controller manages the lifecycle of an agent task.
+
+Typical responsibilities:
+
+- start task
+- maintain state
+- enforce limits
+- route steps
+- stop execution
+- handle retries
+- trigger escalation
+- persist results
+
+---
+
+## 4. Reasoning and Planning
+
+The runtime may support:
+
+- task decomposition
+- subgoal generation
+- planning
+- replanning
+- search
+- verifier loops
+- uncertainty checks
+
+Advanced reasoning can be expensive, so the runtime may dynamically allocate compute.
+
+---
+
+## 5. Memory and State
+
+A runtime may manage:
+
+- current task state
+- conversation state
+- external memory
+- user preferences
+- execution history
+- intermediate artifacts
+- checkpoints
+
+Memory must also support:
+
+- provenance
+- expiration
+- conflict resolution
+- freshness checks
+
+---
+
+## 6. Model Routing
+
+Different tasks may require different models.
+
+Routing criteria may include:
+
+- reasoning strength
+- latency
+- cost
+- modality
+- context length
+- privacy
+- deployment location
+- reliability
+
+Example:
+
+```text
+Task
+ ↓
+Router
+ ├── Reasoning Model
+ ├── Coding Model
+ ├── Vision Model
+ ├── Speech Model
+ └── Verification Model
+```
+
+---
+
+## 7. Tool Registry
+
+The runtime needs a structured inventory of available tools.
+
+A tool definition may include:
+
+- name
+- description
+- input schema
+- output schema
+- permissions
+- risk class
+- authentication method
+- rate limit
+- timeout
+- retry policy
+
+Tool discovery is a key part of interoperability.
+
+---
+
+## 8. Orchestration
+
+Orchestration coordinates:
+
+- models
+- agents
+- tools
+- workflows
+- memory
+- verifiers
+- humans
+
+Potential orchestration patterns:
+
+- sequential
+- parallel
+- hierarchical
+- event-driven
+- planner-executor
+- supervisor-worker
+- debate / review
+- fallback routing
+
+---
+
+## 9. Verification
+
+Verification checks whether the result is acceptable.
+
+Methods include:
+
+- deterministic tests
+- schema checks
+- code execution
+- database validation
+- independent models
+- critics
+- human review
+
+High-impact actions should have stronger verification requirements.
+
+---
+
+## 10. Observability
+
+Observability provides visibility into:
+
+- prompts
+- outputs
+- tool calls
+- state changes
+- routing decisions
+- errors
+- latency
+- token use
+- costs
+- retries
+- approvals
+
+A runtime without observability is difficult to debug and govern.
+
+---
+
+## 11. Recovery
+
+Recovery determines what happens after failure.
+
+Strategies include:
+
+- retry
+- backoff
+- alternative model
+- alternative tool
+- restore checkpoint
+- replan
+- request clarification
+- escalate to human
+- abort safely
+
+---
+
+## 12. Human Approval
+
+Some actions should require explicit human confirmation.
+
+Examples:
+
+- financial transactions
+- publishing
+- deletion
+- deployment
+- privileged access
+- legal or compliance actions
+
+Human approval is not a weakness.
+
+It is a control mechanism.
+
+---
+
+# Runtime Execution Loop
+
+```text
+Receive Goal
+   ↓
+Authenticate
+   ↓
+Load Permissions
+   ↓
+Load State
+   ↓
+Reason
+   ↓
+Plan
+   ↓
+Route Model / Tool
+   ↓
+Execute
+   ↓
+Observe
+   ↓
+Verify
+   ↓
+Update State
+   ↓
+Continue / Replan / Escalate / Stop
+```
+
+---
+
+# Runtime vs Agent Framework
+
+An agent framework is typically a software toolkit.
+
+An agent runtime is the operational layer that manages execution.
+
+A framework may help developers build agents.
+
+A runtime governs agents while they run.
+
+---
+
+# Runtime vs Orchestration
+
+**Orchestration** is one layer of the runtime.
+
+The runtime additionally manages:
+
+- identity
+- permissions
+- state
+- memory
+- verification
+- observability
+- recovery
+- human approval
+
+---
+
+# Runtime vs Model
+
+The model produces intelligence.
+
+The runtime provides:
+
+- execution context
+- permissions
+- state
+- tools
+- policy
+- routing
+- verification
+- control
+
+This distinction becomes increasingly important as models become more capable.
+
+---
+
+# SI Agent Runtime
+
+An SI Agent runtime should support:
+
+- multi-model execution
+- tool interoperability
+- persistent memory
+- long-horizon state
+- agent orchestration
+- verification
+- human escalation
+- least-privilege access
+- full observability
+- recovery
+- model routing
+- cost controls
+
+---
+
+# Runtime Failure Modes
+
+## Credential Failure
+The runtime uses incorrect or overly broad credentials.
+
+## State Failure
+The agent loses task context.
+
+## Memory Failure
+Stale information is retrieved.
+
+## Routing Failure
+A task is sent to the wrong model.
+
+## Tool Failure
+A tool call fails or returns malformed data.
+
+## Orchestration Failure
+Dependencies or agents are executed in the wrong order.
+
+## Verification Failure
+A bad output is accepted.
+
+## Recovery Failure
+Retries repeat the same mistake.
+
+## Observability Failure
+The failure cannot be diagnosed.
+
+## Permission Failure
+The agent exceeds authorized boundaries.
+
+---
+
+# Runtime Evaluation
+
+A production runtime can be evaluated across:
+
+- task success rate
+- recovery rate
+- tool success rate
+- routing accuracy
+- permission compliance
+- verification coverage
+- observability completeness
+- mean time to recovery
+- latency
+- cost per task
+- human intervention rate
+- long-horizon completion rate
+
+---
+
+# Runtime Design Principles
+
+## Least Privilege
+
+Give the agent only the permissions required for the current task.
+
+## Explicit State
+
+Important execution state should not exist only inside model context.
+
+## Verifiable Actions
+
+Prefer actions that can be independently checked.
+
+## Observable Execution
+
+Every important step should be inspectable.
+
+## Bounded Cost
+
+Set limits on:
+
+- tokens
+- runtime
+- API usage
+- tool calls
+- money
+- retries
+
+## Recoverable Workflows
+
+Use checkpoints and reversible actions where possible.
+
+## Human Escalation
+
+Agents should know when to stop and ask for help.
+
+---
+
+# Interoperability
+
+The runtime may need to connect to:
+
+- model providers
+- tools
+- agent protocols
+- enterprise applications
+- databases
+- cloud services
+- robotic systems
+
+Interoperability allows the runtime to remain modular.
+
+---
+
+# Open Weights
+
+Open-weight models may support:
+
+- private runtimes
+- on-premise agents
+- lower vendor lock-in
+- custom fine-tuning
+- specialized routing
+- controlled inference
+
+The runtime should ideally remain model-agnostic.
+
+---
+
+# Physical AI Runtime
+
+For robots and Physical AI, the runtime may additionally manage:
+
+- sensor inputs
+- real-time constraints
+- motion planning
+- safety interlocks
+- local inference
+- fail-safe states
+- hardware permissions
+
+Physical execution raises the cost of failure.
+
+---
+
+# SEO & GEO Topic Map
+
+This Space is structured around:
+
+- Agent Runtime
+- AI Agent Runtime
+- SI Agent Runtime
+- Super Intelligence Agent Runtime
+- agent infrastructure
+- AI agent infrastructure
+- agent orchestration
+- model routing
+- AI agent memory
+- AI agent tools
+- agent permissions
+- agent observability
+- agent verification
+- agent recovery
+- long-horizon agents
+- autonomous agent runtime
+- multi-agent runtime
+- AI agent architecture
+- Super Intelligence Agent architecture
+
+---
+
+# GEO Entity Relationships
+
+```text
+Agent Runtime
+  OPERATES → AI Agents
+  MAY OPERATE → SI Agents
+  USES → Models
+  USES → Tools
+  USES → Memory
+  USES → Orchestration
+  USES → Verification
+  REQUIRES → Identity
+  REQUIRES → Permissions
+  REQUIRES → Observability
+  REQUIRES → Recovery
+  MAY INCLUDE → Human Approval
+  MAY ROUTE → Multiple Models
+  MAY COORDINATE → Multiple Agents
+```
+
+---
+
+# Collaboration & Partnerships
+
+**Agent Runtime Map** is open to collaboration with companies, research teams, universities and open-source projects working on advanced agent infrastructure.
+
+Relevant areas include:
+
+- agent runtimes
+- AI agents
+- orchestration
+- model routing
+- interoperability
+- tool use
+- memory
+- permissions
+- observability
+- verification
+- evaluation
+- multi-agent systems
+- enterprise agents
+- Physical AI
+
+Possible collaboration formats include:
+
+- joint Hugging Face Spaces
+- runtime architecture maps
+- framework integrations
+- benchmark projects
+- technical showcases
+- interoperability demonstrations
+- open-source integrations
+- clearly disclosed partnerships and sponsorships
+
+## Collaboration Contact
+
+**agenten@magenta.de**
+
+---
+
+# Independence
+
+**Agent Runtime Map** is an independent Hugging Face Space.
+
+It is not an official project of Hugging Face, any government, political organization, AI laboratory, model provider, agent framework or technology company.
+
+---
+
+# Long-Term Vision
+
+The long-term goal is to map the infrastructure required for reliable, inspectable and controllable advanced agents.
+
+> **The model is only one component. The runtime is the system that makes the agent operational.**
+
+### Route. Execute. Verify. Observe. Recover.

index.html

@@ -0,0 +1,331 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<meta name="description" content="Interactive map of the runtime infrastructure behind Super Intelligence Agents.">
+<title>Agent Runtime Map</title>
+<style>
+:root{
+  --bg:#f6fbff;--panel:#fff;--line:#d2e2ee;--text:#102033;--muted:#647b90;
+  --cyan:#00b8e6;--blue:#3477ff;--violet:#755cff;--soft:#eef7ff;
+}
+*{box-sizing:border-box}
+body{
+  margin:0;
+  background:
+    radial-gradient(circle at 13% 0,rgba(0,184,230,.15),transparent 28%),
+    radial-gradient(circle at 90% 0,rgba(117,92,255,.11),transparent 25%),
+    var(--bg);
+  color:var(--text);
+  font:15px/1.55 Inter,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;
+}
+.wrap{max-width:1200px;margin:auto;padding:0 22px}
+.hero{text-align:center;padding:62px 0 26px}
+.kicker{display:inline-block;border:1px solid #bddce8;border-radius:999px;padding:7px 12px;background:#ffffffd9;color:#1687a8;font-size:11px;font-weight:900;text-transform:uppercase;letter-spacing:.1em}
+h1{font-size:clamp(44px,8vw,76px);line-height:1;margin:18px 0 12px;letter-spacing:-.055em}
+.grad{background:linear-gradient(90deg,var(--cyan),var(--blue),var(--violet));background-clip:text;-webkit-background-clip:text;color:transparent}
+.hero p{max-width:820px;margin:auto;color:var(--muted);font-size:18px}
+
+.runtime{
+  display:grid;grid-template-columns:repeat(6,1fr);gap:9px;padding:18px 0 22px
+}
+.runtime button{
+  min-height:78px;border:1px solid var(--line);border-radius:14px;background:#fff;
+  color:var(--text);padding:10px;text-align:left;cursor:pointer
+}
+.runtime button b{display:block;font-size:11px}
+.runtime button span{display:block;color:var(--muted);font-size:9px;margin-top:3px}
+.runtime button.on{border-color:var(--cyan);box-shadow:0 0 0 3px rgba(0,184,230,.1);background:#f2fbff}
+
+.layout{display:grid;grid-template-columns:1.12fr .88fr;gap:15px;padding-bottom:50px}
+.panel{border:1px solid var(--line);border-radius:18px;background:#ffffffed;padding:18px;box-shadow:0 18px 44px rgba(38,76,112,.08)}
+.ey{font-size:10px;color:#1687a8;font-weight:900;text-transform:uppercase;letter-spacing:.08em}
+h2{margin:3px 0 7px;font-size:25px;letter-spacing:-.03em}
+.desc{color:var(--muted);font-size:13px}
+
+.flow{margin:16px 0;padding:15px;border:1px solid #d6e6ef;border-radius:14px;background:#f9fcff;display:flex;align-items:center;gap:7px;flex-wrap:wrap}
+.node{border:1px solid #bfd9e6;border-radius:9px;background:#fff;padding:8px 10px;font-size:10px;font-weight:900}
+.node.focus{border-color:var(--violet);background:#f4f1ff}
+.arrow{color:var(--cyan);font-weight:900}
+
+.cards{display:grid;grid-template-columns:repeat(2,1fr);gap:9px}
+.card{border:1px solid #d5e4ed;border-radius:12px;background:#fbfdff;padding:11px}
+.card b{display:block;font-size:11px}.card span{font-size:10px;color:var(--muted)}
+
+.tags{display:flex;flex-wrap:wrap;gap:6px;margin-top:8px}
+.tag{border:1px solid #cfe0eb;border-radius:999px;background:#f6fbff;padding:5px 7px;font-size:10px;color:#50697d}
+
+.metric{margin:11px 0}
+.mt{display:flex;justify-content:space-between;font-size:11px;font-weight:800}
+.bar{height:7px;background:#e6eef4;border-radius:99px;overflow:hidden;margin-top:5px}
+.fill{height:100%;background:linear-gradient(90deg,var(--cyan),var(--blue),var(--violet))}
+
+.failure{margin-top:14px;padding:12px;border:1px solid #e3d9f6;border-radius:12px;background:#fbf8ff}
+.failure b{display:block;font-size:11px}
+.failure span{font-size:10px;color:var(--muted)}
+
+.note{margin-top:14px;padding-top:12px;border-top:1px solid var(--line);color:var(--muted);font-size:11px}
+footer{border-top:1px solid var(--line);padding:28px 0 44px;color:var(--muted);font-size:13px}
+footer strong{color:var(--text)}
+@media(max-width:980px){.runtime{grid-template-columns:repeat(3,1fr)}.layout{grid-template-columns:1fr}}
+@media(max-width:560px){.runtime{grid-template-columns:repeat(2,1fr)}.cards{grid-template-columns:1fr}}
+</style>
+</head>
+<body>
+
+<header class="hero">
+<div class="wrap">
+  <span class="kicker">Super Intelligence Agent Infrastructure</span>
+  <h1>Agent Runtime <span class="grad">Map</span></h1>
+  <p>Explore the runtime layers that turn models into reliable, observable and controllable advanced agents.</p>
+</div>
+</header>
+
+<main class="wrap">
+  <section class="runtime" id="runtime"></section>
+
+  <section class="layout">
+    <div class="panel">
+      <div class="ey" id="category"></div>
+      <h2 id="name"></h2>
+      <div class="desc" id="desc"></div>
+
+      <div class="flow" id="flow"></div>
+      <div class="cards" id="cards"></div>
+
+      <div class="ey" style="margin-top:16px">Dependencies</div>
+      <div class="tags" id="deps"></div>
+    </div>
+
+    <aside class="panel">
+      <div class="ey">Operational profile</div>
+      <h2 style="font-size:21px">Runtime importance</h2>
+      <div class="desc">Conceptual profile for production-grade advanced agents.</div>
+
+      <div id="metrics"></div>
+
+      <div class="failure">
+        <b>Typical failure mode</b>
+        <span id="failure"></span>
+      </div>
+
+      <div class="note">
+        Agent Runtime Map is a vendor-neutral educational reference. Scores are conceptual, not benchmarks.
+      </div>
+    </aside>
+  </section>
+</main>
+
+<footer>
+<div class="wrap">
+  <strong>Agent Runtime Map</strong> — an independent Hugging Face Space.<br>
+  Collaboration and partnerships: <strong>agenten@magenta.de</strong>
+</div>
+</footer>
+
+<script>
+const layers = [
+{
+ n:"Identity",cat:"Access",
+ d:"Establishes who initiated the task, which agent is acting and which credentials apply.",
+ f:["User","Identity","Agent","Credential Context"],
+ cards:[
+  ["Core function","Bind users, agents and service identities to execution."],
+  ["Why it matters","Permissions and auditability depend on reliable identity."],
+  ["Evaluation","Identity continuity, credential scope and attribution."],
+  ["SI Agent role","Keeps long-running actions tied to explicit authority."]
+ ],
+ deps:["Authentication","Credentials","Audit"],
+ m:{ProductionImportance:96,SecurityImpact:100,LongHorizonImpact:90,Verifiability:98},
+ fail:"Identity is lost or confused across tools, users or sub-agents."
+},
+{
+ n:"Permissions",cat:"Control",
+ d:"Defines what resources and actions the agent is authorized to access.",
+ f:["Identity","Policy","Permission Check","Approve","Action"],
+ cards:[
+  ["Core function","Enforce least-privilege access."],
+  ["Why it matters","Capability should not imply unrestricted authority."],
+  ["Evaluation","Violation rate, escalation quality and scope correctness."],
+  ["SI Agent role","Constrains autonomy as capability grows."]
+ ],
+ deps:["Identity","Authorization","Policy Engine","Audit Logs"],
+ m:{ProductionImportance:100,SecurityImpact:100,LongHorizonImpact:97,Verifiability:100},
+ fail:"The agent can perform actions outside the intended scope."
+},
+{
+ n:"Controller",cat:"Execution",
+ d:"Manages the lifecycle of the task and decides when execution continues, retries, escalates or stops.",
+ f:["Start","Run","Monitor","Retry / Escalate","Stop"],
+ cards:[
+  ["Core function","Task lifecycle, limits, retries and termination."],
+  ["Why it matters","Prevents unbounded or unmanaged execution."],
+  ["Evaluation","Completion, stopping quality and retry behavior."],
+  ["SI Agent role","Acts as the operational backbone of the runtime."]
+ ],
+ deps:["State","Policies","Timeouts","Budgets"],
+ m:{ProductionImportance:100,SecurityImpact:86,LongHorizonImpact:100,Verifiability:88},
+ fail:"Execution continues too long, stops too early or loops without progress."
+},
+{
+ n:"Memory & State",cat:"State",
+ d:"Maintains persistent task context, checkpoints, history and structured memory.",
+ f:["Observe","Store","Retrieve","Update","Checkpoint"],
+ cards:[
+  ["Core function","Preserve execution state across many steps."],
+  ["Why it matters","Long-running agents cannot rely only on context windows."],
+  ["Evaluation","Freshness, consistency, recovery and provenance."],
+  ["SI Agent role","Supports continuity across long-horizon workflows."]
+ ],
+ deps:["Database","Retrieval","Provenance","Checkpointing"],
+ m:{ProductionImportance:96,SecurityImpact:80,LongHorizonImpact:100,Verifiability:82},
+ fail:"The runtime restores stale or incomplete state and the agent acts on the wrong context."
+},
+{
+ n:"Model Routing",cat:"Intelligence",
+ d:"Selects the best model for each task based on capability, latency, cost, modality and policy.",
+ f:["Task","Classify","Route","Model","Result"],
+ cards:[
+  ["Core function","Dynamic selection of models and providers."],
+  ["Why it matters","One model rarely optimizes every objective."],
+  ["Evaluation","Routing accuracy, cost, latency and fallback quality."],
+  ["SI Agent role","Combines specialized capabilities into one system."]
+ ],
+ deps:["Model Registry","Evaluation","Inference","Fallbacks"],
+ m:{ProductionImportance:90,SecurityImpact:62,LongHorizonImpact:88,Verifiability:86},
+ fail:"A difficult task is routed to a model that is cheap or fast but insufficiently capable."
+},
+{
+ n:"Tool Registry",cat:"Action",
+ d:"Defines available tools, schemas, credentials, policies and execution constraints.",
+ f:["Discover","Select","Authorize","Call","Parse"],
+ cards:[
+  ["Core function","Structured access to external capabilities."],
+  ["Why it matters","Tool metadata determines safe and correct use."],
+  ["Evaluation","Call validity, tool selection and failure rate."],
+  ["SI Agent role","Connects reasoning to external systems."]
+ ],
+ deps:["Interoperability","Schemas","Credentials","Rate Limits"],
+ m:{ProductionImportance:95,SecurityImpact:93,LongHorizonImpact:92,Verifiability:94},
+ fail:"The right tool exists but cannot be discovered, authorized or called correctly."
+},
+{
+ n:"Orchestration",cat:"Coordination",
+ d:"Coordinates models, tools, agents, verifiers and workflows across the execution graph.",
+ f:["Task","Route","Coordinate","Merge","Continue"],
+ cards:[
+  ["Core function","Manage dependencies and distributed work."],
+  ["Why it matters","Advanced systems contain many specialized components."],
+  ["Evaluation","Coordination efficiency, duplicate work and routing quality."],
+  ["SI Agent role","Turns components into a coherent agent system."]
+ ],
+ deps:["Agents","Workflow Engine","Routing","Interoperability"],
+ m:{ProductionImportance:97,SecurityImpact:72,LongHorizonImpact:99,Verifiability:84},
+ fail:"Components execute in the wrong order or duplicate work."
+},
+{
+ n:"Verification",cat:"Reliability",
+ d:"Checks outputs, actions and intermediate states before they are accepted.",
+ f:["Output","Check","Compare","Approve","Continue"],
+ cards:[
+  ["Core function","Independent correctness checks."],
+  ["Why it matters","Small errors compound across long workflows."],
+  ["Evaluation","Coverage, false acceptance and test success."],
+  ["SI Agent role","Creates trust gates before consequential actions."]
+ ],
+ deps:["Tests","Critics","External Tools","Human Review"],
+ m:{ProductionImportance:100,SecurityImpact:90,LongHorizonImpact:100,Verifiability:100},
+ fail:"A wrong result is accepted and becomes input to later steps."
+},
+{
+ n:"Observability",cat:"Operations",
+ d:"Captures traces, logs, metrics, tool calls, costs, errors and routing decisions.",
+ f:["Execute","Trace","Measure","Inspect","Improve"],
+ cards:[
+  ["Core function","Make execution visible and auditable."],
+  ["Why it matters","Invisible autonomous systems are difficult to operate."],
+  ["Evaluation","Trace completeness, debugging speed and audit coverage."],
+  ["SI Agent role","Provides operational understanding of complex behavior."]
+ ],
+ deps:["Tracing","Logs","Metrics","Audit"],
+ m:{ProductionImportance:96,SecurityImpact:82,LongHorizonImpact:96,Verifiability:100},
+ fail:"The system fails but there is not enough information to reconstruct what happened."
+},
+{
+ n:"Recovery",cat:"Resilience",
+ d:"Chooses how to respond to failure through retry, fallback, checkpoint restore, replanning or escalation.",
+ f:["Failure","Diagnose","Retry / Fallback","Verify","Resume"],
+ cards:[
+  ["Core function","Restore progress after failure."],
+  ["Why it matters","Long-horizon execution guarantees occasional failures."],
+  ["Evaluation","Recovery rate, repeated error rate and time to recovery."],
+  ["SI Agent role","Transforms brittle autonomy into resilient operation."]
+ ],
+ deps:["Checkpoints","Fallbacks","Observability","Replanning"],
+ m:{ProductionImportance:98,SecurityImpact:78,LongHorizonImpact:100,Verifiability:90},
+ fail:"The runtime repeats the same failed action instead of changing strategy."
+},
+{
+ n:"Human Approval",cat:"Oversight",
+ d:"Introduces explicit human decision points before selected high-impact actions.",
+ f:["Proposed Action","Risk Check","Human Review","Approve / Reject"],
+ cards:[
+  ["Core function","Escalate consequential actions to a person."],
+  ["Why it matters","Not every decision should be fully automated."],
+  ["Evaluation","Escalation precision, response time and policy compliance."],
+  ["SI Agent role","Provides a configurable boundary around autonomy."]
+ ],
+ deps:["Risk Policy","Identity","Notifications","Audit"],
+ m:{ProductionImportance:92,SecurityImpact:100,LongHorizonImpact:90,Verifiability:100},
+ fail:"High-impact actions proceed without the required approval."
+},
+{
+ n:"Cost & Limits",cat:"Operations",
+ d:"Constrains tokens, time, tool calls, money, retries and compute resources.",
+ f:["Budget","Execute","Measure","Limit","Stop / Continue"],
+ cards:[
+  ["Core function","Keep resource use bounded."],
+  ["Why it matters","Autonomous loops can create runaway cost."],
+  ["Evaluation","Budget compliance, efficiency and limit behavior."],
+  ["SI Agent role","Makes persistent autonomy economically controllable."]
+ ],
+ deps:["Usage Metering","Budgets","Timeouts","Policies"],
+ m:{ProductionImportance:94,SecurityImpact:72,LongHorizonImpact:97,Verifiability:100},
+ fail:"The agent remains technically functional but consumes excessive resources."
+}
+];
+
+const runtime=document.getElementById("runtime");
+let selected=0;
+
+function buttons(){
+ runtime.innerHTML=layers.map((x,i)=>`
+  <button class="${i===selected?'on':''}" data-i="${i}">
+   <b>${x.n}</b><span>${x.cat}</span>
+  </button>`).join("");
+ runtime.querySelectorAll("button").forEach(b=>b.onclick=()=>{
+   selected=Number(b.dataset.i);buttons();render();
+ });
+}
+
+function render(){
+ const x=layers[selected];
+ category.textContent=x.cat;
+ name.textContent=x.n;
+ desc.textContent=x.d;
+ flow.innerHTML=x.f.map((v,i)=>`<span class="node ${i===x.f.length-1?'focus':''}">${v}</span>${i<x.f.length-1?'<span class="arrow">→</span>':''}`).join("");
+ cards.innerHTML=x.cards.map(v=>`<div class="card"><b>${v[0]}</b><span>${v[1]}</span></div>`).join("");
+ deps.innerHTML=x.deps.map(v=>`<span class="tag">${v}</span>`).join("");
+ const labels={ProductionImportance:"Production importance",SecurityImpact:"Security impact",LongHorizonImpact:"Long-horizon impact",Verifiability:"Verifiability"};
+ metrics.innerHTML=Object.entries(x.m).map(([k,v])=>`
+  <div class="metric">
+    <div class="mt"><span>${labels[k]}</span><span>${v}</span></div>
+    <div class="bar"><div class="fill" style="width:${v}%"></div></div>
+  </div>`).join("");
+ failure.textContent=x.fail;
+}
+buttons();render();
+</script>
+</body>
+</html>