diff --git a/AGENTS.md b/AGENTS.md
index 53d9d7b4..0a1edab3 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -27,6 +27,7 @@
 
 - Keep tests that protect behavior, user-visible contracts, generated artifacts, integrations, regressions, or data-safety boundaries. Remove or avoid tests that mostly restate implementation literals.
 - Do not add tests that only assert package metadata, prompt/help copy substrings, Markdown wrapper scaffolding, export importability, or duplicated flag passthrough when stronger behavior coverage already exists.
+- Do not add tests for marketing/blog/editorial prose, exact headlines, body copy, or subjective positioning. Copy is reviewed by humans, not locked by tests; only test durable content-system behavior such as schema validation, routing, metadata generation, or safety boundaries.
 - Prefer Code Mode coverage through structured envelopes, session/recovery metadata, generated API checks, schema checks, and real tool execution. Avoid long prompt-description snapshots.
 - Prefer benchmark tests that validate metric shape and failure thresholds. Do not pin static scenario IDs or improvement-name fixtures unless the exact list is the behavior under test.
 - When deleting or skipping a narrow unit test, make sure a stronger integration test, generated-file check, or full gate still protects the meaningful behavior.
diff --git a/apps/landing/src/components/landing/BlogArticle.astro b/apps/landing/src/components/landing/BlogArticle.astro
new file mode 100644
index 00000000..60464cb3
--- /dev/null
+++ b/apps/landing/src/components/landing/BlogArticle.astro
@@ -0,0 +1,34 @@
+---
+interface Props {
+  canonicalPath: string;
+  date: Date;
+  description: string;
+  title: string;
+}
+
+const { canonicalPath, date, description, title } = Astro.props;
+---
+
+<article class="mx-auto w-[min(840px,calc(100vw_-_32px))] py-20 md:py-28">
+  <a class="text-sm font-medium text-primary-accent hover:text-foreground" href="/blog/">Blog</a>
+  <h1 class="mt-4 text-4xl leading-tight font-semibold tracking-[-0.03em] text-balance text-foreground md:text-6xl">
+    {title}
+  </h1>
+  <p class="mt-5 text-xl leading-8 text-pretty text-muted-foreground">{description}</p>
+  <time class="mt-6 block text-sm text-muted-foreground" datetime={date.toISOString()}>
+    {
+      date.toLocaleDateString("en", {
+        day: "numeric",
+        month: "long",
+        year: "numeric",
+        timeZone: "UTC",
+      })
+    }
+  </time>
+  <div class="blog-prose mt-12">
+    <slot />
+  </div>
+  <p class="mt-12 text-sm text-muted-foreground">
+    Canonical URL: <a class="text-foreground underline decoration-border underline-offset-4 hover:text-primary-accent" href={canonicalPath}>{canonicalPath}</a>
+  </p>
+</article>
diff --git a/apps/landing/src/components/landing/BlogCta.astro b/apps/landing/src/components/landing/BlogCta.astro
new file mode 100644
index 00000000..ff7bd377
--- /dev/null
+++ b/apps/landing/src/components/landing/BlogCta.astro
@@ -0,0 +1,42 @@
+---
+import ArrowUpRight from "@tabler/icons/outline/arrow-up-right.svg";
+
+import { Button } from "@/components/starwind/button";
+import { Card, CardContent } from "@/components/starwind/card";
+---
+
+<Card class="mt-14 overflow-hidden border-primary-accent/35 bg-card/85">
+  <CardContent class="grid gap-6 p-6 md:grid-cols-[1fr_auto] md:items-center">
+    <div>
+      <p class="text-sm font-medium text-primary-accent">Try Caplets</p>
+      <h2 class="mt-2 text-2xl font-semibold tracking-[-0.02em] text-foreground">Give your agent capabilities, not giant tool walls.</h2>
+      <p class="mt-3 max-w-2xl leading-7 text-muted-foreground">
+        Install the CLI, wire up your agent, browse the catalog, or read the benchmark method behind the launch claim.
+      </p>
+      <code class="mt-5 block overflow-x-auto rounded-lg bg-foreground p-4 font-mono text-sm leading-6 whitespace-pre text-background">npm install -g caplets
+caplets setup</code>
+    </div>
+    <div class="flex flex-col gap-3 sm:flex-row md:flex-col">
+      <Button href="https://docs.caplets.dev" variant="outline">
+        Read docs
+        <ArrowUpRight class="size-4" aria-hidden="true" />
+      </Button>
+      <Button href="https://catalog.caplets.dev" variant="outline">
+        Browse catalog
+        <ArrowUpRight class="size-4" aria-hidden="true" />
+      </Button>
+      <Button href="https://github.com/spiritledsoftware/caplets" variant="outline">
+        GitHub repo
+        <ArrowUpRight class="size-4" aria-hidden="true" />
+      </Button>
+      <Button href="https://www.npmjs.com/package/caplets" variant="outline">
+        npm package
+        <ArrowUpRight class="size-4" aria-hidden="true" />
+      </Button>
+      <Button href="https://github.com/spiritledsoftware/caplets/blob/main/docs/benchmarks/coding-agent.md" variant="outline">
+        Benchmark method
+        <ArrowUpRight class="size-4" aria-hidden="true" />
+      </Button>
+    </div>
+  </CardContent>
+</Card>
diff --git a/apps/landing/src/components/landing/Footer.astro b/apps/landing/src/components/landing/Footer.astro
index b5971d0a..e4bebdac 100644
--- a/apps/landing/src/components/landing/Footer.astro
+++ b/apps/landing/src/components/landing/Footer.astro
@@ -6,6 +6,7 @@ import ArrowUpRight from "@tabler/icons/outline/arrow-up-right.svg";
   <div class="mx-auto flex w-[min(1180px,calc(100vw_-_32px))] flex-col gap-5 text-sm text-muted-foreground md:flex-row md:items-center md:justify-between">
     <p>Caplets gives agents capabilities, not giant tool walls.</p>
     <nav class="flex flex-wrap gap-4" aria-label="Footer links">
+      <a class="inline-flex min-h-11 items-center gap-1 font-medium hover:text-foreground" href="/blog/">Blog</a>
       <a class="inline-flex min-h-11 items-center gap-1 font-medium hover:text-foreground" href="https://catalog.caplets.dev">
         Catalog
         <ArrowUpRight class="size-3.5" aria-hidden="true" />
diff --git a/apps/landing/src/components/landing/Header.astro b/apps/landing/src/components/landing/Header.astro
index 905221c5..4d735ef3 100644
--- a/apps/landing/src/components/landing/Header.astro
+++ b/apps/landing/src/components/landing/Header.astro
@@ -22,6 +22,7 @@ import { Sheet, SheetContent, SheetHeader, SheetTitle, SheetTrigger } from "@/co
       <a class="site-header__section-link inline-flex min-h-11 items-center rounded-md px-3 py-2 transition hover:bg-muted hover:text-foreground focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href="#why">Why</a>
       <a class="site-header__section-link inline-flex min-h-11 items-center rounded-md px-3 py-2 transition hover:bg-muted hover:text-foreground focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href="#install">Setup</a>
       <a class="site-header__section-link inline-flex min-h-11 items-center rounded-md px-3 py-2 transition hover:bg-muted hover:text-foreground focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href="#proof">Benchmark</a>
+      <a class="site-header__section-link inline-flex min-h-11 items-center rounded-md px-3 py-2 transition hover:bg-muted hover:text-foreground focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href="/blog/">Blog</a>
       <a class="site-header__section-link inline-flex min-h-11 items-center rounded-md px-3 py-2 transition hover:bg-muted hover:text-foreground focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href="#remote">Remote</a>
       <a class="site-header__docs-link inline-flex min-h-11 items-center gap-1.5 rounded-md px-3 py-2 transition hover:bg-muted hover:text-foreground focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href="https://catalog.caplets.dev" target="_blank" rel="noopener noreferrer">
         Catalog
@@ -62,6 +63,7 @@ import { Sheet, SheetContent, SheetHeader, SheetTitle, SheetTrigger } from "@/co
             <a class="starwind-dialog-close flex min-h-11 items-center rounded-md px-3 py-2.5 text-muted-foreground transition hover:bg-muted hover:text-foreground focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href="#why">Why Caplets</a>
             <a class="starwind-dialog-close flex min-h-11 items-center rounded-md px-3 py-2.5 text-muted-foreground transition hover:bg-muted hover:text-foreground focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href="#install">Setup</a>
             <a class="starwind-dialog-close flex min-h-11 items-center rounded-md px-3 py-2.5 text-muted-foreground transition hover:bg-muted hover:text-foreground focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href="#proof">Benchmark</a>
