From a6c534a0958d1faea3c45f2d4f3a5711b8b25b6b Mon Sep 17 00:00:00 2001 From: Ian Pascoe Date: Sun, 26 Jul 2026 15:10:29 -0400 Subject: [PATCH 01/32] feat(marketing): position Caplets as whole-stack capability layer --- CONTEXT.md | 30 +++++++- PRODUCT.md | 12 ++- README.md | 26 ++++--- STRATEGY.md | 20 +++-- apps/catalog/src/pages/index.astro | 30 ++++++-- apps/catalog/src/styles/catalog.css | 31 ++++++++ apps/docs/src/content/docs/index.mdx | 20 +++-- .../src/components/landing/Activation.astro | 68 +++++++++++++++-- .../src/components/landing/AgentTrace.astro | 12 +-- .../src/components/landing/BlogCta.astro | 10 +-- .../src/components/landing/Breadth.astro | 60 +++++++++++++++ .../src/components/landing/CommandBlock.astro | 1 + .../src/components/landing/Footer.astro | 4 +- .../src/components/landing/Header.astro | 31 ++++---- .../landing/src/components/landing/Hero.astro | 76 ++++--------------- .../src/components/landing/Proof.astro | 10 +-- .../src/components/landing/RemoteStory.astro | 34 +++++---- .../src/components/landing/WholeJob.astro | 37 +++++++++ .../src/components/landing/WhyCaplets.astro | 12 +-- apps/landing/src/data/landing.ts | 46 ++++++----- apps/landing/src/layouts/LandingLayout.astro | 4 +- apps/landing/src/pages/index.astro | 8 +- apps/landing/src/scripts/observability.ts | 13 +++- apps/landing/test/activation-links.test.ts | 10 +-- apps/landing/test/blog-navigation.test.ts | 17 ----- apps/landing/test/observability.test.ts | 51 +++++++++++++ 26 files changed, 476 insertions(+), 197 deletions(-) create mode 100644 apps/landing/src/components/landing/Breadth.astro create mode 100644 apps/landing/src/components/landing/WholeJob.astro diff --git a/CONTEXT.md b/CONTEXT.md index 7518e71b..1920905c 100644 --- a/CONTEXT.md +++ b/CONTEXT.md @@ -1,9 +1,37 @@ # Caplets -Caplets is a capability gateway for coding agents. This glossary names the product concepts used when describing Caplet configuration and runtime behavior. +Caplets is a capability layer for coding agents. This glossary names the product concepts used when describing Caplet configuration and runtime behavior. ## Language +**Caplet**: +A reusable capability surface for coding agents that exposes intentionally selected backend functionality. A Caplet can be kept local, reused across supported agent environments, or shared without transferring credentials. +_Avoid_: Connector, integration listing, tool bundle + +**Capability Layer**: +The product category for Caplets: a shared intermediary that turns heterogeneous backends into intentionally exposed, reusable capabilities for coding agents. +_Avoid_: Agent integration platform, tool aggregator, capability marketplace + +**Whole Stack**: +The set of backend capabilities a user intentionally makes available to a coding agent through Caplets. It describes potential breadth across the agent's work, not unrestricted authority or the current contents of the Prebuilt Caplets Catalog. +_Avoid_: Unrestricted agent access, every credential by default, prebuilt catalog coverage + +**Capability Sharing**: +The transfer of a reusable Caplet definition and its operating guidance without transferring credentials or authenticated authority. Each receiving user or host supplies and authorizes its own access. +_Avoid_: Credential sharing, connection cloning, inherited authority + +**Capability Composition**: +An agent's task-specific selection and combination of Caplets across backend systems. The agent determines the path from the current task rather than following a predefined human-authored automation. +_Avoid_: Workflow builder, fixed integration pipeline, automation recipe + +**Agent Portability**: +The ability to reuse the same Caplet definitions across supported coding-agent environments without redefining their backend capabilities. Agent-specific surfaces may differ, and credentials remain independently authorized. +_Avoid_: Identical client experience, automatic credential portability, universal client parity + +**Caplet Activation**: +The first successful backend operation executed through a configured Caplet. A website interaction, catalog view, installation, or setup completion is not activation. +_Avoid_: Install conversion, setup completion, first page view + **Code Mode**: A Caplets exposure surface where configured backends appear as typed handles inside a bounded script workflow. _Avoid_: JavaScript shell, Node REPL, sandbox boundary diff --git a/PRODUCT.md b/PRODUCT.md index 59663aad..26f4caaa 100644 --- a/PRODUCT.md +++ b/PRODUCT.md @@ -6,11 +6,19 @@ product ## Users -Caplets serves developers working with coding agents and tool ecosystems. The primary audience is split between agent power users who run many MCP servers, APIs, and local tools, and tool builders who package focused capability domains for agents or teams. Users are usually in a technical workflow: configuring integrations, inspecting available capabilities, debugging setup, or helping an agent choose the right tool without flooding context. +Caplets primarily serves agent power users who want their coding agent to work across the systems surrounding the repository. Teams are the expansion audience: they standardize and distribute approved Caplets. Tool builders and community authors are the ecosystem audience: they package reusable capability definitions for others. Users are usually connecting backends, authorizing access, reusing Caplets across supported agents, or inspecting exactly what a capability exposes. ## Product Purpose -Caplets turns sprawling tool stacks into focused capability cards for coding agents. It exists to reduce context bloat, improve tool discovery, preserve downstream capability fidelity, and make heterogeneous backends feel like one coherent progressive-disclosure interface. Success looks like agents choosing the right capability quickly, users trusting what is exposed and hidden, and builders being able to package tools without writing bespoke agent integration code. +Caplets is the capability layer for coding agents. It turns heterogeneous MCP servers, APIs, and commands into intentionally exposed, reusable Caplets that agents can select and combine for the task at hand. Success means an agent can carry work across the user's authorized stack, the same Caplet definitions can be reused without transferring credentials, and Code Mode keeps the resulting decision surface focused without reducing backend fidelity. + +## Positioning + +**Category:** The capability layer for coding agents. + +**Promise:** Give your coding agent the whole stack. + +**Meaning:** Whole Stack is the set of backend capabilities a user intentionally exposes through Caplets—not blanket authority, inherited credentials, or the current contents of the public catalog. Connection breadth is the primary proof; agent portability and capability sharing are the supporting promises; Code Mode efficiency and benchmarked token reduction are technical evidence. ## Brand Personality diff --git a/README.md b/README.md index 2828293d..e2560699 100644 --- a/README.md +++ b/README.md @@ -4,8 +4,8 @@

