diff --git a/README.md b/README.md
index dc26534f..6c59aa86 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,4 @@
-# Perstack: The Agent Runtime
-
-<p align="center">
-  <img src="demo/demo.gif" alt="Perstack Demo" width="600">
-</p>
+# Perstack: Agentic AI Runtime
 
 <p align="center">
   <a href="https://www.npmjs.com/package/perstack"><img src="https://img.shields.io/npm/v/perstack" alt="npm version"></a>
@@ -16,7 +12,12 @@
   <a href="https://discord.gg/perstack"><strong>Discord</strong></a>
 </p>
 
-Define AI agents as declarative **Experts** in TOML. Execute them with deterministic, event-derived tracking. Each Expert runs in its own isolated context — no shared state, no prompt bloat, full execution history.
+## Key Features
+
+- **`perstack` CLI**: Develop, test, and deploy Experts from the command line.
+- **`create-expert` app**: Creates, tests, and refines new Experts in `perstack.toml` to your specification — powered by agentic AI.
+- **`perstack.toml`**: Define and orchestrate reusable, domain-specialized agents as Experts in declarative TOML.
+- **`@perstack/runtime`**: Execute Experts programmatically. Event-sourced state with step-level checkpoints — resume, replay, and audit any execution from any point.
 
 ## Quick Start
 