+            <a class="starwind-dialog-close flex min-h-11 items-center rounded-md px-3 py-2.5 text-muted-foreground transition hover:bg-muted hover:text-foreground focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href="/blog/">Blog</a>
             <a class="starwind-dialog-close flex min-h-11 items-center rounded-md px-3 py-2.5 text-muted-foreground transition hover:bg-muted hover:text-foreground focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href="#remote">Remote server</a>
             <a class="starwind-dialog-close inline-flex min-h-11 items-center justify-between rounded-md px-3 py-2.5 text-foreground transition hover:bg-muted focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href="https://catalog.caplets.dev" target="_blank" rel="noopener noreferrer">
               Catalog
diff --git a/apps/landing/src/content.config.ts b/apps/landing/src/content.config.ts
new file mode 100644
index 00000000..15c58a32
--- /dev/null
+++ b/apps/landing/src/content.config.ts
@@ -0,0 +1,17 @@
+import { defineCollection } from "astro:content";
+import { glob } from "astro/loaders";
+import { z } from "astro/zod";
+
+export const collections = {
+  blog: defineCollection({
+    loader: glob({ pattern: "**/*.md", base: "./src/content/blog" }),
+    schema: z.object({
+      title: z.string(),
+      description: z.string(),
+      date: z.coerce.date(),
+      tags: z.array(z.string()).default([]),
+      draft: z.boolean().default(false),
+      ogImage: z.string().optional(),
+    }),
+  }),
+};
diff --git a/apps/landing/src/content/blog/why-giant-mcp-tool-walls-dont-scale.md b/apps/landing/src/content/blog/why-giant-mcp-tool-walls-dont-scale.md
new file mode 100644
index 00000000..f7739dc6
--- /dev/null
+++ b/apps/landing/src/content/blog/why-giant-mcp-tool-walls-dont-scale.md
@@ -0,0 +1,292 @@
+---
+title: Why Most MCP Clients Suck
+description: "Large MCP servers are not the problem. GitHub, Slack, Linear, and Cloudflare should expose everything. The broken part is clients that make the model babysit that whole surface one raw call at a time."
+date: 2026-07-01
+tags:
+  - MCP
+  - agents
+  - benchmarks
+  - Code Mode
+---
+
+Everyone keeps complaining about large MCP servers.
+
+GitHub exposes too much.
+Slack exposes too much.
+Linear exposes too much.
+Cloudflare exposes too much.
+
+Honestly?
+
+Bring it on.
+
+I want GitHub's MCP server to expose every issue, PR, workflow run, code search result, discussion, release, branch protection rule, permission, audit event, and weird corner of the API.
+
+I want Slack to expose the whole workspace.
+I want Linear to expose the whole product system.
+I want Cloudflare to expose the whole platform.
+
+That is the point.
+
+MCP servers should be rich. They should be complete. They should expose the real surface area of the service instead of some tiny toy subset that only works in a demo.
+
+The bloat is not the enemy.
+
+The client is the broken part.
+
+Most MCP clients take a huge server and flatten it straight into the model loop.
+
+Pick a tool.
+Read the schema.
+Call it.
+Get a blob back.
+Read the blob.
+Pick another tool.
+Call it.
+Get another blob.
+Try to remember which three fields mattered from the last six calls.
+
+That is not an agent workflow.
+
+That is making the model manually drive an API client through a chat window.
+
+MCP is good. The protocol is not the villain here.
+
+The mistake is treating the model like it should personally inspect every tool, every response, every follow-up decision, and every noisy intermediate payload.
+
+It should not.
+
+The server should be rich.
+The client should be smart.
+The model should only see what matters.
+
+That is Caplets.
+
+## Stop shrinking the server
+
+The common reaction to MCP bloat is to make the server smaller.
+
+Expose fewer tools.
+Hide parts of the API.
+Handcraft a tiny happy-path surface.
+Pretend the real product is simpler than it is.
+
+I think that is backwards.
+
+If the service is large, the MCP server should be large too.
+
+GitHub is not small. Cloudflare is not small. Stripe is not small. Linear is not small. Any useful internal platform at a real company is not small.
+
+The agent needs access to the actual surface area eventually.
+
+The problem is not that a server has 200 tools.
+
+The problem is that most clients act like the only two options are:
+
+1. dump all 200 tools into the model's face, or
+2. remove most of the capability.
+
+That is a false choice.
+
+You do not fix a rich capability surface by amputating it.
+
+You fix it by giving the agent a better way to move through it.
+
+Search the capability.
+Inspect the specific operation.
+Call what matters.
+Batch the boring middle steps.
+Filter the raw backend exhaust.
+Return compact evidence.
+
+That is the missing layer.
+
+## The broken loop
+
+Flat MCP aggregation looks fine in demos.
+
+The toy server has a few tools. The names are clean. The responses are small. The happy path works.
+
+Then you point it at a real backend.
+
+Now the agent has broad surfaces, generic operation names, nested schemas, pagination, noisy records, partial failures, and follow-up calls that only make sense after the first result comes back.
+
+The bad client loop looks like this:
+
+1. The model scans a giant initial tool list.
+2. It guesses which generic operation belongs to the task.
+3. The client sends raw output back into the conversation.
+4. The model reads the raw output and decides the next call.
+5. The client sends another raw payload back.
+6. Repeat until the answer is somewhere in the context window.
+
+That is not capability.
+
+That is remote-controlling an API with a language model.
+
+And it gets worse as the server gets better.
+
+The more complete the server is, the more the naive client punishes you for using it.
+
+That is insane.
+
+A good MCP server should be allowed to be huge. The client should make that hugeness navigable.
+
+The model should not need to see every field in every candidate object just to answer a focused question. It should not need to burn tokens reading intermediate junk that a tiny bit of local logic could have filtered away.
+
+The model should see the evidence.
+
+It does not need to watch the plumbing.
+
+## Caplets is the client-side moat
+
+Caplets is not a plea for smaller MCP servers.
+
+It is the opposite.
+
+Caplets assumes MCP servers are going to be big, messy, useful, and full of stuff.
+
+Good.
+
+The job is to make that surface agent-usable.
+
+Instead of handing the model one giant flattened tool wall, Caplets gives the agent named capability handles. The agent can inspect a capability, search its operations, describe the schema it actually needs, call the operation, join follow-up calls, filter noisy data, and return a decision-ready result.
+
+That changes the shape of the interaction.
+
+The agent is no longer asking the model to babysit every backend call.
+
+It can do the boring middle work near the tools and bring back the answer with the evidence that supports it.
+
+This is the moat.
+
+Not “we made MCP smaller.”
+
+More like: “we made large MCP servers usable without dumping the whole thing into model context.”
+
+## Batching is the point
+
+The thing I keep coming back to is that most useful backend tasks are not one call.
+
+They are small investigations.
+
+Find the right operation. Inspect the shape. Fetch candidates. Throw away irrelevant records. Preserve the fields that matter. Maybe make a follow-up call. Then come back with the answer and the evidence.
+
+A normal MCP client tends to spread that whole investigation across the chat transcript.
+
+Caplets Code Mode lets the agent do it as one bounded workflow.
+
+Inside Code Mode, the agent can write a compact TypeScript script that discovers, filters, joins, and summarizes before returning anything to the model. The final output can be small JSON with the exact facts needed for the decision.
+
+That changes the cost profile.
+
+Instead of paying model-context rent for every intermediate object, you keep bulky exploration inside the workflow and only bring back the useful part.
+
+That is the wedge.
+
+Not “hide the tools.”
+
+More like: “let the server expose everything, then give the agent a sane way to work with it.”
+
+## What the benchmark actually says
+
+The deterministic benchmark in this repo compares direct flat MCP exposure with Caplets capability exposure over local mock MCP metadata.
+
+It is deliberately boring. No external APIs. No network. No model credentials. No vibes.
+
+In that fixture, Caplets shows:
+
+- 80.5% fewer model/tool round trips in the Code Mode workflow fixture versus equivalent progressive-disclosure sequences, with required evidence fields preserved.
+- 96.7% fewer initially visible tools: 215 direct flat tools became 7 Caplets top-level handles.
+- 79.9% lower initial serialized tool payload.
+- 12,633 fewer approximate initial context tokens.
+- 0 top-level duplicate tool-name collisions, compared with repeated direct collisions for generic names such as `get` and `search`.
+
+The important word is “visible.”
+
+Caplets is not saying the downstream capability should disappear.
+
+Those 215 operations can still exist. The server can still be broad. The backend can still expose the real product.
+
+The difference is that the first thing the model sees is not a giant wall of every operation and every schema.
+
+It sees a smaller set of capability handles and can progressively discover what it needs.
+
+The bigger win is workflow shape: batch the investigation, filter before the model sees it, and return compact evidence instead of raw backend exhaust.
+
+These are deterministic context-surface and workflow-shape claims. They are not a promise that every model, every server, and every task gets faster in every environment.
+
+Real MCP servers vary in schema quality, latency, operation count, and error behavior. Live benchmarks are useful, but they are model-dependent and should be treated like local result artifacts, not universal product claims.
+
+## Why Code Mode matters
+
+Progressive discovery is a good start because it stops spraying every downstream operation into the initial prompt.
+
+Code Mode is where it gets interesting.
+
+It gives the agent a place to do the middle of the job without dumping every intermediate result into chat.
+
+That middle is where a lot of agent work actually lives:
+
+- discover the right operation
+- inspect the schema
+- fetch candidate records
+- keep the evidence fields
+- drop the noise
+- join follow-up calls
+- return the smallest useful answer
+
+That is not glamorous. It is plumbing.
+
+But good plumbing is the difference between an agent that feels sharp and an agent that feels like it is reading logs out loud.
+
+A capability layer should help the agent get work done. It should not ask the model to survive the blast radius of a rich MCP server.
+
+## Try it
+
+Install Caplets and wire it into your agent:
+
+```sh
+npm install -g caplets
+caplets setup
+```
+
+Then install a no-auth example Caplet:
+
+```sh
+caplets install spiritledsoftware/caplets osv
+```
+
+Ask your coding agent to use Caplets Code Mode to query OSV for a package version and return compact JSON.
+A successful run should use the visible `caplets__code_mode` tool and inspect a handle such as `caplets.osv`.
+
+## Reproduce the benchmark
+
+The committed benchmark report is in `docs/benchmarks/coding-agent.md`.
+To regenerate it locally from the repository, run:
+
+```sh
+pnpm benchmark
+```
+
+The benchmark is narrow on purpose.
+
+It measures initial tool surface, serialized payload size, approximate context-token proxy, duplicate-name pressure, preserved evidence fields, and deterministic workflow shape.
+
+It does not pretend to prove that every model, server, or task is faster in every environment.
+
+## The claim
+
+MCP made tool connection easy.
+
+Now let MCP servers be big.
+
+Let them expose everything.
+
+Bring on the giant GitHub server. Bring on the giant Cloudflare server. Bring on the internal platform with 600 weird operations nobody remembers until they need one.
+
+That is not the problem.
+
+The next fight is smarter clients: clients that let agents search, batch, filter, and return evidence without making the model babysit every API call.
+
+Give your agent capabilities, not a junk drawer with schemas.
diff --git a/apps/landing/src/layouts/LandingLayout.astro b/apps/landing/src/layouts/LandingLayout.astro
index f36e6621..8aca0a6f 100644
--- a/apps/landing/src/layouts/LandingLayout.astro
+++ b/apps/landing/src/layouts/LandingLayout.astro
@@ -2,16 +2,25 @@
 import "../styles/starwind.css";
 import "../styles/global.css";
 import { themeColor } from "../data/landing";
