Assorted content updates to Website, README, and Welcome Docs

README.md

@@ -11,22 +11,35 @@
 
 ## What is iii?
 
+<!-- prettier-ignore -->
+> [!IMPORTANT]
+> The best way to understand iii is to
+> [try our Quickstart](https://iii.dev/docs/quickstart), it will take just two minutes and may
+> forever change how you build software. If you want an even shorter introduction the try the
+> simulated [iii experience](https://iii.dev/#experience).
+
 Software engineering is an exercise in assembling categories of services. Each service has its own
 internals, its own lifecycle, its own integration story, and its own failure modes. The cost of
-every new service addition is quadratic. Every new service has potential integration points with
-every other service.
+every new service addition is quadratic as every new service has potential integration points with
+every existing service. In iii services roughly map to workers. Workers are explained in the next
+section.
 
-iii eliminates this integration effort by reducing every new addition to zero. Installing 4 workers
-or 20 workers is exactly the same. Each worker is simply able to interact with every other worker
-the moment it is registered with iii. The result is an infrastructure that behaves like a single
+iii eliminates this integration effort by reducing every new addition to zero. Adding 4 workers or
+20 workers is exactly the same. Each worker is simply able to interact with every other worker the
+moment it is registered with iii. The result is an infrastructure that behaves like a single
 application and composes effortlessly no matter how much it grows or changes over time.
 
-iii supports any language, and any runtime. It makes a new engineer productive on day one because
-their mental model never changes from one capability to the next. Likewise AI Agents can reliably
-reason about an entire system in a single context window because there is one set of primitives to
-learn and one always-accurate source of truth for what exists. As agents do more of the work of
-building and operating software, small primitives compound: easier to onboard, cheaper to prompt,
-faster to extend, simpler to maintain.
+We also ships workers with more being added all the time. You can browse our worker repository at
+[workers.iii.dev](https://workers.iii.dev/). Adding any of them to a system is as easy as installing
+a library or package and can be done with the command `iii worker add iii-sandbox`, or `iii-queue`,
+or `iii-stream`. New infrastructure-level and service-level workers are being added all of the time.
+
+The structure of workers enables iii to trivially support any language, and any runtime. It makes a
+new engineer productive on day one because their mental model never changes from one capability to
+the next. Likewise AI Agents can reliably reason about an entire system in a single context window
+because there is one set of primitives to learn and one always-accurate source of truth for what
+exists. As agents do more of the work of building and operating software, small primitives compound:
+easier to onboard, cheaper to prompt, faster to extend, simpler to maintain.
 
 ### Three Primitives
 
@@ -93,10 +106,6 @@ triggers, queues, traces, logs, and real-time state. See the
 
 See [STRUCTURE.md](STRUCTURE.md) for the full monorepo layout, dependency chain, and CI/CD details.
 
-## Examples
-
-See the [Quickstart guide](https://iii.dev/docs/quickstart) for step-by-step tutorials.
-
 ## Resources
 
 - [Documentation](https://iii.dev/docs)

docs/index.mdx

@@ -1,64 +1,50 @@
 ---
 title: Welcome to iii
-description: A backend unification and orchestration system.
+description: A next-generation software system that eliminates integration complexity and makes software unreasonably simple to create, extend, and modify.
 ---
 
-Today, building a typical backend means connecting many separate systems: API frameworks,
-a task queue, a cron scheduler, an event bus, a pub/sub layer, a state store,
-a WebSocket server, and an observability pipeline.
+## The Problem
 
-Each system brings its own setup, its own deployment, and its own
-failure modes. Balancing infrastructure and business logic becomes increasingly difficult
-with every new system.
+Software engineering has become an exercise in assembling categories of services. Each service arrives with its own internals, its own lifecycle, its own integration story, and its own failure modes. Four services means 6 possible integrations. Twenty means 190. Every new capability quadratically compounds the coordination cost of everything already in your stack.
 
-The result of balancing these many necessary systems are delayed delivery, difficulty debugging,
-transient issues, increased expenses, siloed domain and systems knowledge, and difficulty with
-onboarding new developers and AI agents.
+This pattern has been growing for decades.
 
-The main benefit of iii is that it transforms a backend from behaving like a series of
-separate concerns, domains, and services into a single application-level interface across services.
 
-**iii** (pronounced "three eye") does this by creating a single integration point
-for all backend systems which results in a stack that is easier to change and which
-keeps all historical knowledge in one place (ie. a single config).
+## The Solution
 
-The result is faster onboarding of new developers and AI agents, and simpler debugging across systems,
-removal of cost centers with reduced switching costs, and faster delivery of backend features.
+iii organizes software into three primitives: **Worker**, **Trigger**, **Function**. Something hosts work, something causes it, something does it. Every capability in every system can be built with these three things. It doesn't matter if it's queues, cron, streaming, sandboxing, observability, agents, business logic, devices, or even frontend browser UIs. Everything can be represented as workers, triggers, and functions.
 
-## What makes iii different
+## Quadratic to Linear
 
-iii's primitives produce an execution model and live system traits that together make it
-unreasonably good at creating backend software.
+The integration problem doesn't just manifest at the point where two systems connect. It also creates downstream friction in logging, debugging, and upgrading as well as upstream friction blocking growth initiatives, new verticals, and partnerships.
 
-| | What it means |
-| --- | --- |
-| **Durable orchestration** | Coordinate long-running, failure-tolerant execution across workers and triggers. |
-| **Interoperable execution** | Execute across languages natively as if it were one runtime. |
-| **Simple primitives** | Collapse distributed backend design into a paradigm that humans and agents can reason about. |
-| **Live discovery** | Functions and triggers exposed by one worker become visible and usable across the system in real time. |
-| **Live extensibility** | Add new workers and capabilities to a live iii system without redesigning the architecture. |
-| **Live observability** | Observe operations, traces, and system behavior across the entire connected stack in real time. |
+iii reduces all of this effort to zero. Adding 2 workers or 200 workers is exactly the same. A new worker joins the system by opening a single WebSocket connection and becomes immediately available to every other worker at that moment.
 
-## How iii achieves this
+## Have a Need? Add a Worker
 
-iii unifies any backend stack with a single engine and three primitives: **Function**, **Trigger**, and **Worker**.
+Need a queue? Add a worker. Need real-time streaming, scheduling, sandboxing, observability, an agent, a CRM integration, a browser tab as a first-class participant? Add a worker. Some workers are deterministic code. Some are stochastic agents. Most real systems are a mix. The semantics live in the functions, not in the category.
 
-This results in the ability to:
+`iii worker add` is the npm moment for systems. What you install is not a library — it is a running participant. A queue worker. A sandbox worker. A classifier. One command, complete capability, immediately available to every other worker in the system.
 
-- **Write Functions in any language:** Use TypeScript, Python, or Rust. Mix them freely. Everything is just a Function.
-- **Handle any event with Triggers:** A function call, an HTTP request, a cron schedule, a queue message, a state change, a stream event. They all work the same way: a Trigger fires, iii invokes your Function.
-- **Always stay in sync with Workers:** When a new function is registered with iii every other part of the stack can use it. Workers can dynamically unregister Functions too, allowing rolling upgrades without manual registry or config updates. No service registry needed — iii always knows what the entire system can do.
+## Same Contract, Both Sides
 
-<Info title="Why this matters">
-  React simplified the frontend with Component and Context. iii does the same for the backend with Function, Trigger, and Worker.
-  One mental model for every backend system.
-</Info>
+Application teams register functions and declare triggers, focused entirely on business logic. Platform teams publish workers, focused entirely on the capabilities they provide. Both sides fulfill the exact same contract. No bespoke SDKs, no internal client libraries, no per-service API contracts. The work that used to live between teams disappears.
 
-## Getting Started
+## Any Language, Any Runtime
+
+A worker in Docker, on Kubernetes, on the edge, in a browser tab, on a Raspberry Pi, or inside a hardware-isolated microVM is the same kind of worker. Moving a workload is a redeploy, not a rewrite. The engine handles serialization and routing.
+
+## Built for Agents
+
+Humans and agents share one mental model. A new engineer is productive on day one because their mental model never changes from one capability to the next. AI agents can reliably reason about an entire system in a single context window because there is one set of primitives to learn and one always-accurate source of truth for what exists.
 
-The best way to understand iii is to try it. [Install iii](/install) and then follow the [Quickstart](/quickstart) to create your first iii powered project.
+Agents are workers. An agent's tools are functions. Its memory is state. Its orchestration is triggers. An agent that hits a task outside its current capabilities can register a worker at runtime and use its functions immediately. This is the difference between scripted LLM calls and real autonomy.
+
+As agents do more of the work of building and operating software, small primitives compound: easier to onboard, cheaper to prompt, faster to extend, simpler to maintain.
+
+## Getting Started
 
-## Next Steps
+The best way to understand iii is to try it. [Install iii](/install) and follow the [Quickstart](/quickstart) to create your first iii-powered project.
 
 <CardGroup cols={2}>
   <Card title="Install" href="/install" icon="download">

website/index.html

@@ -1518,7 +1518,7 @@
     font-size:12px;
   }
   .xp-trace .head .label{
-    color:var(--ink-faint); letter-spacing:0.18em; text-transform:uppercase;
+    color:var(--ink-faint); letter-spacing:0.18em;
     display:inline-flex; align-items:center; gap:6px;
   }
   .xp-trace .head .label .pulse{
@@ -1844,6 +1844,16 @@
     border-top:1px solid var(--rule);
   }
   .xp-trace-actions:empty{ display:none; }
+  .xp-trace-actions .continue-link{
+    appearance:none; cursor:pointer;
+    border:1px solid var(--ink);
+    background:var(--ink); color:var(--bg);
+    padding:5px 12px;
+    font-family:'Chivo Mono', ui-monospace, monospace;
+    font-size:12px; letter-spacing:0.18em; text-transform:uppercase;
+    transition: background .15s, color .15s, border-color .15s;
+  }
+  .xp-trace-actions .continue-link:hover{ background:var(--accent); border-color:var(--accent); color:var(--bg); }
   .xp-trace .trace-row.sel{ background: var(--panel); }
   .xp-trace.completed.err{ border-color: oklch(0.55 0.21 27); }
   .xp-trace.completed .completed-line{ color: var(--ink); }
@@ -6314,7 +6324,7 @@ <h5>contact</h5>
     wrap.innerHTML = ''
       + '<div class="xp-trace">'
       +   '<div class="head">'
-      +     '<span class="label"><span class="pulse"></span>iii console</span>'
+      +     '<span class="label"><span class="pulse"></span>iii Console</span>'
       +     '<span class="phases">' + phasesHtml + '</span>'
       +   '</div>'
       +   '<div class="traces"></div>'
@@ -6421,7 +6431,7 @@ <h5>contact</h5>
         stepStates[i].timers.push(t);
       } else {
         const btn = document.createElement('button');
-        btn.type = 'button'; btn.className = 'deploy';
+        btn.type = 'button'; btn.className = 'continue-link';
         btn.textContent = 'Continue';
         btn.addEventListener('click', advance);
         actEl.appendChild(btn);