@@ -26,96 +27,92 @@ Prerequisites: [Node.js 22+](https://nodejs.org/) and an [LLM provider API key](
 npx create-expert "Create saas-developer expert that can build a SaaS product"
 ```
 
-This creates a new Expert in `perstack.toml`, then:
-- tests it against real-world scenarios
-- analyzes execution history and output to evaluate the definition
-- iterates on the definition until behavior stabilizes
-- reports capabilities and limitations
+`create-expert` does more than scaffold a file — it:
+- tests the Expert against real-world scenarios
+- analyzes execution history and output to evaluate the Expert definition
+- iterates on the Expert definition until behavior stabilizes
+- reports capabilities and limitations of the Expert
 
-Run the Expert from the CLI:
-
-```bash
-npx perstack start saas-developer "Build an agentic CRM with Perstack"
-```
+`perstack.toml` is created like this:
+```toml
+# perstack.toml
 
-Or use it programmatically via [runtime embedding](https://perstack.ai/guides/adding-ai-to-your-app/#runtime-embedding-optional):
+[experts."saas-developer"]
+description = "Builds a SaaS product"
+instruction = """
+Build a SaaS product using Perstack. Use the tools available to you.
+... (more instructions)
+"""
+delegates = ["@saas-developer/product-manager", "@saas-developer/developer", "(more delegates)"]
 
-```typescript
-import { run } from "@perstack/runtime"
+[experts."@saas-developer/product-manager"]
+description = "Manages the product roadmap"
+instruction = "Manage the product roadmap and features"
 
-const checkpoint = await run({
-  setting: {
-    model: "claude-sonnet-4-5-20250929",
-    providerConfig: { providerName: "anthropic" },
-    expertKey: "saas-developer",
-    input: { text: "Build an agentic CRM with Perstack" },
-  },
-})
+[experts."@saas-developer/developer"]
+description = "Develops the product"
+instruction = "Develop the product using Perstack"
 ```
 
-The CLI is for prototyping. The runtime API is for production. Both use the same `perstack.toml`.
-
-## Why Perstack?
-
-Agentic app development has five structural problems:
+Run the created Expert from the CLI:
 
-1. **Tight coupling**: Frameworks bundle tools, code, and prompts together. Agent behavior is determined by all of them at once.
-2. **Broken feedback loops**: You only get feedback after shipping, and improving the agent means changing the entire app codebase.
-3. **The developer owns everything**: A single developer is responsible for the entire stack — from defining the agent to building the app around it.
-4. **No sustained behavior**: Today's working agent may break next year. When the model or framework changes, behavior must be redefined from scratch.
-5. **No real isolation**: Agents need filesystem sandboxing and infrastructure-level isolation, but most frameworks address isolation at the application level rather than the architecture level.
-
-Perstack is designed to address these problems:
-
-| Problem | Perstack's Approach |
-| :--- | :--- |
-| **Tight coupling** | **A runtime** that separates Expert definitions from app code, tools, prompts, and models |
-| **Broken feedback loops** | **CLI tools** to execute and analyze Experts from day one. Expert and app evolve independently. |
-| **The developer owns everything** | Expert definitions in **`perstack.toml`** are written by domain experts using natural language. Developers focus on integration, not prompt engineering. |
-| **No sustained behavior** | **Event-derived execution** and **step-level checkpoints** help maintain reproducible behavior, even across model or provider changes |
-| **No real isolation** | **Isolation** is built into the runtime architecture — workspace boundaries, environment sandboxing, and tool whitelisting — so your platform can enforce security at the infrastructure level |
+```bash
+npx perstack start saas-developer "Build an agentic CRM with Perstack"
+```
 
-### How It Works
+## Deployment
 
-Define Experts in `perstack.toml` and run them through the runtime:
+Use `perstack install` to generate `perstack.lock` — a pre-compiled bundle of all Expert and tool definitions. This is optional, but it lets the runtime start without spawning MCP processes, so LLM inference begins immediately.
 
-```toml
-# perstack.toml
+```bash
+perstack install --config perstack.toml
+```
 
-[experts."fitness-assistant"]
-description = "Manages fitness records and suggests training menus"
-instruction = """
-Conduct interview sessions and manage records in `./fitness-log.md`.
-Collaborate with `pro-trainer` for professional training menus.
-"""
-delegates = ["pro-trainer"]  # This Expert can delegate to pro-trainer
+Then, you can use `perstack.lock` in docker containers, cloud functions, or any other deployment environment. The runtime automatically discovers the lockfile when it exists alongside the config.
 
-[experts."pro-trainer"]
-description = "Suggests scientifically-backed training menus"
-instruction = "Provide split routines and HIIT plans tailored to user history."
+```dockerfile
+FROM node:22-slim
+RUN npm install -g perstack
+COPY perstack.toml /app/perstack.toml
+COPY perstack.lock /app/perstack.lock
+WORKDIR /workspace
+ENTRYPOINT ["perstack", "run", "--config", "/app/perstack.toml"]
 ```
 
-```bash
-npx perstack start fitness-assistant "Start today's session"
+Or, use it programmatically:
+```typescript
+import { run } from "@perstack/runtime"
+
+const finalCheckpoint = await run(
+  {
+    setting: {
+      model: "claude-sonnet-4-5",
+      providerConfig: { providerName: "anthropic" },
+      expertKey: "saas-developer",
+      input: { text: "Build an agentic CRM with Perstack" },
+    },
+  },
+  {
+    eventListener: (event) => {
+      console.log(JSON.stringify(event))
+    },
+  },
+)
 ```
 
-Each Expert runs in its own isolated context — no shared state, no prompt bloat, full execution history.
+## Why Perstack?
 
-### Key Capabilities
+Agentic AI apps are tangled. Agent loop, prompts, tools, and orchestration are buried in application logic. Untestable until production. Opaque when things break. Impossible to hand off to the people who understand the domain.
 
-- **Step-level checkpoints** — resume from any step, not just the beginning. Debug, replay, and audit every decision the agent made.
-- **Multi-provider support** — 8 LLM providers (OpenAI, Anthropic, Google, and more). Switch with a single config change.
-- **Delegation** — Experts delegate to other Experts. Break monolithic agents into composable Experts that run in parallel.
-- **Draft & versioned definitions** — iterate on Expert behavior without affecting production. Promote when ready.
-- **Isolation by design** — each Expert runs in a sandboxed context with its own workspace, environment, and tool whitelist.
+| Problem | Perstack's Approach |
+| :--- | :--- |
+| **Tight coupling** | Expert definitions in TOML, separate from app code, tools, and models. Deploy each independently. |
+| **Broken feedback loops** | CLI to execute and analyze Experts from day one. Expert and app evolve on their own. |
+| **The developer owns everything** | Domain experts tune behavior in natural language. Developers own integration. Each side ships on its own. |
+| **No sustained behavior** | Event-sourced execution with step-level checkpoints. Resume, replay, and diff across model or provider changes. |
+| **No real isolation** | Each Expert runs in its own context — workspace boundaries, environment sandboxing, tool whitelisting. Your platform enforces security at the infrastructure level. |
 
-## Examples
-
-| Example | Description |
-| ------- | ----------- |
-| [bug-finder](./examples/bug-finder/) | Codebase analyzer that finds potential bugs |
-| [github-issue-bot](./examples/github-issue-bot/) | Automated GitHub issue responder that reads your codebase to answer questions |
-| [gmail-assistant](./examples/gmail-assistant/) | AI-powered email assistant with Gmail integration |
+8 LLM providers supported. Switch with a single config change. No vendor lock-in.
 
 ## What to Read Next
 
@@ -130,15 +127,23 @@ Each Expert runs in its own isolated context — no shared state, no prompt bloa
 - [Isolation & Safety](https://perstack.ai/docs/operating-experts/isolation-by-design/) — production deployment patterns
 - [CLI & API Reference](https://perstack.ai/docs/references/cli/)
 
+## Examples
+
+| Example | Description |
+| ------- | ----------- |
+| [bug-finder](./examples/bug-finder/) | Codebase analyzer that finds potential bugs |
+| [github-issue-bot](./examples/github-issue-bot/) | Automated GitHub issue responder that reads your codebase to answer questions |
+| [gmail-assistant](./examples/gmail-assistant/) | AI-powered email assistant with Gmail integration |
+
 ## FAQ
 
 ### Is this an agent framework?
 
-No. Frameworks help you *build* agents. Perstack is a *runtime* that *executes* them. You define Experts declaratively in TOML; Perstack handles execution, isolation, and state.
+No. Frameworks help you *build* agents in your own codebase. Perstack is just a *runtime* that *executes* them. What your application is built with is out of Perstack's scope.
 
 ### Can Experts be used with other frameworks?
 
-Yes. Expert definitions are TOML files, so other tools can read and interpret them. See the [API Reference](https://perstack.ai/api/v1/spec).
+Yes. Expert definitions are TOML files, so other tools can read and interpret them.
 
 ### Can I convert existing agents to Experts?