+import { landingSiteUrl } from "../lib/blog";
 
 interface Props {
-  title?: string;
+  canonicalUrl?: string;
   description?: string;
+  ogImage?: string;
+  ogType?: "article" | "website";
+  title?: string;
 }
 
 const {
+  canonicalUrl,
   title = "Caplets, capabilities instead of giant tool walls",
   description = "Caplets gives coding agents focused capability modes instead of giant MCP tool walls.",
+  ogImage = "/icon.png",
+  ogType = "website",
 } = Astro.props;
+const canonicalHref = canonicalUrl ? new URL(canonicalUrl, landingSiteUrl).href : undefined;
+const ogImageUrl = new URL(ogImage, landingSiteUrl).href;
 ---
 
 <html lang="en" class="dark">
@@ -22,6 +31,16 @@ const {
     <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
     <meta name="generator" content={Astro.generator} />
     <meta name="description" content={description} />
+    {canonicalHref && <link rel="canonical" href={canonicalHref} />}
+    <meta property="og:title" content={title} />
+    <meta property="og:description" content={description} />
+    {canonicalHref && <meta property="og:url" content={canonicalHref} />}
+    <meta property="og:type" content={ogType} />
+    <meta property="og:image" content={ogImageUrl} />
+    <meta name="twitter:card" content="summary_large_image" />
+    <meta name="twitter:title" content={title} />
+    <meta name="twitter:description" content={description} />
+    <meta name="twitter:image" content={ogImageUrl} />
     <meta name="theme-color" content={themeColor} />
     <title>{title}</title>
   </head>
diff --git a/apps/landing/src/lib/blog.ts b/apps/landing/src/lib/blog.ts
new file mode 100644
index 00000000..27fad0f6
--- /dev/null
+++ b/apps/landing/src/lib/blog.ts
@@ -0,0 +1,39 @@
+export const landingSiteUrl = "https://caplets.dev";
+
+export type BlogPostLike = {
+  slug: string;
+  data: {
+    date: Date;
+    draft?: boolean;
+  };
+};
+
+export function blogPostUrl(slug: string): string {
+  return `/blog/${slug}/`;
+}
+
+export function blogIndexUrl(): string {
+  return new URL("/blog/", landingSiteUrl).href;
+}
+
+export function absoluteBlogPostUrl(slug: string): string {
+  return new URL(blogPostUrl(slug), landingSiteUrl).href;
+}
+
+export function sortBlogPostsNewestFirst<const TPost extends BlogPostLike>(
+  posts: TPost[],
+): TPost[] {
+  return posts
+    .filter((post) => !post.data.draft)
+    .toSorted((a, b) => b.data.date.getTime() - a.data.date.getTime());
+}
+
+export async function getSortedBlogPosts() {
+  const { getCollection } = await import("astro:content");
+  return sortBlogPostsNewestFirst(
+    (await getCollection("blog")).map((entry) => ({
+      ...entry,
+      slug: entry.id,
+    })),
+  );
+}
diff --git a/apps/landing/src/pages/blog/[slug].astro b/apps/landing/src/pages/blog/[slug].astro
new file mode 100644
index 00000000..63c8b717
--- /dev/null
+++ b/apps/landing/src/pages/blog/[slug].astro
@@ -0,0 +1,44 @@
+---
+import { render } from "astro:content";
+
+import BlogArticle from "../../components/landing/BlogArticle.astro";
+import BlogCta from "../../components/landing/BlogCta.astro";
+import Footer from "../../components/landing/Footer.astro";
+import Header from "../../components/landing/Header.astro";
+import LandingLayout from "../../layouts/LandingLayout.astro";
+import { absoluteBlogPostUrl, blogPostUrl, getSortedBlogPosts } from "../../lib/blog";
+
+export async function getStaticPaths() {
+  const posts = await getSortedBlogPosts();
+
+  return posts.map((entry) => ({
+    params: { slug: entry.slug },
+    props: { entry },
+  }));
+}
+
+const { entry } = Astro.props;
+const { Content } = await render(entry);
+const canonicalPath = blogPostUrl(entry.slug);
+const canonicalUrl = absoluteBlogPostUrl(entry.slug);
+---
+
+<LandingLayout
+  canonicalUrl={canonicalUrl}
+  title={`${entry.data.title} | Caplets Blog`}
+  description={entry.data.description}
+  ogType="article"
+  ogImage={entry.data.ogImage ?? "/icon.png"}
+>
+  <Header slot="header" />
+  <BlogArticle title={entry.data.title} description={entry.data.description} date={entry.data.date} canonicalPath={canonicalPath}>
+    <Content />
+    <BlogCta />
+  </BlogArticle>
+  <Footer slot="footer" />
+</LandingLayout>
+
+<script>
+  import "../../scripts/observability";
+  import "../../scripts/header-collapse";
+</script>
diff --git a/apps/landing/src/pages/blog/index.astro b/apps/landing/src/pages/blog/index.astro
new file mode 100644
index 00000000..e7c66750
--- /dev/null
+++ b/apps/landing/src/pages/blog/index.astro
@@ -0,0 +1,72 @@
+---
+import ArrowUpRight from "@tabler/icons/outline/arrow-up-right.svg";
+
+import Footer from "../../components/landing/Footer.astro";
+import Header from "../../components/landing/Header.astro";
+import { Badge } from "../../components/starwind/badge";
+import { Card, CardContent } from "../../components/starwind/card";
+import LandingLayout from "../../layouts/LandingLayout.astro";
+import { blogIndexUrl, blogPostUrl, getSortedBlogPosts } from "../../lib/blog";
+
+const posts = await getSortedBlogPosts();
+const featuredTitle = posts[0]?.data.title ?? "our launch essay";
+---
+
+<LandingLayout
+  canonicalUrl={blogIndexUrl()}
+  title="Caplets Blog"
+  description="Long-form notes and benchmark-backed proof for Caplets."
+>
+  <Header slot="header" />
+  <section class="mx-auto w-[min(960px,calc(100vw_-_32px))] py-20 md:py-28" aria-labelledby="blog-title">
+    <p class="text-sm font-medium text-primary-accent">Blog</p>
+    <h1 id="blog-title" class="mt-3 max-w-3xl text-4xl leading-tight font-semibold tracking-[-0.03em] text-balance text-foreground md:text-6xl">
+      Notes on agents, capabilities, and the tool wall problem.
+    </h1>
+    <p class="mt-6 max-w-2xl text-lg leading-8 text-pretty text-muted-foreground">
+      Start with the launch essay, <span class="text-foreground">{featuredTitle}</span>, then syndicate the canonical URL wherever developers already talk about MCP.
+    </p>
+  </section>
+
+  <section class="mx-auto w-[min(960px,calc(100vw_-_32px))] pb-24" aria-label="Blog posts">
+    <div class="grid gap-4">
+      {
+        posts.map((post) => (
+          <Card class="overflow-hidden">
+            <CardContent class="grid gap-5 p-6 md:grid-cols-[1fr_auto] md:items-start">
+              <div>
+                <div class="mb-4 flex flex-wrap items-center gap-2">
+                  <time class="text-sm text-muted-foreground" datetime={post.data.date.toISOString()}>
+                    {post.data.date.toLocaleDateString("en", {
+                      day: "numeric",
+                      month: "long",
+                      year: "numeric",
+                      timeZone: "UTC",
+                    })}
+                  </time>
+                  {post.data.tags.map((tag) => <Badge variant="outline">{tag}</Badge>)}
+                </div>
+                <h2 class="text-2xl font-semibold tracking-[-0.02em] text-foreground">
+                  <a class="rounded-sm hover:text-primary-accent focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href={blogPostUrl(post.slug)}>
+                    {post.data.title}
+                  </a>
+                </h2>
+                <p class="mt-3 max-w-2xl leading-7 text-muted-foreground">{post.data.description}</p>
+              </div>
+              <a class="inline-flex min-h-11 items-center gap-2 rounded-md border border-border px-4 py-2 text-sm font-medium text-foreground transition hover:bg-muted focus-visible:ring-3 focus-visible:ring-outline/50 focus-visible:outline-none" href={blogPostUrl(post.slug)}>
+                Read post
+                <ArrowUpRight class="size-4" aria-hidden="true" />
+              </a>
+            </CardContent>
+          </Card>
+        ))
+      }
+    </div>
+  </section>
+  <Footer slot="footer" />
+</LandingLayout>
+
+<script>
+  import "../../scripts/observability";
+  import "../../scripts/header-collapse";
+</script>
diff --git a/apps/landing/src/scripts/observability.ts b/apps/landing/src/scripts/observability.ts
index 6fe90d72..fcd424b8 100644
--- a/apps/landing/src/scripts/observability.ts
+++ b/apps/landing/src/scripts/observability.ts
@@ -47,9 +47,10 @@ if (sentryDsn) {
   });
 }
 