Caplets

- Give your agent capabilities, not giant tool walls.
- Caplets wraps MCP servers, APIs, and commands behind focused capability cards. + Give your coding agent the whole stack.
+ The capability layer for coding agents.

@@ -25,20 +25,26 @@ --- -Caplets gives coding agents a Code Mode surface for MCP servers, APIs, and commands. Instead -of exposing every downstream operation as a giant tool list, each backend becomes a typed -`caplets.` handle the agent can inspect, search, call, filter, join, and summarize inside -one compact workflow. +Caplets turns MCP servers, APIs, and commands into reusable capabilities your coding agent +can use from issue to production. You choose what each agent can access. A Caplet definition +can stay local, work across supported agent environments, or be shared without transferring +credentials or authenticated authority. -Progressive discovery is still available when you want visible wrapper tools, but Code Mode is -the default exposure for configured backends. +Code Mode is the default exposure: each configured backend becomes a typed `caplets.` +handle the agent can inspect, search, call, filter, join, and summarize inside one compact +workflow. Progressive and direct exposure remain available when a client or task needs them. Caplets can wrap: - MCP servers -- OpenAPI, GraphQL, and simple HTTP APIs +- OpenAPI APIs +- Google Discovery APIs +- GraphQL and simple HTTP APIs - Curated repository CLI commands -- Shared Caplet files from this repo's `caplets/` catalog +- Shared Caplet Files from the public catalog or another source + +The catalog is a discovery and distribution channel, not the boundary of what Caplets can +connect. Each receiving host supplies and authorizes its own access. ## Quick Start diff --git a/STRATEGY.md b/STRATEGY.md index 44807c72..257e5e21 100644 --- a/STRATEGY.md +++ b/STRATEGY.md @@ -1,24 +1,26 @@ --- name: Caplets -last_updated: 2026-06-17 +last_updated: 2026-07-26 --- # Caplets Strategy ## Target problem -Coding agents get slower, more expensive, and less reliable when real backend surfaces are exposed as flat tool lists: large MCP/API setups flood context with hundreds of operations, create duplicate generic names, and force repeated model/tool round trips for discovery, schema inspection, execution, and synthesis. The hard part is preserving exact backend power, auth state, schemas, resources, prompts, results, and errors across local, remote, Cloud, and native agent setups without making the agent reason over the whole tool wall up front. +Coding agents stop where the repository ends. Users become the human integration layer: they carry issue context into the agent, inspect dashboards themselves, trigger operations, and update external systems after the code changes. Connecting more systems can then overwhelm the agent with flat tool lists, giant schemas, repeated auth setup, and extra model/tool round trips. The hard part is giving an agent broad, reusable capability access while preserving exact backend semantics and deliberate user control. ## Our approach -Caplets wins by being a Code Mode-first capability layer for coding agents, not a general tool catalog. It turns heterogeneous backends into typed, scoped handles so agents can discover, inspect, execute, filter, and summarize with a small decision surface, while preserving exact backend semantics and keeping auth, direct I/O, and project-local context behind Caplet-controlled boundaries. +Caplets wins by being the capability layer for coding agents. It turns heterogeneous MCP servers, APIs, commands, and shared Caplet Files into intentionally exposed, reusable capabilities that an agent can select and combine for the current task. Code Mode is the default mechanism for keeping that Whole Stack focused: typed, scoped handles preserve backend fidelity while auth, direct I/O, and project-local context remain behind Caplet-controlled boundaries. ## Who it's for -**Primary:** Agent power-users/builders - They're hiring Caplets to turn sprawling MCP/API/CLI surfaces into typed capabilities their coding agents can inspect, call, filter, and synthesize without a giant tool wall. +**Primary:** Individual agent power users who want their coding agent to work across the systems surrounding the repository. **Expansion:** Teams that standardize and distribute approved Caplets. **Ecosystem:** Tool builders and community authors who publish reusable capability definitions. ## Key metrics +- **Caplet Activation** - The first successful backend operation executed through a configured Caplet. Landing clicks, catalog views, installation, and setup completion are funnel diagnostics, not activation. +- **Whole Stack retention** - Repeat successful Caplet executions across backend families, indicating that users expanded beyond the first no-auth capability into personally relevant work. - **Initial tool surface compression** - Reduction in initially visible tools, serialized payload bytes, approximate context tokens, and duplicate top-level names versus direct flat MCP; measured by `pnpm benchmark:check`. - **Code Mode workflow efficiency** - Reduction in model/tool round trips, external calls, and payload tokens while preserving required evidence fields; measured by deterministic Code Mode benchmark fixtures. - **Live task parity at lower token cost** - Live eval pass rate must match baselines before claiming token efficiency, then compare request+output tokens and tool-surface tokens. @@ -62,6 +64,12 @@ _Why it serves the approach:_ Caplets asks users to trust a smaller visible surf ## Marketing -**One-liner:** Give your agent capabilities, not giant tool walls. +**Category:** The capability layer for coding agents. -**Key message:** Caplets turns MCP servers, APIs, and commands into focused capability handles for compact coding-agent workflows. The proof point is not just that Caplets connects to more backends; it is that agents can complete real multi-step backend work with a smaller decision surface, fewer round trips, and claims that are checked against reproducible benchmarks. +**One-liner / headline:** Give your coding agent the whole stack. + +**Profile description:** Turn MCP servers, APIs, and commands into reusable Caplets your coding agent can use across the work. You control access. + +**Key message:** Caplets connects coding agents to intentionally exposed capabilities across the user's stack. A Caplet is reusable across supported agent environments and can be shared without transferring credentials. Agents compose Caplets for the task instead of requiring a fixed automation workflow. Code Mode tool-surface compression, fewer round trips, and benchmarked token reduction are technical proof—not the primary promise. + +**Launch sequence:** Whole Stack promise → “MCP. APIs. Commands. All of it.” → human integration-layer problem → capability composition → agent portability → “Share capabilities, not secrets.” → issue-to-production example → Code Mode evidence → first Caplet activation. diff --git a/apps/catalog/src/pages/index.astro b/apps/catalog/src/pages/index.astro index 4a4b6c4e..fcac7432 100644 --- a/apps/catalog/src/pages/index.astro +++ b/apps/catalog/src/pages/index.astro @@ -17,10 +17,23 @@ const entries = await listCatalogEntries(getCatalogEnv()); - Caplets Catalog + Shared Caplets — Caplets Catalog + + + + + + + @@ -29,10 +42,17 @@ const entries = await listCatalogEntries(getCatalogEnv());