+const routeFamily = currentRouteFamily();
 captureLandingEvent("caplets_site_pageview", {
-  route_family: classifyRouteFamily(window.location.pathname),
-  page_family: "home",
+  route_family: routeFamily,
+  page_family: routeFamily,
   referrer_category: referrerCategory(document.referrer),
 });
 
@@ -58,11 +59,13 @@ document.addEventListener("click", (event) => {
   if (!link) return;
   const category = linkCategory(link);
   if (category === "unknown") return;
+  const routeFamily = currentRouteFamily();
   captureLandingEvent("caplets_site_intent", {
-    route_family: "home",
+    route_family: routeFamily,
+    page_family: routeFamily,
     section_category: sectionCategory(link),
     navigation_path_category:
-      category === "docs" || category === "catalog"
+      category === "docs" || category === "catalog" || category === "blog"
         ? category
         : category === "github"
           ? "external"
@@ -78,12 +81,16 @@ export function attributedLandingCommand(command: string): string {
 
 export function captureLandingInstallCopy(): void {
   captureLandingEvent("caplets_install_intent", {
-    route_family: "home",
+    route_family: currentRouteFamily(),
     section_category: "install",
     install_intent_category: "copy",
   });
 }
 
+function currentRouteFamily(): WebEventPropertySet["route_family"] {
+  return classifyRouteFamily(window.location.pathname);
+}
+
 function captureLandingEvent(name: WebEventName, properties: WebEventPropertySet): void {
   if (!posthogEnabled) return;
   try {
@@ -123,6 +130,7 @@ function linkCategory(
   const href = link.getAttribute("href") ?? "";
   if (href.includes("github.com")) return "github";
   if (href.includes("npmjs.com")) return "npm";
+  if (href.startsWith("/blog") || href.includes("caplets.dev/blog")) return "blog";
   if (href.startsWith("/docs") || href.includes("docs.caplets")) return "docs";
   if (
     href.startsWith("/catalog") ||
@@ -143,6 +151,7 @@ function sectionCategory(
   const text = `${section?.id ?? ""} ${section?.className ?? ""}`.toLowerCase();
   if (text.includes("hero")) return "hero";
   if (text.includes("install") || text.includes("activation")) return "install";
+  if (text.includes("blog")) return "blog";
   if (text.includes("docs")) return "docs";
   if (text.includes("catalog")) return "catalog";
   return "unknown";
@@ -151,6 +160,7 @@ function sectionCategory(
 function ctaCategory(element: HTMLElement): NonNullable<WebEventPropertySet["cta_category"]> {
   const text = element.textContent?.toLowerCase() ?? "";
   if (text.includes("install") || text.includes("copy")) return "install";
+  if (text.includes("blog")) return "blog";
   if (text.includes("docs")) return "docs";
   if (text.includes("catalog")) return "catalog";
   return element.closest("main") ? "secondary" : "primary";
diff --git a/apps/landing/src/styles/global.css b/apps/landing/src/styles/global.css
index 7a195d38..64e72b26 100644
--- a/apps/landing/src/styles/global.css
+++ b/apps/landing/src/styles/global.css
@@ -638,3 +638,71 @@ footer {
     transform: none;
   }
 }
+
+.blog-prose {
+  color: var(--muted-foreground);
+  font-size: 1.0625rem;
+  line-height: 1.85;
+}
+
+.blog-prose :where(h2, h3) {
+  color: var(--foreground);
+  font-weight: 650;
+  letter-spacing: -0.02em;
+  line-height: 1.2;
+}
+
+.blog-prose :where(h2) {
+  margin-top: 3rem;
+  font-size: clamp(1.75rem, 3vw, 2.5rem);
+}
+
+.blog-prose :where(h3) {
+  margin-top: 2.25rem;
+  font-size: 1.5rem;
+}
+
+.blog-prose :where(p, ul, ol, pre) {
+  margin-top: 1.25rem;
+}
+
+.blog-prose :where(ul, ol) {
+  padding-left: 1.5rem;
+}
+
+.blog-prose :where(li + li) {
+  margin-top: 0.5rem;
+}
+
+.blog-prose :where(a) {
+  color: var(--foreground);
+  text-decoration: underline;
+  text-decoration-color: var(--border);
+  text-underline-offset: 0.25rem;
+}
+
+.blog-prose :where(a:hover) {
+  color: var(--primary-accent);
+}
+
+.blog-prose :where(code) {
+  border-radius: 0.375rem;
+  background: var(--muted);
+  color: var(--foreground);
+  padding: 0.125rem 0.35rem;
+  font-size: 0.9em;
+}
+
+.blog-prose :where(pre) {
+  overflow-x: auto;
+  border-radius: 0.75rem;
+  background: var(--foreground);
+  color: var(--background);
+  padding: 1rem;
+}
+
+.blog-prose :where(pre code) {
+  background: transparent;
+  color: inherit;
+  padding: 0;
+}
diff --git a/apps/landing/test/blog-content.test.ts b/apps/landing/test/blog-content.test.ts
new file mode 100644
index 00000000..25943a01
--- /dev/null
+++ b/apps/landing/test/blog-content.test.ts
@@ -0,0 +1,18 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+const repoRoot = join(import.meta.dirname, "../../..");
+const contentConfigPath = join(repoRoot, "apps/landing/src/content.config.ts");
+describe("landing blog content", () => {
+  it("defines a typed blog content collection with required launch metadata", () => {
+    const source = readFileSync(contentConfigPath, "utf8");
+
+    expect(source).toContain("blog: defineCollection");
+    expect(source).toContain("title:");
+    expect(source).toContain("description:");
+    expect(source).toContain("date:");
+    expect(source).not.toContain("canonicalPath:");
+    expect(source).toContain("tags:");
+  });
+});
diff --git a/apps/landing/test/blog-metadata.test.ts b/apps/landing/test/blog-metadata.test.ts
new file mode 100644
index 00000000..3b65da70
--- /dev/null
+++ b/apps/landing/test/blog-metadata.test.ts
@@ -0,0 +1,65 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+const repoRoot = join(import.meta.dirname, "../../..");
+
+describe("blog metadata and article presentation", () => {
+  it("lets landing pages provide canonical and social metadata", () => {
+    const layout = readFileSync(
+      join(repoRoot, "apps/landing/src/layouts/LandingLayout.astro"),
+      "utf8",
+    );
+
+    expect(layout).toContain("canonicalUrl");
+    expect(layout).toContain('rel="canonical"');
+    expect(layout).toContain('property="og:title"');
+    expect(layout).toContain('property="og:description"');
+    expect(layout).toContain('property="og:url"');
+    expect(layout).toContain('property="og:type"');
+    expect(layout).toContain("ogImageUrl");
+    expect(layout).toContain('name="twitter:card"');
+    expect(layout).toContain('name="twitter:image"');
+  });
+
+  it("sets canonical metadata on the blog index and post pages", () => {
+    const indexRoute = readFileSync(
+      join(repoRoot, "apps/landing/src/pages/blog/index.astro"),
+      "utf8",
+    );
+    const postRoute = readFileSync(
+      join(repoRoot, "apps/landing/src/pages/blog/[slug].astro"),
+      "utf8",
+    );
+
+    expect(indexRoute).toContain("canonicalUrl={blogIndexUrl()}");
+    expect(postRoute).toContain("canonicalUrl={canonicalUrl}");
+    expect(postRoute).toContain("canonicalPath={canonicalPath}");
+    expect(postRoute).toContain("absoluteBlogPostUrl(entry.slug)");
+  });
+
+  it("uses article and CTA components on blog post pages", () => {
+    const postRoute = readFileSync(
+      join(repoRoot, "apps/landing/src/pages/blog/[slug].astro"),
+      "utf8",
+    );
+    const article = readFileSync(
+      join(repoRoot, "apps/landing/src/components/landing/BlogArticle.astro"),
+      "utf8",
+    );
+    const cta = readFileSync(
+      join(repoRoot, "apps/landing/src/components/landing/BlogCta.astro"),
+      "utf8",
+    );
+
+    expect(postRoute).toContain("BlogArticle");
+    expect(postRoute).toContain("BlogCta");
+    expect(article).toContain("blog-prose");
+    expect(cta).toContain("npm install -g caplets");
+    expect(cta).toContain("https://docs.caplets.dev");
+    expect(cta).toContain("https://catalog.caplets.dev");
+    expect(cta).toContain("https://github.com/spiritledsoftware/caplets");
+    expect(cta).toContain("https://www.npmjs.com/package/caplets");
+    expect(cta).toContain("docs/benchmarks/coding-agent.md");
+  });
+});
diff --git a/apps/landing/test/blog-navigation.test.ts b/apps/landing/test/blog-navigation.test.ts
new file mode 100644
index 00000000..0fb1ea2f
--- /dev/null
+++ b/apps/landing/test/blog-navigation.test.ts
@@ -0,0 +1,35 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+const repoRoot = join(import.meta.dirname, "../../..");
+
+describe("blog navigation", () => {
+  it("links to the first-party blog from desktop and mobile header navigation", () => {
+    const header = readFileSync(
+      join(repoRoot, "apps/landing/src/components/landing/Header.astro"),
+      "utf8",
+    );
+
+    expect(header.match(/href="\/blog\/"/gu)?.length ?? 0).toBeGreaterThanOrEqual(2);
+    expect(header).toContain(">Blog<");
+    expect(header).not.toContain('href="/blog/" target="_blank"');
+
+    const desktopBlogLink = header.match(/<a class="[^"]*" href="\/blog\/">Blog<\/a>/u)?.[0] ?? "";
+    const desktopRemoteLink =
+      header.match(/<a class="[^"]*" href="#remote">Remote<\/a>/u)?.[0] ?? "";
+    expect(desktopBlogLink).toContain("focus-visible:ring-outline/50");
+    expect(desktopRemoteLink).toContain("focus-visible:ring-outline/50");
+  });
+
+  it("links to the first-party blog from the footer without external-link treatment", () => {
+    const footer = readFileSync(
+      join(repoRoot, "apps/landing/src/components/landing/Footer.astro"),
+      "utf8",
+    );
+
+    expect(footer).toContain('href="/blog/"');
+    expect(footer).toContain("Blog");
+    expect(footer).not.toContain('href="/blog/" target="_blank"');
+  });
+});
diff --git a/apps/landing/test/blog-routes.test.ts b/apps/landing/test/blog-routes.test.ts
new file mode 100644
index 00000000..bd58e72a
--- /dev/null
+++ b/apps/landing/test/blog-routes.test.ts
@@ -0,0 +1,49 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+import {
+  blogIndexUrl,
+  blogPostUrl,
+  landingSiteUrl,
+  sortBlogPostsNewestFirst,
+} from "../src/lib/blog";
+
+const repoRoot = join(import.meta.dirname, "../../..");
+
+describe("landing blog routes", () => {
+  it("builds canonical blog URLs from one site origin", () => {
+    expect(landingSiteUrl).toBe("https://caplets.dev");
+    expect(blogIndexUrl()).toBe("https://caplets.dev/blog/");
+    expect(blogPostUrl("why-giant-mcp-tool-walls-dont-scale")).toBe(
+      "/blog/why-giant-mcp-tool-walls-dont-scale/",
+    );
+  });
+
+  it("sorts public posts newest first", () => {
+    const posts = sortBlogPostsNewestFirst([
+      { slug: "older", data: { date: new Date("2026-01-01"), draft: false } },
+      { slug: "draft", data: { date: new Date("2026-12-01"), draft: true } },
+      { slug: "newer", data: { date: new Date("2026-07-01"), draft: false } },
+    ]);
+
+    expect(posts.map((post) => post.slug)).toEqual(["newer", "older"]);
+  });
+
+  it("defines a blog index and static post route from the blog collection", () => {
+    const indexSource = readFileSync(
+      join(repoRoot, "apps/landing/src/pages/blog/index.astro"),
+      "utf8",
+    );
+    const postSource = readFileSync(
+      join(repoRoot, "apps/landing/src/pages/blog/[slug].astro"),
+      "utf8",
+    );
+
+    expect(indexSource).toContain("getSortedBlogPosts");
+    expect(indexSource).toContain("featuredTitle = posts[0]?.data.title");
+    expect(postSource).toContain("getStaticPaths");
+    expect(postSource).toContain("getSortedBlogPosts");
+    expect(postSource).toContain("render(entry)");
+  });
+});
diff --git a/apps/landing/test/observability.test.ts b/apps/landing/test/observability.test.ts
index 7414902e..25670a12 100644
--- a/apps/landing/test/observability.test.ts
+++ b/apps/landing/test/observability.test.ts
@@ -15,6 +15,7 @@ describe("landing observability", () => {
   beforeEach(() => {
     vi.resetModules();
     vi.restoreAllMocks();
+    window.history.pushState({}, "", "/");
     document.body.innerHTML = "";
     Object.defineProperty(navigator, "clipboard", {
       configurable: true,
@@ -65,4 +66,24 @@ describe("landing observability", () => {
       }),
     );
   });
+
+  it("keeps the source route family when navigating from home to blog", async () => {
+    vi.stubEnv("PUBLIC_CAPLETS_POSTHOG_TOKEN", "phc_test");
+    document.body.innerHTML = `<main><a href="/blog/why-giant-mcp-tool-walls-dont-scale/">Read blog</a></main>`;
+
+    await import("../src/scripts/observability");
+    posthogCapture.mockClear();
+    document.querySelector("a")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+
+    expect(posthogCapture).toHaveBeenCalledWith(
+      "caplets_site_intent",
+      expect.objectContaining({
+        route_family: "home",
+        page_family: "home",
+        navigation_path_category: "blog",
+        outbound_action_category: "blog",
+        cta_category: "blog",
+      }),
+    );
+  });
 });
diff --git a/docs/plans/2026-07-01-003-feat-landing-blog-path-plan.md b/docs/plans/2026-07-01-003-feat-landing-blog-path-plan.md
new file mode 100644
index 00000000..0bc1a6ef
--- /dev/null
+++ b/docs/plans/2026-07-01-003-feat-landing-blog-path-plan.md
@@ -0,0 +1,264 @@
+---
+title: Landing Blog Path - Plan
+type: feat
+date: 2026-07-01
+artifact_contract: ce-unified-plan/v1
+artifact_readiness: implementation-ready
+product_contract_source: ce-plan-bootstrap
+execution: code
+---
+
+# Landing Blog Path - Plan
+
+## Goal Capsule
+
+- **Objective:** Add a canonical `/blog` surface to the Caplets landing site so long-form launch and proof content lives on `caplets.dev` and can be syndicated elsewhere.
+- **Product authority:** The blog supports the strategy in `STRATEGY.md`: public proof, reproducible claims, and trust in the Code Mode-first capability model.
+- **Execution profile:** Standard software plan; implement in small units across the Astro landing app and shared web-observability package.
+- **Stop conditions:** Stop and ask if implementation would require a CMS, user accounts, comments, dynamic server rendering, or raw per-post telemetry.
+- **Tail ownership:** The implementation owns the initial static blog surface and first launch essay; ongoing editorial cadence remains marketing work outside this plan.
+
+---
+
+## Product Contract
+
+### Summary
+
+Add a minimal, static, repo-owned blog to `apps/landing` with a `/blog` index and canonical post pages.
+The first post should be the benchmark-backed “tool wall” launch essay, with strong metadata and CTAs into install, docs, catalog, GitHub, and the reproducible benchmark.
+X Articles and social posts remain distribution channels that link back to the canonical Caplets URL.
+
+### Problem Frame
+
+Caplets’ strongest awareness asset is a technical argument backed by reproducible benchmark evidence.
+If the launch essay lives only on X Articles, it will be platform-dependent, harder to cite from PR outreach, weaker for search and AI discovery, and disconnected from install/docs/catalog conversion paths.
+The landing app already presents the core proof and activation story, so a small static blog path is the right owned-media home without introducing CMS carrying cost.
+
+### Requirements
+
+**Canonical owned media**
+
+- R1. The landing site exposes `/blog` as the canonical home for Caplets long-form marketing and technical proof posts.
+- R2. Individual posts have stable slug URLs under `/blog/<slug>/` and include canonical metadata that points to the owned URL.
+- R3. X Articles, social posts, and community submissions are treated as syndication that link back to the canonical blog post.
+
+**Static content and editorial scope**
+
+- R4. Blog posts are repo-owned static Markdown/MDX-style content with typed frontmatter and no CMS dependency.
+- R5. The initial content set includes the “Why Giant MCP Tool Walls Don’t Scale” launch essay with benchmark claims, limitations, and reproduction links.
+- R6. Future recurring content such as “Caplet of the week” is deferred unless it only requires adding more posts to the same static collection.
+
+**Reader experience and conversion**
+
+- R7. The blog index lists posts with title, description, date, category/tag metadata, and a clear path to the canonical post.
+- R8. Post pages preserve the landing site visual language while making long-form reading comfortable on mobile and desktop.
+- R9. Post pages include calls to action for install/setup, docs, catalog, GitHub, npm, and benchmark reproduction where relevant.
+
+**Search, sharing, and privacy-safe measurement**
+
+- R10. Blog pages include title, description, canonical URL, Open Graph, and social-card metadata suitable for launch sharing.
+- R11. Public-site observability classifies blog traffic and blog CTAs categorically without preserving raw slugs, raw URLs, browser identities, or hidden user identifiers.
+- R12. Install-copy attribution from blog CTAs uses the existing landing-surface attribution model unless a future product decision creates a distinct blog marker.
+
+### Scope Boundaries
+
+#### In scope
+
+- Static blog collection for `apps/landing`.
+- `/blog` index and `/blog/<slug>/` detail route.
+- Initial launch essay content.
+- Landing navigation/footer links to the blog.
+- Privacy-safe route and CTA categorization for blog traffic.
+- Source-level tests plus Astro build/typecheck coverage.
+
+#### Deferred to Follow-Up Work
+
+- RSS feed, sitemap customization, and structured Article JSON-LD.
+- Dedicated generated Open Graph images per post.
+- “Caplet of the week” editorial system or recurring templates beyond adding ordinary posts.
+- Search, tags archive, pagination, author pages, comments, newsletter capture, or CMS integration.
+
+#### Outside this product's identity
+
+- Treating X Articles as the canonical source of truth.
+- Turning the catalog site into a blog or mixing editorial content into catalog discovery.
+- Collecting raw article URLs, raw referrers, or user-identifying marketing telemetry.
+
+### Acceptance Examples
+
+- AE1. Given a visitor opens `/blog`, when the page renders, then they see the launch essay card with title, description, date, and a link to the canonical post.
+- AE2. Given a visitor opens `/blog/why-giant-mcp-tool-walls-dont-scale/`, when the page renders, then the article has readable long-form layout, benchmark caveats, reproduction links, and install/docs/catalog CTAs.
+- AE3. Given a social crawler previews the launch post URL, when it reads metadata, then it receives the post-specific title, description, canonical URL, and share image fallback.
+- AE4. Given PostHog is configured, when a visitor opens or clicks through blog pages, then events use categorical `blog` route/page data and never include the raw slug.
+- AE5. Given a post is missing required frontmatter, when the landing app typecheck/build runs, then the content validation fails before deployment.
+
+---
+
+## Planning Contract
+
+### Key Technical Decisions
+
+- KTD1. Use Astro content collections for blog posts. Astro’s current content collection pattern supports typed static Markdown content, `getCollection('blog')`, and static paths without adding a CMS or runtime server.
+- KTD2. Keep blog rendering inside `apps/landing`. The blog is owned marketing/proof content and should inherit landing styling, CTAs, and observability rather than living in Starlight docs or the catalog app.
+- KTD3. Extend `LandingLayout` for page-specific SEO and social metadata. A shared layout prop surface prevents index and post pages from hand-rolling inconsistent head tags.
+- KTD4. Add a categorical `blog` route/page family to `@caplets/web-observability`. Classifying `/blog` as `other` would weaken the public-site intent loop; capturing raw slugs would violate the existing privacy model.
+- KTD5. Ship one polished launch post before broader content infrastructure. The first post proves the publishing path and supports the awareness campaign; larger editorial features are deferred until content volume justifies them.
+
+### High-Level Technical Design
+
+```mermaid
+flowchart TB
+  Content[apps/landing/src/content/blog/*.md] --> Config[apps/landing/src/content.config.ts]
+  Config --> Index[apps/landing/src/pages/blog/index.astro]
+  Config --> Post[apps/landing/src/pages/blog/[slug].astro]
+  Layout[apps/landing/src/layouts/LandingLayout.astro] --> Index
+  Layout --> Post
+  Nav[Header and Footer links] --> Index
+  Obs[packages/web-observability blog categories] --> LandingObs[apps/landing/src/scripts/observability.ts]
+  LandingObs --> Index
+  LandingObs --> Post
+```
+
+The static content collection feeds both the index and post routes.
+The shared layout supplies canonical and social metadata, while the observability package constrains blog measurements to categorical values.
+
+### Assumptions
+
+- The canonical domain for generated links is `https://caplets.dev` unless the existing deployment configuration exposes a more specific public origin during implementation.
+- The initial share image can reuse an existing landing icon or generic social fallback; bespoke per-post OG images are deferred.
+- The launch essay can be written directly in repo content during implementation from the approved marketing plan and benchmark docs.
+- Blog install-copy attribution should stay under the existing `landing_install` category for now.
+
+### Sources and Research
+
+- `STRATEGY.md` frames public proof, docs, and reproducible benchmark confidence as an active strategic track.
+- `apps/landing/src/pages/index.astro`, `apps/landing/src/layouts/LandingLayout.astro`, and `apps/landing/src/components/landing/*` show the current one-page landing composition and visual conventions.
+- `apps/docs/src/content.config.ts` shows this repo already uses Astro content configuration in the docs app.
+- `packages/web-observability/src/events.ts` and `packages/web-observability/src/privacy.ts` define the current categorical telemetry contract.
+- Astro documentation research confirmed the current static blog pattern: collection content, `getCollection('blog')`, `getStaticPaths()`, and dynamic post routes.
+- `docs/plans/2026-07-01-002-marketing-developer-awareness-plan.md` supplies the campaign direction and first-post topic.
+
+---
+
+## Implementation Units
+
+### U1. Define blog content collection and launch post
+
+- **Goal:** Create the repo-owned static content source for landing blog posts and add the initial launch essay content.
+- **Requirements:** R1, R2, R4, R5, R10, AE1, AE2, AE5
+- **Dependencies:** None
+- **Files:**
+  - `apps/landing/src/content.config.ts`
+  - `apps/landing/src/content/blog/why-giant-mcp-tool-walls-dont-scale.md`
+  - `apps/landing/test/blog-content.test.ts`
+- **Approach:** Define a `blog` content collection with required frontmatter for title, description, date, draft/publication state if needed, tags/category, canonical slug, and optional share metadata. Write the first post from the developer-awareness plan and benchmark docs, including benchmark limitations and reproduction links rather than only headline claims.
+- **Patterns to follow:** Mirror the repo's existing Astro content configuration shape in `apps/docs/src/content.config.ts`; keep marketing claims aligned with `docs/benchmarks/coding-agent.md` and `STRATEGY.md`.
+- **Test scenarios:**
+  - Covers AE5. A post without required title, description, date, or slug metadata fails content validation during typecheck/build.
+  - The launch post source includes the deterministic benchmark numbers, caveat language that the benchmark is deterministic, and a reproduction reference to `pnpm benchmark` or the benchmark document.
+  - The launch post frontmatter slug matches the intended canonical URL segment.
+- **Verification:** The content collection is typed, the launch essay is present as the first non-draft post, and malformed required metadata cannot pass the landing app checks.
+
+### U2. Add blog index and post routes
+
+- **Goal:** Render `/blog` and `/blog/<slug>/` from the static blog collection.
+- **Requirements:** R1, R2, R7, R8, AE1, AE2
+- **Dependencies:** U1
+- **Files:**
+  - `apps/landing/src/pages/blog/index.astro`
+  - `apps/landing/src/pages/blog/[slug].astro`
+  - `apps/landing/src/lib/blog.ts`
+  - `apps/landing/test/blog-routes.test.ts`
+- **Approach:** Add a small blog helper for sorting public posts newest-first and resolving post URLs. The index should render public posts as cards with date, title, description, tags/category, and link. The dynamic route should use static path generation from collection entries and render article content through Astro’s content rendering API.
+- **Patterns to follow:** Follow the landing page's `w-[min(1180px,calc(100vw_-_32px))]` container rhythm and existing card/button components where useful.
+- **Test scenarios:**
+  - Covers AE1. The blog index source or rendered build includes the launch post title, description, date, and `/blog/why-giant-mcp-tool-walls-dont-scale/` link.
+  - Covers AE2. The post route is generated by the static build and renders the launch essay body rather than only metadata.
+  - Draft or future-hidden posts are excluded from the index and static paths if the schema includes such a state.
+  - Unknown slugs rely on Astro’s static routing behavior and do not create a catch-all route.
+- **Verification:** Static build output contains `/blog/index.html` and the launch post route, with no runtime server dependency.
+
+### U3. Extend layout metadata and article presentation
+
+- **Goal:** Give blog index and post pages first-class SEO/share metadata and readable long-form presentation.
+- **Requirements:** R8, R9, R10, AE2, AE3
+- **Dependencies:** U1, U2
+- **Files:**
+  - `apps/landing/src/layouts/LandingLayout.astro`
+  - `apps/landing/src/components/landing/BlogArticle.astro`
+  - `apps/landing/src/components/landing/BlogCta.astro`
+  - `apps/landing/src/styles/global.css`
+  - `apps/landing/test/blog-metadata.test.ts`
+- **Approach:** Extend `LandingLayout` with optional canonical URL, Open Graph title/description/type/image, and article date props. Add a blog article component or section classes that make Markdown content readable without diluting the landing aesthetic. Include a reusable CTA block for install/setup, docs, catalog, GitHub, npm, and benchmark reproduction.
+- **Patterns to follow:** Reuse `Button`, `Card`, and current muted/foreground/accent token patterns; preserve `skip-link`, header/footer slots, and mobile responsiveness.
+- **Test scenarios:**
+  - Covers AE3. The launch post output includes post-specific `<title>`, meta description, canonical link, `og:title`, `og:description`, `og:url`, and `og:type` values.
+  - Covers AE2. Article layout keeps one primary `<h1>`, visible publication date, and content width suitable for long-form reading.
+  - CTA links point to install/docs/catalog/GitHub/npm/benchmark targets without broken relative URLs.
+  - Default layout metadata remains valid for the home page when blog-specific props are absent.
+- **Verification:** Home page metadata remains unchanged except for intentional layout enhancements, and blog pages produce shareable metadata from post frontmatter.
+
+### U4. Add blog navigation and conversion paths
+
+- **Goal:** Make the blog discoverable from the landing site without disrupting the current single-page conversion flow.
+- **Requirements:** R1, R3, R7, R9, AE1, AE2
+- **Dependencies:** U2, U3
+- **Files:**
+  - `apps/landing/src/components/landing/Header.astro`
+  - `apps/landing/src/components/landing/Footer.astro`
+  - `apps/landing/src/components/landing/Hero.astro`
+  - `apps/landing/test/blog-navigation.test.ts`
+- **Approach:** Add a `/blog` link to desktop and mobile navigation plus footer. Consider one lightweight home-page link from the benchmark/proof area or hero secondary action only if it does not crowd the existing install/docs/catalog actions.
+- **Patterns to follow:** Match existing header link classes, mobile sheet behavior, footer link style, and external-link icon conventions only for off-site links.
+- **Test scenarios:**
+  - The desktop header, mobile sheet, and footer contain a first-party `/blog` link.
+  - `/blog` links do not use `target="_blank"` or external-link icons.
+  - Existing catalog, docs, GitHub, npm, and hash-section links remain present.
+  - If a home-page proof link is added, it points to the launch post or blog index and does not replace benchmark reproduction links.
+- **Verification:** Visitors can navigate from home to blog and back, while existing landing section navigation still works.
+
+### U5. Preserve privacy-safe observability for blog traffic
+
+- **Goal:** Classify blog pageviews and blog CTAs categorically without raw post slugs or URLs.
+- **Requirements:** R11, R12, AE4
+- **Dependencies:** U2, U4
+- **Files:**
+  - `packages/web-observability/src/events.ts`
+  - `packages/web-observability/src/privacy.ts`
+  - `packages/web-observability/test/web-observability.test.ts`
+  - `apps/landing/src/scripts/observability.ts`
+  - `apps/landing/test/observability.test.ts`
+- **Approach:** Add `blog` as an allowed route/page family and navigation/CTA category where needed. Classify `/blog` and `/blog/<slug>` as `blog`, but never pass the actual slug into event properties. Keep install copy attribution under the existing landing surface unless a later product decision adds a separate blog marker.
+- **Patterns to follow:** Follow the categorical allowlist design in `packages/web-observability/src/privacy.ts` and existing route tests in `packages/web-observability/test/web-observability.test.ts`.
+- **Test scenarios:**
+  - Covers AE4. `classifyRouteFamily('/blog')` and `classifyRouteFamily('/blog/why-giant-mcp-tool-walls-dont-scale')` return `blog` without preserving slug values.
+  - Blog links in landing observability produce categorical blog navigation/CTA values.
+  - Unsafe raw URLs and unknown telemetry properties remain rejected after adding blog categories.
+  - Blog install-copy CTAs still emit `landing_install` attribution and do not introduce a raw article identifier.
+- **Verification:** Blog observability enriches public-site intent with categorical data while preserving the Anonymous Telemetry and Anonymous Install Attribution constraints in `CONCEPTS.md`.
+
+---
+
+## Verification Contract
+
+| Gate                                                 | Scope                                        | Done signal                                                                   |
+| ---------------------------------------------------- | -------------------------------------------- | ----------------------------------------------------------------------------- |
+| `pnpm --filter @caplets/landing test`                | U1-U4 and landing observability pieces of U5 | New and existing landing tests pass.                                          |
+| `pnpm --filter @caplets/landing typecheck`           | U1-U4                                        | Astro content collection, routes, and layout props typecheck.                 |
+| `pnpm --filter @caplets/landing build`               | U1-U4                                        | Static `/blog` and launch-post pages build successfully.                      |
+| `pnpm --filter @caplets/web-observability test`      | U5                                           | Shared route/privacy contract accepts `blog` and still rejects unsafe values. |
+| `pnpm --filter @caplets/web-observability typecheck` | U5                                           | Shared observability type changes compile.                                    |
+| `pnpm format:check`                                  | All units                                    | New Markdown, Astro, CSS, and TypeScript files match repo formatting.         |
+| `pnpm lint`                                          | All units                                    | No lint regressions from route, component, or telemetry changes.              |
+
+---
+
+## Definition of Done
+
+- `/blog` and `/blog/why-giant-mcp-tool-walls-dont-scale/` are generated by the landing build.
+- The launch post is the canonical source for the tool-wall essay and includes benchmark evidence, limitations, reproduction path, and conversion CTAs.
+- Home, header, mobile menu, and footer navigation still work and expose the blog intentionally.
+- Blog metadata is post-specific and suitable for social sharing.
+- Observability classifies blog traffic categorically and does not preserve raw slugs, URLs, identities, or hidden identifiers.
+- All Verification Contract gates pass.
+- Any abandoned prototype/CMS/RSS/OG-image experimentation is removed from the final diff.
diff --git a/packages/web-observability/src/events.ts b/packages/web-observability/src/events.ts
index d64ff248..dca23953 100644
--- a/packages/web-observability/src/events.ts
+++ b/packages/web-observability/src/events.ts
@@ -6,7 +6,14 @@ export type WebEventName =
   | "caplets_site_intent"
   | "caplets_catalog_search"
   | "caplets_install_intent";
-export type RouteFamily = "home" | "docs" | "catalog" | "catalog_detail" | "privacy" | "other";
+export type RouteFamily =
+  | "home"
+  | "docs"
+  | "catalog"
+  | "catalog_detail"
+  | "privacy"
+  | "blog"
+  | "other";
 export type ReferrerCategory = "direct" | "search" | "social" | "docs" | "catalog" | "external";
 export type ScrollDepthBucket = "lt_25" | "lt_50" | "lt_75" | "gte_75";
 export type SearchLengthBucket = "empty" | "short" | "medium" | "long";
@@ -17,10 +24,18 @@ export type WebEventPropertySet = Partial<{
   route_family: RouteFamily;
   page_family: RouteFamily;
   referrer_category: ReferrerCategory;
-  section_category: "hero" | "install" | "docs" | "catalog" | "search" | "footer" | "unknown";
-  navigation_path_category: "docs" | "catalog" | "home" | "external" | "unknown";
-  outbound_action_category: "github" | "npm" | "docs" | "catalog" | "unknown";
-  cta_category: "primary" | "secondary" | "install" | "docs" | "catalog" | "unknown";
+  section_category:
+    | "hero"
+    | "install"
+    | "docs"
+    | "catalog"
+    | "blog"
+    | "search"
+    | "footer"
+    | "unknown";
+  navigation_path_category: "docs" | "catalog" | "blog" | "home" | "external" | "unknown";
+  outbound_action_category: "github" | "npm" | "docs" | "catalog" | "blog" | "unknown";
+  cta_category: "primary" | "secondary" | "install" | "docs" | "catalog" | "blog" | "unknown";
   install_intent_category: "copy" | "run_marker" | "unknown";
   search_length_bucket: SearchLengthBucket;
   filter_category: "auth" | "source" | "tag" | "clear" | "unknown";
@@ -168,6 +183,7 @@ export function classifyRouteFamily(pathname: string): RouteFamily {
   if (pathname === "/" || pathname === "") return "home";
   if (pathname.startsWith("/docs/privacy")) return "privacy";
   if (pathname.startsWith("/docs")) return "docs";
+  if (pathname === "/blog" || pathname.startsWith("/blog/")) return "blog";
   if (pathname.startsWith("/caplets/")) return "catalog_detail";
   if (pathname.startsWith("/catalog") || pathname === "/caplets") return "catalog";
   return "other";
diff --git a/packages/web-observability/src/privacy.ts b/packages/web-observability/src/privacy.ts
index bc77143c..1ca1c9a3 100644
--- a/packages/web-observability/src/privacy.ts
+++ b/packages/web-observability/src/privacy.ts
@@ -21,13 +21,22 @@ const ALLOWED_WEB_KEYS = new Set([
 
 const VALUE_ALLOWLISTS: Record<string, ReadonlySet<string>> = {
   surface: new Set(["landing", "docs", "catalog"]),
-  route_family: new Set(["home", "docs", "catalog", "catalog_detail", "privacy", "other"]),
-  page_family: new Set(["home", "docs", "catalog", "catalog_detail", "privacy", "other"]),
+  route_family: new Set(["home", "docs", "catalog", "catalog_detail", "privacy", "blog", "other"]),
+  page_family: new Set(["home", "docs", "catalog", "catalog_detail", "privacy", "blog", "other"]),
   referrer_category: new Set(["direct", "search", "social", "docs", "catalog", "external"]),
-  section_category: new Set(["hero", "install", "docs", "catalog", "search", "footer", "unknown"]),
-  navigation_path_category: new Set(["docs", "catalog", "home", "external", "unknown"]),
-  outbound_action_category: new Set(["github", "npm", "docs", "catalog", "unknown"]),
-  cta_category: new Set(["primary", "secondary", "install", "docs", "catalog", "unknown"]),
+  section_category: new Set([
+    "hero",
+    "install",
+    "docs",
+    "catalog",
+    "blog",
+    "search",
+    "footer",
+    "unknown",
+  ]),
+  navigation_path_category: new Set(["docs", "catalog", "blog", "home", "external", "unknown"]),
+  outbound_action_category: new Set(["github", "npm", "docs", "catalog", "blog", "unknown"]),
+  cta_category: new Set(["primary", "secondary", "install", "docs", "catalog", "blog", "unknown"]),
   install_intent_category: new Set(["copy", "run_marker", "unknown"]),
   search_length_bucket: new Set(["empty", "short", "medium", "long"]),
   filter_category: new Set(["auth", "source", "tag", "clear", "unknown"]),
diff --git a/packages/web-observability/test/web-observability.test.ts b/packages/web-observability/test/web-observability.test.ts
index 9ed6b352..c7b35243 100644
--- a/packages/web-observability/test/web-observability.test.ts
+++ b/packages/web-observability/test/web-observability.test.ts
@@ -39,6 +39,31 @@ describe("web observability contract", () => {
         empty_state_category: "unknown",
       },
     });
+    expect(
+      buildWebEvent({
+        name: "caplets_site_intent",
+        properties: {
+          surface: "landing",
+          route_family: "blog",
+          page_family: "blog",
+          section_category: "blog",
+          navigation_path_category: "blog",
+          outbound_action_category: "blog",
+          cta_category: "blog",
+        } as never,
+      }),
+    ).toEqual({
+      name: "caplets_site_intent",
+      properties: {
+        surface: "landing",
+        route_family: "blog",
+        page_family: "blog",
+        section_category: "blog",
+        navigation_path_category: "blog",
+        outbound_action_category: "blog",
+        cta_category: "blog",
+      },
+    });
   });
 
   it("rejects event-specific property mixes at the shared boundary", () => {
@@ -89,6 +114,8 @@ describe("web observability contract", () => {
   it("classifies routes without preserving raw URLs", () => {
     expect(classifyRouteFamily("/")).toBe("home");
     expect(classifyRouteFamily("/docs/privacy/indexing")).toBe("privacy");
+    expect(classifyRouteFamily("/blog")).toBe("blog");
+    expect(classifyRouteFamily("/blog/why-giant-mcp-tool-walls-dont-scale")).toBe("blog");
     expect(classifyRouteFamily("/caplets/google-docs")).toBe("catalog_detail");
   });