-
- Not security-reviewed. - Inspect Caplets before installing. +
+

The capability layer for coding agents

+

Find a capability. Make it yours.

+ + Search reusable Caplet definitions and operating guidance. The catalog is one distribution channel—not the boundary of what Caplets can connect. +
+
diff --git a/apps/catalog/src/styles/catalog.css b/apps/catalog/src/styles/catalog.css index 6a2b32e8..1e5108b4 100644 --- a/apps/catalog/src/styles/catalog.css +++ b/apps/catalog/src/styles/catalog.css @@ -75,6 +75,37 @@ padding: 0.875rem; } +.catalog-positioning { + display: grid; + max-width: 52rem; + gap: 0.65rem; + margin: 1.5rem 0 1.25rem; +} + +.catalog-positioning p { + color: var(--accent); + font-family: var(--font-mono); + font-size: 0.75rem; + font-weight: 700; +} + +.catalog-positioning h1 { + color: var(--foreground); + font-size: clamp(2rem, 5vw, 3.75rem); + font-weight: 700; + line-height: 1; + letter-spacing: -0.035em; + text-wrap: balance; +} + +.catalog-positioning span { + max-width: 68ch; + color: var(--muted-foreground); + font-size: 1rem; + line-height: 1.65; + text-wrap: pretty; +} + .catalog-intro { display: flex; flex-wrap: wrap; diff --git a/apps/docs/src/content/docs/index.mdx b/apps/docs/src/content/docs/index.mdx index 2e973900..8ed010eb 100644 --- a/apps/docs/src/content/docs/index.mdx +++ b/apps/docs/src/content/docs/index.mdx @@ -1,14 +1,22 @@ --- title: Caplets -description: Give coding agents Code Mode capabilities without a giant tool wall. +description: Give your coding agent the whole stack through reusable, controlled Caplets. --- -Caplets wraps MCP servers, APIs, and commands into focused capabilities for coding agents. -Code Mode is the default surface: each configured backend becomes a typed caplets.<id> -handle that an agent can inspect, search, call, filter, and summarize in one workflow. +Caplets is the capability layer for coding agents. Turn MCP servers, OpenAPI and Google +Discovery APIs, GraphQL endpoints, simple HTTP actions, and curated CLI commands into +reusable Caplets your agent can use across the work surrounding your code. -Use Caplets with Codex, Claude, OpenCode, Pi, or any MCP client that can launch a local -stdio server. +Your Whole Stack is the set of capabilities you intentionally expose through Caplets—not +blanket access to every system or credential. Caplet definitions can be reused across +Codex, Claude, OpenCode, Pi, and supported MCP clients while each host independently +supplies and authorizes access. + +Code Mode is the default surface: each configured backend becomes a typed + +caplets.<id> handle that an agent can inspect, search, +call, filter, and summarize in one workflow. Direct and progressive exposure remain available for +clients and tasks that need them. > **Required upgrade migration:** If this host ran `caplets@0.25.x` or earlier, do not > start `caplets@0.26.0` or later until you complete the diff --git a/apps/landing/src/components/landing/Activation.astro b/apps/landing/src/components/landing/Activation.astro index 7392baf3..59038381 100644 --- a/apps/landing/src/components/landing/Activation.astro +++ b/apps/landing/src/components/landing/Activation.astro @@ -1,5 +1,7 @@ --- import ArrowUpRight from "@tabler/icons/outline/arrow-up-right.svg"; +import Check from "@tabler/icons/outline/check.svg"; +import Copy from "@tabler/icons/outline/copy.svg"; import Terminal from "@tabler/icons/outline/terminal-2.svg"; import { Badge } from "@/components/starwind/badge"; @@ -7,24 +9,76 @@ import { Button } from "@/components/starwind/button"; import { Card, CardContent } from "@/components/starwind/card"; import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/starwind/tabs"; -import { exampleCaplets } from "../../data/landing"; +import { + agentSetupPrompt, + exampleCaplets, + manualSetupCommand, + manualSetupCommands, +} from "../../data/landing"; + +const setupOptions = [ + { + label: "Manual", + copyLabel: "manual setup commands", + copyValue: manualSetupCommand, + copyAttribution: true, + lines: [manualSetupCommands.install, manualSetupCommands.setup], + }, + { + label: "Agent", + copyLabel: "agent setup prompt", + copyValue: agentSetupPrompt, + copyAttribution: false, + lines: ["Read bootstrap skill", "detect -> ask -> plan -> approve"], + }, +] as const; ---
-

First Caplet

+

Connect your first capability

- Start where auth cannot get in the way. + Get one real result. Then bring in your stack.

- Copy setup from the hero, then add OSV first because it needs no auth. Bring in GitHub or Sourcegraph after the discovery path feels right. + Set up Caplets, then run OSV first because it needs no auth. Once the agent completes that call, connect an MCP server, API, or command you already rely on.

- + + + {setupOptions.map((option) => {option.label})} + + { + setupOptions.map((option) => ( + +
+
+
+ {option.lines.map((line) => {line})} +
+ +
+
+ + )) + } +
discover @@ -55,7 +109,7 @@ import { exampleCaplets } from "../../data/landing";

Add {example.name}

{example.summary}

{example.why}

-
+
{example.path.map((step, index) => ( <> {index > 0 && /} diff --git a/apps/landing/src/components/landing/AgentTrace.astro b/apps/landing/src/components/landing/AgentTrace.astro index 54734061..7c597ea3 100644 --- a/apps/landing/src/components/landing/AgentTrace.astro +++ b/apps/landing/src/components/landing/AgentTrace.astro @@ -1,10 +1,12 @@ --- const traceSteps = [ - { href: "#trace", label: "How" }, - { href: "#why", label: "Why" }, - { href: "#install", label: "Setup" }, - { href: "#proof", label: "Benchmark" }, - { href: "#remote", label: "Remote" }, + { href: "#trace", label: "Promise" }, + { href: "#breadth", label: "Breadth" }, + { href: "#why", label: "Problem" }, + { href: "#work", label: "Whole job" }, + { href: "#portable", label: "Portability" }, + { href: "#proof", label: "Evidence" }, + { href: "#install", label: "Connect" }, ] as const; --- diff --git a/apps/landing/src/components/landing/BlogCta.astro b/apps/landing/src/components/landing/BlogCta.astro index ff7bd377..862f5977 100644 --- a/apps/landing/src/components/landing/BlogCta.astro +++ b/apps/landing/src/components/landing/BlogCta.astro @@ -9,20 +9,20 @@ import { Card, CardContent } from "@/components/starwind/card";

Try Caplets

-

Give your agent capabilities, not giant tool walls.

+

Give your coding agent the whole stack.

- Install the CLI, wire up your agent, browse the catalog, or read the benchmark method behind the launch claim. + Connect your first capability, reuse a shared Caplet, or inspect the benchmark behind the smaller tool surface.

npm install -g caplets caplets setup
- 
   

-    
Caplets gives agents capabilities, not giant tool walls.

+    
Caplets is the capability layer for coding agents.

     

diff --git a/apps/landing/src/components/landing/RemoteStory.astro b/apps/landing/src/components/landing/RemoteStory.astro
index 393a00fd..8bdafdb4 100644
--- a/apps/landing/src/components/landing/RemoteStory.astro
+++ b/apps/landing/src/components/landing/RemoteStory.astro
@@ -12,12 +12,12 @@ import CommandBlock from "./CommandBlock.astro";
 

   

     

-      
Agent portability and sharing

+      
Reuse across agents and teams

       

-        Use one capability model across native integrations, MCP clients, and Remote Attach.
+        Configure a capability once. Reuse it across supported agents.
       

       

-        Run Caplets through native OpenCode and Pi integrations, use MCP with Codex, Claude, and other compatible clients, or connect supported Remote Attach clients. Each host independently supplies credentials and authorizes access.
+        Use native integrations with OpenCode and Pi, MCP with Codex, Claude, and compatible clients, or Remote Attach with supported clients. Every host supplies its own credentials and authorizes its own access.
       

       

         {portabilitySurfaces.map((endpoint) => (
@@ -50,15 +50,15 @@ import CommandBlock from "./CommandBlock.astro";
             

               

             
             

               

@@ -66,8 +66,8 @@ import CommandBlock from "./CommandBlock.astro";
             

               

           

@@ -79,9 +79,9 @@ import CommandBlock from "./CommandBlock.astro";
   

     

       
Share capabilities, not secrets.

-      
A shared Caplet transfers its reusable definition and operating guidance. Every receiving user or host provides and authorizes its own access.

+      
Sharing a Caplet transfers only its definition and operating guidance. The recipient supplies credentials and authorizes access on its own host.

     

-    Create a Caplet
+    Learn how to create a Caplet
   

 
   

diff --git a/apps/landing/src/components/landing/WholeJob.astro b/apps/landing/src/components/landing/WholeJob.astro
index 9c82edb3..7a7f3467 100644
--- a/apps/landing/src/components/landing/WholeJob.astro
+++ b/apps/landing/src/components/landing/WholeJob.astro
@@ -16,10 +16,10 @@ const workStages = [
         Let the agent carry the whole job.
       
       

-        Follow one illustrative route across issue tracking, source control, CI, deployment, and status instead of carrying every handoff yourself.
+        This example moves one change across issue tracking, source control, CI, deployment, and status—without handing each step back to you.
       

       

-        Every step runs only when its capability has been exposed and authorized. Caplets does not grant autonomous deployment authority.
+        The agent can run a step only after you expose and authorize its capability. Caplets never grants deployment authority on its own.
       

     

 
diff --git a/apps/landing/src/components/landing/WhyCaplets.astro b/apps/landing/src/components/landing/WhyCaplets.astro
index 2658aad0..bd142bbc 100644
--- a/apps/landing/src/components/landing/WhyCaplets.astro
+++ b/apps/landing/src/components/landing/WhyCaplets.astro
@@ -7,15 +7,15 @@ import { whyCapletsProblems } from "../../data/landing";
 

   

     

-      
The missing connection

+      
Why Caplets

       

         Stop being your agent's human integration layer.
       

       

-        Your agent can change the code. You still copy the issue, inspect the dashboard, trigger the operation, and update the status.
+        Your agent changes the code. You still carry the issue context, inspect CI, trigger the deployment, and report the result.
       

       

-        Caplets gives it controlled capabilities across those systems while preserving the exact access, schemas, results, and errors each backend provides.
+        Caplets lets the agent continue across systems you intentionally expose while preserving each backend's access controls, schemas, results, and errors.
       

     

 
@@ -48,9 +48,9 @@ import { whyCapletsProblems } from "../../data/landing";
   

     
A reusable capability for coding agents

     

-      
The agent composes the route for the task.

+      
The agent selects the capabilities this task needs.

       

-        Each Caplet exposes one controlled capability domain. The agent selects and combines the Caplets it needs now instead of asking you to prebuild a fixed automation workflow.
+        Each Caplet exposes one controlled capability domain. The agent can combine Caplets at runtime instead of requiring you to prebuild a fixed automation workflow.
       

     

   

diff --git a/apps/landing/src/data/landing.ts b/apps/landing/src/data/landing.ts
index a94706f4..4d3ef1f1 100644
--- a/apps/landing/src/data/landing.ts
+++ b/apps/landing/src/data/landing.ts
@@ -25,19 +25,21 @@ Set up Caplets for this environment. Detect the environment first. Do not instal
 export const proofStats = [
   {
     value: "10/10",
-    label: "tasks cleared",
+    label: "tasks completed",
     detail:
-      "Caplets Code Mode, progressive modes, direct MCP, and Executor.sh all completed the task set.",
+      "Caplets Code Mode, progressive modes, direct MCP, and Executor.sh all completed the same task set.",
   },
   {
     value: "236,803",
-    label: "avg tokens",
-    detail: "Request plus output estimate for the Code Mode run, averaged across live Pi evals.",
+    label: "average total tokens",
+    detail:
+      "Average request and output tokens for the Code Mode run across the live Pi evaluations.",
   },
   {
     value: "72.0% fewer",
-    label: "vs vanilla",
-    detail: "Reduction against direct vanilla MCP without giving up the completed-task result.",
+    label: "than direct MCP",
+    detail:
+      "Fewer request and output tokens than direct vanilla MCP, with the same completed-task result.",
   },
 ] as const;
 
@@ -78,9 +80,9 @@ export const benchmarkRows = [
 ] as const;
 
 export const deterministicSurface = [
-  { label: "flat tool wall", value: "215" },
-  { label: "first screen cards", value: "7" },
-  { label: "surface cut", value: "79.9%" },
+  { label: "direct MCP tools", value: "215" },
+  { label: "Caplet cards shown first", value: "7" },
+  { label: "serialized payload cut", value: "79.9%" },
 ] as const;
 
 export const whyCapletsProblems = [
@@ -125,7 +127,7 @@ export const portabilityClaims = [
   {
     label: "Agent portability",
     detail:
-      "Reuse one capability definition across supported agent surfaces without pretending every client experience is identical.",
+      "Use the same Caplet definition through each supported surface. The agent experience may differ; the reusable definition stays the same.",
     points: [
       "Native OpenCode and Pi integrations",
       "MCP for Codex, Claude, and compatible clients",
@@ -135,11 +137,11 @@ export const portabilityClaims = [
   {
     label: "Capability sharing",
     detail:
-      "Keep a Caplet local, distribute it within a team, or publish it for the community without transferring authenticated authority.",
+      "Keep a Caplet local, share it with a team, or publish it for the community. Each recipient supplies and authorizes their own credentials.",
     points: [
-      "Personal reuse across agents and projects",
-      "Team-distributed Caplet definitions",
-      "Public Caplets through the catalog or another source",
+      "Reuse it across your agents and projects",
+      "Share it with a team",
+      "Publish it for the community",
     ],
   },
 ] as const;

From 75a4e914cb07bc03f843186d5a3e579d6bd88525 Mon Sep 17 00:00:00 2001
From: Ian Pascoe 
Date: Tue, 28 Jul 2026 07:42:40 -0400
Subject: [PATCH 04/32] fix(marketing): distill landing page

---
 .../src/components/landing/Activation.astro   | 166 ++++++----------
 .../src/components/landing/AgentTrace.astro   |  34 ----
 .../src/components/landing/CommandBlock.astro |  37 ----
 .../src/components/landing/Proof.astro        | 101 ++--------
 .../src/components/landing/RemoteStory.astro  |  94 ++-------
 .../src/components/landing/WhyCaplets.astro   |  61 ++----
 apps/landing/src/data/landing.ts              | 188 ++----------------
 apps/landing/src/pages/index.astro            |   3 -
 apps/landing/src/scripts/agent-trace.ts       |  70 -------
 apps/landing/src/styles/global.css            | 162 +--------------
 10 files changed, 136 insertions(+), 780 deletions(-)
 delete mode 100644 apps/landing/src/components/landing/AgentTrace.astro
 delete mode 100644 apps/landing/src/components/landing/CommandBlock.astro
 delete mode 100644 apps/landing/src/scripts/agent-trace.ts

diff --git a/apps/landing/src/components/landing/Activation.astro b/apps/landing/src/components/landing/Activation.astro
index 484c5e45..f7ebb1e7 100644
--- a/apps/landing/src/components/landing/Activation.astro
+++ b/apps/landing/src/components/landing/Activation.astro
@@ -11,7 +11,7 @@ import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/starwind/
 
 import {
   agentSetupPrompt,
-  exampleCaplets,
+  firstCaplet,
   manualSetupCommand,
   manualSetupCommands,
 } from "../../data/landing";
@@ -35,122 +35,86 @@ const setupOptions = [
 ---
 
 

-  

-    

+  

+    

       
Connect your first capability

       

-        Get one real result. Then bring in your stack.
+        Get one real result.
       

       

-        Set up Caplets, then run OSV first because it needs no auth. Once the agent completes that call, connect an MCP server, API, or command you already rely on.
+        Set up Caplets, then run OSV. It is public, useful, and needs no authentication.
       

 
       
         
           {setupOptions.map((option) => {option.label})}
         
-        {
-          setupOptions.map((option) => (
-            
-              

-                

-                  

-                    {option.lines.map((line) => {line})}
-                  

-                  
+        {setupOptions.map((option) => (
+          
+            

+              

+                

+                  {option.lines.map((line) => {line})}
                 

+                
               

-            
-          ))
-        }
+            

+          
+        ))}
       
-      

-        

-          discover
-          Caplets
-        

-        

-          inspect
-          tool schemas
-        

-        

-          call
-          typed tools
-        

-      

     

 
-    
-      
-        {exampleCaplets.map((example) => {example.name})}
-      
-      {
-        exampleCaplets.map((example) => (
-          
-            
-              
-                

-                  {example.name}
-                  
Add {example.name}

-                  
{example.summary}

-                  
{example.why}

-                  

-                    {example.path.map((step, index) => (
-                      <>
-                        {index > 0 && /}
-                        {step}
-                      
-                    ))}
-                  

-                  

-                    {example.help.map((part) =>
-                      part === "GH_TOKEN" || part === "caplets setup" ? (
-                        {part}
-                      ) : (
-                        part
-                      ),
-                    )}
-                  

-                

-                

-                  

-                    

-                  
    
-                    {example.steps.map((step, index) => (
-                      
  1. 
-                        
-                        {step.command}
-                      
    2. 
-                    ))}
-                  

-                

-              
-            
-          
-        ))
-      }
-    
+    
+      
+        

+          {firstCaplet.name}
+          
Add {firstCaplet.name}

+          
{firstCaplet.summary}

+          

+            {firstCaplet.help.map((part) =>
+              part === "caplets setup" ? (
+                {part}
+              ) : (
+                part
+              ),
+            )}
+          

+        

+        

+          

+            

+          
    
+            {firstCaplet.steps.map((step, index) => (
+              
  1. 
+                
+                {step.command}
+              
    2. 
+            ))}
+          

+        

+      
+    
   

-  

-    

-      
Your first successful backend call is Caplet Activation.

-      
OSV proves the setup without requiring authentication. Next, connect one capability from the stack you already use.

-    

+
+  

+    

+      The first successful call is Caplet Activation. Then connect a capability from your own stack.
+    

     
-  

-  
{command}

-

diff --git a/apps/landing/src/components/landing/Proof.astro b/apps/landing/src/components/landing/Proof.astro
index d2bac7e4..e9fd934e 100644
--- a/apps/landing/src/components/landing/Proof.astro
+++ b/apps/landing/src/components/landing/Proof.astro
@@ -2,100 +2,35 @@
 import ArrowUpRight from "@tabler/icons/outline/arrow-up-right.svg";
 
 import { Button } from "@/components/starwind/button";
-import { Card, CardContent } from "@/components/starwind/card";
-import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/starwind/table";
 
-import { benchmarkProvenance, benchmarkRows, deterministicSurface, proofStats } from "../../data/landing";
+import { benchmarkProvenance, proofStats } from "../../data/landing";
 ---
 
 

-  

-    

+  

+    

       Technical evidence
-      

+      

         Smaller surface. Same completed work.
       

-      

-        Broader backend access does not have to flood the prompt. In the live benchmark, Code Mode completed the same 10/10 tasks as direct vanilla MCP with fewer tokens and fewer round trips.
+      

+        Code Mode kept the task result while cutting the tool wall and token load.
       

-      {benchmarkProvenance}
-      

-        The live run rows are listed here; the linked benchmark document covers the harness, deterministic surface check, and reproduction path.
-      

-      
     

 
-    

-      

-        {proofStats.map((stat) => (
-          

-            
{stat.label}

-            
{stat.value}

-            
{stat.detail}

-          

-        ))}
-      

-
-      

-        {
-          benchmarkRows.map((row) => (
-            

-              
-                Mode: {row.mode}
-              
-              
-                Passed: {row.passed}
-              
-              
-                Total tokens: {row.tokens} tokens
-              
-              
-                Tool surface tokens: {row.surfaceTokens} surface
-              
-            

-          ))
-        }
-      

-
-      
-
-      

-        {deterministicSurface.map((item) => (
-          

-            {item.label}
-            {item.value}
-          

-        ))}
-      

-      

-        Code Mode used 72.0% fewer request + output tokens than Direct vanilla MCP and 65.0% fewer than Executor.sh. Progressive disclosure also reduced tokens while every listed mode completed 10/10 tasks.
-      

-    

+    

+      {proofStats.map((stat) => (
+        

+          
{stat.label}

+          
{stat.value}

+          
{stat.detail}

+        

+      ))}
+    

   

 

diff --git a/apps/landing/src/components/landing/RemoteStory.astro b/apps/landing/src/components/landing/RemoteStory.astro
index 8bdafdb4..7d46bfe9 100644
--- a/apps/landing/src/components/landing/RemoteStory.astro
+++ b/apps/landing/src/components/landing/RemoteStory.astro
@@ -1,91 +1,27 @@
 ---
-import Route from "@tabler/icons/outline/route.svg";
-import Server from "@tabler/icons/outline/server.svg";
-
-import { Card, CardContent } from "@/components/starwind/card";
-import { Separator } from "@/components/starwind/separator";
-
-import { portabilityClaims, portabilitySurfaces, remoteCommands } from "../../data/landing";
-import CommandBlock from "./CommandBlock.astro";
+import { portabilitySurfaces } from "../../data/landing";
 ---
 
 

-  

-    

+  

+    

       
Reuse across agents and teams

       

-        Configure a capability once. Reuse it across supported agents.
+        Configure once. Reuse anywhere Caplets is supported.
       

-      

-        Use native integrations with OpenCode and Pi, MCP with Codex, Claude, and compatible clients, or Remote Attach with supported clients. Every host supplies its own credentials and authorizes its own access.
+      

+        The Caplet definition travels. Credentials and authorization stay with each host.
       

-      

-        {portabilitySurfaces.map((endpoint) => (
-          

-            
{endpoint.label}

-            
{endpoint.value}

-          

-        ))}
-      

-    

-
-    

-      

-        {portabilityClaims.map((item) => (
-          
-            
-              
{item.label}

-              
{item.detail}

-              
    
-                {item.points.map((point) => 
  • {point}
    • )}
-              

-            
-          
-        ))}
-      

-
-      
-        
-          

-            

-              

-            
-            

-              

-            
-            

-              

-          

-        
-      
+      Create and share a Caplet
     

-  

-
-  

-    

-      
Share capabilities, not secrets.

-      
Sharing a Caplet transfers only its definition and operating guidance. The recipient supplies credentials and authorizes access on its own host.

-    

-    Learn how to create a Caplet
-  

 
-  

-    
-    
+    

+      {portabilitySurfaces.map((surface) => (
+        

+          
{surface.label}

+          
{surface.value}

+        

+      ))}
+    

   

 

diff --git a/apps/landing/src/components/landing/WhyCaplets.astro b/apps/landing/src/components/landing/WhyCaplets.astro
index bd142bbc..38c6be59 100644
--- a/apps/landing/src/components/landing/WhyCaplets.astro
+++ b/apps/landing/src/components/landing/WhyCaplets.astro
@@ -1,57 +1,28 @@
----
-import Route from "@tabler/icons/outline/route.svg";
-
-import { whyCapletsProblems } from "../../data/landing";
----
-
 

-  

-    

+  

+    

       
Why Caplets

       

-        Stop being your agent's human integration layer.
+        Stop carrying every handoff.
       

       

-        Your agent changes the code. You still carry the issue context, inspect CI, trigger the deployment, and report the result.
-      

-      

-        Caplets lets the agent continue across systems you intentionally expose while preserving each backend's access controls, schemas, results, and errors.
+        Your agent changes the code. Caplets lets it continue through the systems you authorize.
       

     

 
-    

-      
-  

-    
A reusable capability for coding agents

-    

-      
The agent selects the capabilities this task needs.

-      

-        Each Caplet exposes one controlled capability domain. The agent can combine Caplets at runtime instead of requiring you to prebuild a fixed automation workflow.
-      

-    

+      

+        
Keep focus

+        
Open exact tools and schemas only when the task requires them.

+      

+    
   

 

diff --git a/apps/landing/src/data/landing.ts b/apps/landing/src/data/landing.ts
index 4d3ef1f1..3088da45 100644
--- a/apps/landing/src/data/landing.ts
+++ b/apps/landing/src/data/landing.ts
@@ -26,96 +26,23 @@ export const proofStats = [
   {
     value: "10/10",
     label: "tasks completed",
-    detail:
-      "Caplets Code Mode, progressive modes, direct MCP, and Executor.sh all completed the same task set.",
+    detail: "Code Mode matched every compared mode on task completion.",
   },
   {
-    value: "236,803",
-    label: "average total tokens",
-    detail:
-      "Average request and output tokens for the Code Mode run across the live Pi evaluations.",
+    value: "72.0% fewer",
+    label: "request + output tokens",
+    detail: "Compared with direct vanilla MCP in the live run.",
   },
   {
-    value: "72.0% fewer",
-    label: "than direct MCP",
-    detail:
-      "Fewer request and output tokens than direct vanilla MCP, with the same completed-task result.",
+    value: "7 vs 215",
+    label: "initial choices",
+    detail: "Caplet cards versus direct MCP tools in the deterministic check.",
   },
 ] as const;
 
 export const benchmarkProvenance =
   "Run June 2026 with the real-world large MCP suite, openai-codex/gpt-5.5, 10 tasks, 2 runs per task, and a large no-fixture MCP stack.";
 
-export const benchmarkRows = [
-  {
-    mode: "Caplets Code Mode",
-    passed: "10/10",
-    tokens: "236,803",
-    surfaceTokens: "31,166",
-  },
-  {
-    mode: "Caplets progressive + Code Mode",
-    passed: "10/10",
-    tokens: "422,861",
-    surfaceTokens: "124,772",
-  },
-  {
-    mode: "Caplets progressive",
-    passed: "10/10",
-    tokens: "461,171",
-    surfaceTokens: "103,776",
-  },
-  {
-    mode: "Executor.sh",
-    passed: "10/10",
-    tokens: "675,842",
-    surfaceTokens: "24,570",
-  },
-  {
-    mode: "Direct vanilla MCP",
-    passed: "10/10",
-    tokens: "846,048",
-    surfaceTokens: "457,818",
-  },
-] as const;
-
-export const deterministicSurface = [
-  { label: "direct MCP tools", value: "215" },
-  { label: "Caplet cards shown first", value: "7" },
-  { label: "serialized payload cut", value: "79.9%" },
-] as const;
-
-export const whyCapletsProblems = [
-  {
-    label: "Work stops at the repository",
-    before:
-      "The agent edits code, then waits while you carry context into issues, dashboards, CI, and deployment tools.",
-    after:
-      "Expose the capabilities it needs so the agent can keep the task moving across authorized systems.",
-  },
-  {
-    label: "Every agent needs new wiring",
-    before:
-      "Provider setup, auth, and integration assumptions get repeated across clients and projects.",
-    after:
-      "Reuse the same Caplet definitions from supported agents while each host keeps access independently authorized.",
-  },
-  {
-    label: "Connected agents get overwhelmed",
-    before:
-      "A flat wall of tools and schemas competes with the work as soon as more systems are connected.",
-    after:
-      "Code Mode starts with named handles and opens exact schemas and operations only when the task needs them.",
-  },
-] as const;
-
-export const remoteCommands = {
-  server: `caplets daemon install --start
-caplets remote host approve  --yes`,
-  client: `caplets remote login 
-caplets attach `,
-} as const;
-
 export const portabilitySurfaces = [
   { label: "Native integrations", value: "OpenCode · Pi" },
   { label: "MCP clients", value: "Codex · Claude · compatible clients" },
@@ -123,93 +50,18 @@ export const portabilitySurfaces = [
   { label: "Capability package", value: "The same Caplet definition" },
 ] as const;
 
-export const portabilityClaims = [
-  {
-    label: "Agent portability",
-    detail:
-      "Use the same Caplet definition through each supported surface. The agent experience may differ; the reusable definition stays the same.",
-    points: [
-      "Native OpenCode and Pi integrations",
-      "MCP for Codex, Claude, and compatible clients",
-      "Remote Attach for supported clients",
-    ],
-  },
-  {
-    label: "Capability sharing",
-    detail:
-      "Keep a Caplet local, share it with a team, or publish it for the community. Each recipient supplies and authorizes their own credentials.",
-    points: [
-      "Reuse it across your agents and projects",
-      "Share it with a team",
-      "Publish it for the community",
-    ],
-  },
-] as const;
-
 export const themeColor = "oklch(18% 0.014 100)";
 
-export const exampleCaplets = [
-  {
-    id: "osv",
-    name: "OSV",
-    summary:
-      "Vulnerability lookups by package, purl, commit, or batch query, with no auth ceremony.",
-    why: "Best first install: it proves the Caplet flow before OAuth or provider secrets enter the picture.",
-    path: ["osv", "inspect", "search_tools", "get_tool", "call_tool"],
-    steps: [
-      { command: "caplets setup", label: "Caplets setup command" },
-      {
-        command: "caplets install spiritledsoftware/caplets osv",
-        label: "OSV caplet install command",
-      },
-      { command: 'codex "try using the osv caplet"', label: "Codex trial command" },
-    ],
-    help: ["OSV is public. If the trial fails, check Node 22+ and rerun ", "caplets setup", "."],
-  },
-  {
-    id: "github",
-    name: "GitHub",
-    summary:
-      "Repositories, issues, pull requests, branches, commits, and reviews behind one capability card.",
-    why: "This is the stress case: a valuable MCP server that is painful when every operation is exposed at once.",
-    path: ["github", "inspect", "search_tools", "get_tool", "call_tool"],
-    steps: [
-      { command: "export GH_TOKEN=github_pat_...", label: "GitHub token export" },
-      { command: "caplets setup", label: "Caplets setup command" },
-      {
-        command: "caplets install spiritledsoftware/caplets github",
-        label: "GitHub caplet install command",
-      },
-      { command: 'codex "try using the github caplet"', label: "Codex trial command" },
-    ],
-    help: [
-      "If setup fails, check Node 22+, rerun ",
-      "caplets setup",
-      ", and confirm ",
-      "GH_TOKEN",
-      ".",
-    ],
-  },
-  {
-    id: "sourcegraph",
-    name: "Sourcegraph",
-    summary:
-      "Hosted code search for examples, references, and implementation patterns across repositories.",
-    why: "Good for search-first work: the agent asks for matches, then opens only the operations it needs.",
-    path: ["sourcegraph", "inspect", "search_tools", "get_tool", "call_tool"],
-    steps: [
-      { command: "caplets setup", label: "Caplets setup command" },
-      {
-        command: "caplets install spiritledsoftware/caplets sourcegraph",
-        label: "Sourcegraph caplet install command",
-      },
-      { command: "caplets auth login sourcegraph", label: "Sourcegraph auth command" },
-      { command: 'codex "try using the sourcegraph caplet"', label: "Codex trial command" },
-    ],
-    help: [
-      "If setup fails, check Node 22+, rerun ",
-      "caplets setup",
-      ", and finish Sourcegraph OAuth login.",
-    ],
-  },
-] as const;
+export const firstCaplet = {
+  name: "OSV",
+  summary: "Public vulnerability lookups with no token or OAuth setup.",
+  steps: [
+    { command: "caplets setup", label: "Caplets setup command" },
+    {
+      command: "caplets install spiritledsoftware/caplets osv",
+      label: "OSV caplet install command",
+    },
+    { command: 'codex "try using the osv caplet"', label: "Codex trial command" },
+  ],
+  help: ["If the trial fails, check Node 22+ and rerun ", "caplets setup", "."],
+} as const;
diff --git a/apps/landing/src/pages/index.astro b/apps/landing/src/pages/index.astro
index 3db4a906..0cc9f0fb 100644
--- a/apps/landing/src/pages/index.astro
+++ b/apps/landing/src/pages/index.astro
@@ -1,7 +1,6 @@
 ---
 import Activation from "../components/landing/Activation.astro";
 import Breadth from "../components/landing/Breadth.astro";
-import AgentTrace from "../components/landing/AgentTrace.astro";
 import CapabilityAperture from "../components/landing/CapabilityAperture.astro";
 import Footer from "../components/landing/Footer.astro";
 import Header from "../components/landing/Header.astro";
@@ -16,7 +15,6 @@ import LandingLayout from "../layouts/LandingLayout.astro";
 
   
   

-  
   
   
   
@@ -29,7 +27,6 @@ import LandingLayout from "../layouts/LandingLayout.astro";