diff --git a/CONTEXT.md b/CONTEXT.md
index fb3c0dc..79eb0ae 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -37,6 +37,31 @@ The repository-root `docs/` directory: skill configuration and this
 repository's ADRs. Unrelated to the Mirror despite the shared word.
 _Avoid_: docs (unqualified), the docs folder
 
+## The product
+
+The three terms this repository does not own but has to speak, because a word
+that means one thing in the Guide and another on the Landing is how a site
+starts contradicting itself. All three are authoritative in the Guide, under
+`deployment-shapes`.
+
+**Shape**:
+Which of the two forms an Argus installation is running in, derived from one
+fact: whether an LLM provider is configured. Never picked by a setting, so the
+Landing describes Shapes rather than offering a choice between them.
+_Avoid_: mode, tier, plan, edition
+
+**Toolbox**:
+The Shape with no provider configured. Argus serves its scanners, the
+organization's knowledge, its memory and its skills, and the reader's own AI
+tool does the reasoning. The floor, and never a trial or a crippled mode.
+_Avoid_: agentless, tooling mode, free tier, MCP-only
+
+**Colleague**:
+The Shape with a provider configured. Everything a Toolbox serves, plus Argus
+reasoning on its own behalf. A storey above a Toolbox, never a different
+building.
+_Avoid_: agentic mode, full version, pro
+
 ## The landing
 
 **Landing**:
diff --git a/docs/adr/0012-the-landing-speaks-the-guides-shape-vocabulary.md b/docs/adr/0012-the-landing-speaks-the-guides-shape-vocabulary.md
new file mode 100644
index 0000000..2c0d774
--- /dev/null
+++ b/docs/adr/0012-the-landing-speaks-the-guides-shape-vocabulary.md
@@ -0,0 +1,16 @@
+# The Landing speaks the Guide's shape vocabulary, and never says agentless
+
+The Guide names two deployment shapes — **Toolbox** with no LLM provider
+configured, **Colleague** with one — and derives the shape from that single fact
+rather than from a setting. The Landing adopts both words unchanged instead of
+inventing its own, because this repository publishes prose it does not author,
+and a term that means one thing upstream and another on the home page is how a
+site starts contradicting itself. It already had: the third story beat closed on
+"A colleague, not a toolbox" while Toolbox was a shipped shape.
+
+*Agentless* was the tempting word for what a Toolbox is, and it is refused. In
+application security the word is already taken and means "nothing installed on
+the host" — and a Toolbox is a daemon running on the machine the code is on,
+scanning that host's own filesystem. To the readers most likely to know the term
+it would be a claim about topology, and a false one. What it was reaching for is
+a sentence the Guide already has: *your agent does the reasoning*.
diff --git a/docs/adr/0013-the-landing-ascends-and-the-hero-does-not.md b/docs/adr/0013-the-landing-ascends-and-the-hero-does-not.md
new file mode 100644
index 0000000..4b6c6dd
--- /dev/null
+++ b/docs/adr/0013-the-landing-ascends-and-the-hero-does-not.md
@@ -0,0 +1,20 @@
+# The Landing ascends from Toolbox to Colleague, and the hero does not
+
+The middle of the page climbs. It starts where a reader can start today — a
+Toolbox their own AI tool drives, with no model to pay for — and then adds the
+model that makes Argus a Colleague. Two reasons: it is the product's own shape,
+since a Colleague is a storey above a Toolbox rather than a different building;
+and the page previously had no ascent at all, opening at its maximum with Argus
+arguing back and then descending into configuration. Trust closes the page for
+the same reason, so the boundaries land after the climb instead of interrupting
+it.
+
+The hero deliberately does not carry the Toolbox pitch, and stays the thesis. A
+reader at the top has not yet learned that Argus uses a model, so "no model
+required" up there answers an objection nobody has raised, and reads as
+defensive. Worse, an opening that sells the tool the reader drives sells the
+product below its own ceiling: the first thing a stranger would learn is a
+protocol and a subordinate role. The zero-cost first step is the strongest
+acquisition argument we have, and it is not lost by this — it lands thirty
+seconds in, in the first section of the climb, and in the meta description that
+link previews show.
diff --git a/src/landing/bands.test.ts b/src/landing/bands.test.ts
new file mode 100644
index 0000000..ecc13a5
--- /dev/null
+++ b/src/landing/bands.test.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+
+import { raisedIn } from './bands';
+
+/**
+ * The alternation is the page's rhythm, and a broken rhythm is the kind of
+ * failure nobody notices in review: two raised sections in a row read as one
+ * long section, and the reader loses the boundary the design was using to say
+ * "new argument". Nothing turns red, and the page looks almost right.
+ */
+describe('the raised band', () => {
+  const isRaised = raisedIn(['hero', 'one', 'two', 'three', 'four', 'five']);
+
+  it('leaves the hero on the ground', () => {
+    // It closes with a rule instead of a change of band, so raising it would
+    // give it two endings.
+    expect(isRaised('hero')).toBe(false);
+  });
+
+  it('leaves the section under the hero on the ground too', () => {
+    // The hero's own rule is the boundary there; a band as well would draw the
+    // same line twice.
+    expect(isRaised('one')).toBe(false);
+  });
+
+  it('alternates from the second section down', () => {
+    expect(['two', 'three', 'four', 'five'].map(isRaised)).toEqual([true, false, true, false]);
+  });
+
+  it('holds the alternation whatever the section is called', () => {
+    // The rule is positional. A section renamed keeps its band, which is what
+    // lets the page be reordered by moving markup rather than by re-deciding
+    // every band by hand.
+    expect(['hero', 'a', 'b'].map(raisedIn(['hero', 'a', 'b']))).toEqual([false, false, true]);
+  });
+
+  it('refuses a section the page never declared', () => {
+    // Which is what makes this a build failure rather than a silent one: a
+    // typo in a section's id, or a section added to the markup and not to the
+    // order, stops the page being rendered at all.
+    expect(() => isRaised('your-editor')).toThrow(/your-editor/);
+  });
+
+  it('refuses an order that names a section twice', () => {
+    // Two sections sharing an id would each ask the same question and get the
+    // same answer, so one of them lands on the wrong band. A duplicate is a
+    // mistake in the page, not an input to interpret.
+    expect(() => raisedIn(['hero', 'one', 'one'])).toThrow(/one/);
+  });
+});
diff --git a/src/landing/bands.ts b/src/landing/bands.ts
new file mode 100644
index 0000000..ad34085
--- /dev/null
+++ b/src/landing/bands.ts
@@ -0,0 +1,47 @@
+/**
+ * Which of the Landing's sections stand on the raised band.
+ *
+ * The page alternates: `bg`, then `surface`, then `bg` again, so each section
+ * announces itself as a new argument without needing a heading rule. That is a
+ * property of the *sequence*, not of any section, and it used to be decided
+ * section by section in the markup — which works right up until the page is
+ * reordered, and then it silently doesn't. Two raised sections in a row read as
+ * one long section and the boundary the design was drawing disappears.
+ *
+ * So the page declares its order once, at the top, and every section asks. A
+ * section moved keeps the band of its new position rather than the band it was
+ * written with, which is what makes reordering the Landing an edit to markup
+ * instead of a re-decision about every band on the page.
+ *
+ * The first two sections are both on the ground. The hero is the first, and it
+ * closes with a rule rather than with a change of band — raising the section
+ * under it would draw that same boundary twice.
+ *
+ * Asking about a section the order does not name throws, so a typo or a section
+ * added to the markup and not to the order fails the build. The alternative is
+ * the failure this exists to prevent, arriving silently by another door.
+ */
+export function raisedIn(order: readonly string[]): (id: string) => boolean {
+  const raised = new Map<string, boolean>();
+
+  order.forEach((id, index) => {
+    if (raised.has(id)) {
+      throw new Error(
+        `the Landing names the section \`${id}\` twice — two sections sharing an id cannot sit on different bands`,
+      );
+    }
+
+    raised.set(id, index >= 2 && index % 2 === 0);
+  });
+
+  return (id) => {
+    const band = raised.get(id);
+    if (band === undefined) {
+      throw new Error(
+        `the Landing renders a section \`${id}\` its order never names — add it to the order, in the place it is rendered`,
+      );
+    }
+
+    return band;
+  };
+}
diff --git a/src/landing/landing.test.ts b/src/landing/landing.test.ts
index 28f7941..cde44b1 100644
--- a/src/landing/landing.test.ts
+++ b/src/landing/landing.test.ts
@@ -136,8 +136,103 @@ describe('the Landing', () => {
       expect(value, `${property}: ${value}`).toMatch(/var\(--color-/);
     }
   });
+
+  it('uses none of the words the glossary refuses for the product\'s own terms', () => {
+    // The Landing has to speak Toolbox and Colleague, and it does not own them:
+    // they are the Guide's words. `CONTEXT.md` is where that is written down,
+    // including the words each one is *not* — so the list is read out of the
+    // glossary rather than copied here, and adding a trap there arms this test
+    // with no edit. ADR 0012 is the one that matters: `agentless` already means
+    // "nothing installed on the host" to this page's audience, and a Toolbox is
+    // a daemon on the machine the code is on.
+    const refused = glossaryAvoids('The product');
+
+    expect(refused, 'no `_Avoid_` under `## The product` — has the glossary moved?').not.toHaveLength(
+      0,
+    );
+
+    for (const word of refused) {
+      const used = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
+      expect(copy(), `the glossary refuses \`${word}\``).not.toMatch(used);
+    }
+  });
+
+  it('names both shapes the Guide names', () => {
+    // The other half of the same rule, and the half that goes wrong quietly.
+    // ADR 0012 adopts Toolbox and Colleague *because* this page has to speak
+    // them, and a page that refuses `agentless` while never saying `colleague`
+    // has kept the letter of that and dropped the point. The word only ever
+    // reached the page inside one claim, so deleting the claim deleted the
+    // vocabulary — which is what happened, and what this now catches.
+    for (const shape of ['toolbox', 'colleague']) {
+      expect(copy(), `ADR 0012 adopts \`${shape}\`, and the page never says it`).toMatch(
+        new RegExp(`\\b${shape}\\b`, 'i'),
+      );
+    }
+  });
+
+  it('writes no snake_case name anywhere in its copy', () => {
+    // The Inventory rule, over the one class of name that always breaks it. An
+    // MCP tool, a config key and an environment variable are all snake_case,
+    // and all three are enumerations Argus changes without telling this
+    // repository — the tool surface gained the scanners the week this page was
+    // last rewritten. So the page describes what happened in verbs and names
+    // none of them; a link goes to the Guide, which owns the list.
+    expect(copy()).not.toMatch(/\b[a-z][a-z0-9]*_[a-z0-9_]+\b/);
+  });
+
+  it('renders every section its declared order names', () => {
+    // `bandOf` fails the build on a section the order does not name. This is
+    // the other direction, which nothing at build time can see: an id left in
+    // the order after its section went shifts the band of every section under
+    // it, and the page still renders.
+    const declaration = /const ORDER = \[([\s\S]*?)\] as const;/.exec(SOURCE);
+
+    expect(declaration, 'the Landing declares no section order').not.toBeNull();
+
+    const declared = [...declaration![1]!.matchAll(/'([^']+)'/g)].map(([, id]) => id!);
+    // Everything past the declaration, and never the declaration itself: the
+    // ids are written there, so a search that included it would find each one
+    // in its own definition and pass whatever the page renders.
+    const rest = SOURCE.slice(declaration!.index + declaration![0].length);
+
+    expect(declared, 'the Landing declares an empty section order').not.toHaveLength(0);
+
+    for (const id of declared) {
+      expect(rest, `\`${id}\` is declared and never rendered`).toContain(id);
+    }
+  });
 });
 
+/**
+ * Everything on the page that can carry a word the reader sees: its markup and
+ * the frontmatter its copy is declared in, with the stylesheet and the comments
+ * taken out. A comment explaining why a word is refused must not itself read as
+ * the page using that word — the same reason `stylesheet()` below blanks them.
+ *
+ * Not prose, and deliberately not: most of the copy is declared in TypeScript, so
+ * anything narrower than this would police the half of the page that happens to
+ * be markup and leave the half that is data alone.
+ */
+function copy(): string {
+  return SOURCE.replace(/<style>[\s\S]*?<\/style>/g, ' ')
+    .replace(/\/\*[\s\S]*?\*\//g, ' ')
+    .replace(/^[ \t]*\/\/.*$/gm, ' ');
+}
+
+/** The `_Avoid_` words under one heading of the glossary, in the order written. */
+function glossaryAvoids(heading: string): string[] {
+  const context = readFileSync(join(REPO_ROOT, 'CONTEXT.md'), 'utf8');
+  const section = new RegExp(`^## ${heading}$([\\s\\S]*?)(?=^## |\\Z)`, 'm').exec(context)?.[1];
+
+  expect(section, `CONTEXT.md has no \`## ${heading}\``).toBeDefined();
+
+  return [...section!.matchAll(/^_Avoid_:(.*)$/gm)]
+    .flatMap(([, list]) => list!.split(','))
+    .map((word) => word.trim())
+    .filter((word) => word !== '');
+}
+
 /** The Landing's stylesheet with its comments blanked, so the prose explaining
  *  why gold fills in light is never mistaken for a colour value. */
 function stylesheet(): string {
diff --git a/src/pages/index.astro b/src/pages/index.astro
index d6e2311..d4b0d3c 100644
--- a/src/pages/index.astro
+++ b/src/pages/index.astro
@@ -4,6 +4,16 @@
  * make the Argument — scanners are precise but shallow, a model alone drowns the
  * signal, and the organization is the missing third ingredient — and hand off.
  *
+ * The middle of the page climbs, which is what ADR 0013 argues for: it starts
+ * where a reader can start today, with Argus serving its scanners and what the
+ * organization knows to the AI tool they already pay for, and then adds the model
+ * that makes it a Colleague. The hero deliberately does not carry that first
+ * step — a reader at the top has not yet learned that Argus uses a model, so
+ * "no model required" up there answers an objection nobody has raised.
+ *
+ * Toolbox and Colleague are the Guide's words, adopted rather than invented, and
+ * `agentless` is refused however well it would have fitted. ADR 0012 has both.
+ *
  * It restates the Argument in its own words, because an argument does not go
  * stale. It restates no Inventory: the scanners, the built-in skills, the
  * channels and the quick-start commands are all things that change as Argus
@@ -31,6 +41,7 @@ import { getCollection } from 'astro:content';
 import Mark from '../assets/brand/argus.svg';
 import GitHubMark from '../components/GitHubMark.astro';
 import VendorLogo from '../components/VendorLogo.astro';
+import { raisedIn } from '../landing/bands';
 import { GUIDE_ROOT, guideHandoff } from '../landing/handoff';
 import { CLIENT_MARKS, PROVIDER_MARKS } from '../landing/vendor-marks';
 import '../styles/global.css';
@@ -46,9 +57,38 @@ const REPOSITORY = 'https://github.com/argusappsec/argus';
 const SECURITY_CONTACT = 'security@argusappsec.com';
 
 const TITLE = 'Argus — an application security agent that knows your organization';
+/**
+ * The line a search result and a shared link show, which for a stranger is often
+ * the only line they read. So it carries the thesis and the first step, and stops
+ * there: past about 160 characters it is truncated, and a truncated argument is
+ * an argument the reader never sees the end of.
+ */
 const DESCRIPTION =
-  'Argus is an open-source application security agent. It reviews your code ' +
-  'against your own stack, risk tolerance and exceptions, and answers when you disagree.';
+  'An open-source application security agent that knows your organization. ' +
+  'Point the AI you already pay for at it, or give it a model of its own.';
+
+/**
+ * The sections, in the order the page renders them. Written down once because
+ * the raised band alternates over the *sequence* rather than being chosen per
+ * section — see `src/landing/bands.ts` for why that is a rule and not a habit.
+ *
+ * Reordering the page is moving markup and moving an id here. Every section asks
+ * whether it is raised, and asking about a section this list does not name throws,
+ * so the two cannot drift apart without the build saying so.
+ */
+const ORDER = [
+  'hero',
+  'your-editor',
+  'your-team',
+  'your-ai',
+  'reviews',
+  'learns',
+  'answers',
+  'ask-argus',
+  'trust',
+] as const;
+
+const isRaised = raisedIn(ORDER);
 
 /**
  * The hero's thesis, as a conversation: the finding a scanner cannot reach,
@@ -203,7 +243,7 @@ const BEATS: readonly Beat[] = [
     eyebrow: 'The argument',
     title: 'Argue with it.',
     lede: 'A report is a list. This one answers, moves its own finding when you give it a reason, and says so when you are wrong.',
-    claim: 'A colleague, not a toolbox.',
+    claim: 'It answers. A report cannot.',
     code: ANCHOR,
     messages: [
       { ...CORRECTION, state: 'past' },
@@ -215,13 +255,54 @@ const BEATS: readonly Beat[] = [
 
 
 /**
- * What the page says about its own boundaries, which for a tool that reads a
- * stranger's pull request is the section a security reader actually opens.
+ * The floor's evidence: your own AI tool asking Argus, doing the deterministic
+ * half through it, and answering you itself. The one panel on the page that shows
+ * work rather than speech, which is the only honest way to draw a shape whose
+ * reasoning belongs to somebody else.
  *
- * All three are transcribed from the Guide's own security posture and go no
- * further: each is a promise the code has to keep, so none of them is a sentence
- * this page is free to improve on.
+ * The steps say what happened and name nothing. What Argus serves over MCP is an
+ * Inventory — the surface gained the scanners days before this was written — and
+ * a panel listing tool names is a panel that eventually lies. Verbs do not go
+ * stale, and `landing.test.ts` holds the page to it.
+ */
+/**
+ * A toolbox exchange: your question, and your own client's answer. Deliberately
+ * not a `Message[]` — on this shape the answering voice is always the client, so
+ * there is no choice left for a `from` field to record, and naming the two halves
+ * says more than indexing them would.
+ */
+interface Exchange {
+  readonly asked: string;
+  readonly answered: string;
+}
+
+const ORCHESTRATION = [
+  'ran the scanners over the checkout',
+  'read what your organization has settled before',
+  'read the context document it pointed to',
+];
+
+const ORCHESTRATED: Exchange = {
+  asked: 'anything here I should fix before I open the pull request?',
+  answered:
+    'One thing. A token is hardcoded in the migration script. The other two hits are in the vendored SDK, which your team accepted twice already.',
+};
+
+/**
+ * The same floor, asked by somebody else. Another client and another person, and
+ * the answer rests on something this person never told anybody: what the team
+ * settled once is what every later session starts from.
+ *
+ * A different mark in the panel's head is the whole of how the page says "not
+ * you this time", which is why the client here is deliberately not the one the
+ * floor's panel used.
  */
+const SHARED: Exchange = {
+  asked: 'do I need to fix these two SDK findings?',
+  answered:
+    'No. Somebody on your team accepted them two months ago, and Argus still has the reason they gave.',
+};
+
 /**
  * The other side of the same protocol: not Argus asking a model, but a tool
  * asking Argus. Which is why the reader is watching their own assistant here —
@@ -243,11 +324,19 @@ const CONSULT: readonly Message[] = [
   },
 ];
 
+/**
+ * What the page says about its own boundaries, which for a tool that reads a
+ * stranger's pull request is the section a security reader actually opens.
+ *
+ * All three are transcribed from the Guide's own security posture and go no
+ * further: each is a promise the code has to keep, so none of them is a sentence
+ * this page is free to improve on.
+ */
 const GUARDS = [
   {
-    title: 'A pull request cannot give orders.',
+    title: 'What it knows stays where it runs.',
     detail:
-      'The code under review is data. Nothing it contains directs the agent, and nothing it says is written back to what your organization knows.',
+      'Your identity, memory and context documents never leave your instance, and anything Argus posts in public has to be grounded in the tree it just read.',
   },
   {
     title: 'Scanners never leave the checkout.',
@@ -255,9 +344,9 @@ const GUARDS = [
       'Review tools read the tree they were pointed at, not the machine Argus runs on.',
   },
   {
-    title: 'What it knows stays where it runs.',
+    title: 'A pull request cannot give orders.',
     detail:
-      'Your identity, memory and context documents never leave your instance, and anything Argus posts in public has to be grounded in the tree it just read.',
+      'The code under review is data. Nothing it contains directs the agent, and nothing it says is written back to what your organization knows.',
   },
 ];
 
@@ -328,9 +417,10 @@ const canonical = new URL('/', Astro.site);
         </a>
 
         <nav class="nav" aria-label="Sections of this page">
+          <a href="#your-editor">Your editor</a>
+          <a href="#your-ai">Your AI</a>
           <a href="#reviews">How it works</a>
           <a href="#trust">Trust</a>
-          <a href="#your-ai">Your AI</a>
         </nav>
 
         <div class="topbar-end">
@@ -344,7 +434,7 @@ const canonical = new URL('/', Astro.site);
     </header>
 
     <main id="main">
-      <section class="section hero">
+      <section class:list={['section', 'hero', isRaised('hero') && 'section-raised']}>
         <span class="rings" aria-hidden="true"></span>
         <span class="sweep" aria-hidden="true"></span>
         <span class="blip blip-1" aria-hidden="true"></span>
@@ -403,10 +493,240 @@ const canonical = new URL('/', Astro.site);
           </div>
         </div>
       </section>
+      {
+        /* The floor, and the first step of the climb ADR 0013 argues for. Copy
+           left and panel right, which is the story's default shape: the section
+           under it turns around, and from there the sides alternate all the way
+           down the page.
+
+           It opens from the knowledge and not from the tools on purpose: three
+           scanners are an afternoon's work for anybody, and a section that leads
+           with them reads as a wrapper around somebody else's binaries. What
+           cannot be improvised is the memory. */
+      }
+      <section
+        class:list={['section', 'story', isRaised('your-editor') && 'section-raised']}
+        id="your-editor"
+        aria-labelledby="your-editor-heading"
+      >
+        <div class="shell story-inner">
+          <div class="story-copy">
+            <p class="eyebrow reveal">Your editor</p>
+            <h2 class="heading reveal" id="your-editor-heading">
+              Your AI doesn't know your organization.
+            </h2>
+
+            <div class="prose reveal">
+              <p>
+                It knows the language. It does not know which findings your team already accepted,
+                or what this service's payloads may carry.
+              </p>
+              <p>
+                Argus knows both, and runs real scanners rather than guessing. With no model
+                configured, that is the whole of it: a toolbox.
+              </p>
+              <p class="claim">Your agent does the reasoning.</p>
+            </div>
+
+            <ul class="pills reveal">
+              {
+                CLIENT_MARKS.map((mark) => (
+                  <li class="pill">
+                    <VendorLogo mark={mark} size={16} />
+                    {mark.title}
+                  </li>
+                ))
+              }
+              <li class="pill pill-open">anything that speaks MCP</li>
+            </ul>
+
+            <div class="prose reveal pills-note">
+              <p class="footnote">
+                Examples of clients, not a supported list. The protocol is the contract, and Argus
+                certifies nobody's client.
+              </p>
+              <p><a href="/guide/deployment-shapes/">The two shapes, and which one you run</a></p>
+            </div>
+          </div>
+
+          {
+            /* The evidence, and the one thing on the page that shows work rather
+               than speech: your own client asking, Argus doing the deterministic
+               half, and the answer coming back in your client's own voice. The
+               steps say what happened and name nothing — see `ORCHESTRATION`. */
+          }
+          <div class="panel reveal">
+            <p class="panel-head">
+              <span class="panel-mark" aria-hidden="true">
+                <VendorLogo mark={CLIENT_MARKS[0]!} size={13} />
+              </span>
+              <span class="panel-repo">{CLIENT_MARKS[0]!.title}</span>
+              <span class="chip chip-sm panel-protocol">mcp</span>
+            </p>
+
+            <ol class="thread">
+              <li class="message message-now" style="--at: 20%">
+                <p class="message-who">you</p>
+                <p class="message-says">{ORCHESTRATED.asked}</p>
+              </li>
+
+              {
+                ORCHESTRATION.map((step, index) => (
+                  <li class="step" style={`--at: ${34 + index * 7}%`}>
+                    {step}
+                  </li>
+                ))
+              }
+
+              <li class="message message-now" style="--at: 60%">
+                <p class="message-who">
+                  <span class="message-mark" aria-hidden="true">
+                    <VendorLogo mark={CLIENT_MARKS[0]!} size={14} />
+                  </span>
+                  {CLIENT_MARKS[0]!.title}
+                </p>
+                <p class="message-says">{ORCHESTRATED.answered}</p>
+              </li>
+            </ol>
+          </div>
+        </div>
+      </section>
 
       {
-        /* Every other beat turns around and stands on the raised band, so the
-           page alternates without any beat having to know where it sits. */
+        /* The other half of the floor, and the reason a team installs a daemon
+           instead of writing three integrations: one place to teach. Panel left,
+           turning around against the section above it.
+
+           Its evidence is the same window again with a different mark on it, and
+           an answer nobody in this conversation supplied. Which is the argument:
+           the reasoning is each person's own, and the knowledge is not. */
+      }
+      <section
+        class:list={['section', 'story', 'story-flip', isRaised('your-team') && 'section-raised']}
+        id="your-team"
+        aria-labelledby="your-team-heading"
+      >
+        <div class="shell story-inner">
+          <div class="story-copy">
+            <p class="eyebrow reveal">Your team</p>
+            <h2 class="heading reveal" id="your-team-heading">One Argus. Everyone's own AI.</h2>
+
+            <div class="prose reveal">
+              <p>
+                Point every developer's agent at one instance. The knowledge and the memory are
+                shared, so what one person settles is settled for the next session, the next
+                repository and the next person.
+              </p>
+              <p>
+                The reasoning is not shared, and does not need to be. It happens on each machine,
+                under each person's own name, paid for by the subscription they already have.
+              </p>
+              <p class="claim">You are already paying for the reasoning.</p>
+              <p class="footnote">
+                What is shared is what Argus knows. Scanning stays close to the code, on the host
+                Argus itself runs on, which is what decides where an instance belongs.
+              </p>
+            </div>
+          </div>
+
+          <div class="panel reveal">
+            <p class="panel-head">
+              <span class="panel-mark" aria-hidden="true">
+                <VendorLogo mark={CLIENT_MARKS[2]!} size={13} />
+              </span>
+              <span class="panel-repo">{CLIENT_MARKS[2]!.title}</span>
+              <span class="chip chip-sm panel-protocol">mcp</span>
+            </p>
+
+            <ol class="thread">
+              <li class="message message-now" style="--at: 26%">
+                <p class="message-who">you</p>
+                <p class="message-says">{SHARED.asked}</p>
+              </li>
+
+              <li class="message message-now" style="--at: 42%">
+                <p class="message-who">
+                  <span class="message-mark" aria-hidden="true">
+                    <VendorLogo mark={CLIENT_MARKS[2]!} size={14} />
+                  </span>
+                  {CLIENT_MARKS[2]!.title}
+                </p>
+                <p class="message-says">{SHARED.answered}</p>
+              </li>
+            </ol>
+          </div>
+        </div>
+      </section>
+
+      {
+        /* The turn, and the page's one threshold: the only place it says out
+           loud that what follows needs a model. Said once, here, because the
+           reader is already in "how do I run this" and nowhere else.
+
+           It is a sentence and not a device: the page draws a rule to close the
+           hero and nowhere else, so a second one across a paragraph would read as
+           a stray divider rather than as a boundary. And it opens the sentence
+           that turns rather than standing alone, because a threshold nobody
+           crosses in the same breath is just a warning. */
+      }
+      <section
+        class:list={['section', isRaised('your-ai') && 'section-raised']}
+        id="your-ai"
+        aria-labelledby="your-ai-heading"
+      >
+        <div class="shell split">
+          <div class="split-main">
+            <p class="eyebrow reveal">Your AI</p>
+            <h2 class="heading reveal" id="your-ai-heading">Give it a model of its own.</h2>
+
+            <div class="prose reveal">
+              <p>
+                Up to here Argus has needed no model of its own. Past here it does: add a provider
+                and a toolbox becomes a colleague, the same daemon one storey up.
+              </p>
+              <p>
+                Argus ships none. Point it at whatever speaks the protocol, hosted or on hardware
+                you own, and nothing else about your instance changes.
+              </p>
+              <p class="claim">Run it on your own machines and your code never leaves them.</p>
+              <p class="footnote">
+                Examples of servers that speak the protocol, not a supported list. Argus implements
+                the protocol and certifies nobody's server.
+              </p>
+              <p><a href="/guide/llm-providers/">What Argus needs from a model</a></p>
+            </div>
+          </div>
+
+          <div class="reel reveal">
+            <ul class="reel-column">
+              {
+                PROVIDER_MARKS.map((mark) => (
+                  <li class="reel-item">
+                    <VendorLogo mark={mark} />
+                    {mark.title}
+                  </li>
+                ))
+              }
+            </ul>
+            <ul class="reel-column" aria-hidden="true">
+              {
+                PROVIDER_MARKS.map((mark) => (
+                  <li class="reel-item">
+                    <VendorLogo mark={mark} />
+                    {mark.title}
+                  </li>
+                ))
+              }
+            </ul>
+          </div>
+        </div>
+      </section>
+
+      {
+        /* Every other beat turns around, so the story alternates sides. The
+           band is a separate question now: the beats no longer open the page, so
+           the section that flips is not the section that rises. Both answers stay
+           positional, and neither beat has to know where it sits. */
         BEATS.map((beat, beatIndex) => {
           const at = stagger(beat);
 
@@ -415,7 +735,8 @@ const canonical = new URL('/', Astro.site);
             class:list={[
               'section',
               'story',
-              beatIndex % 2 === 1 && ['story-flip', 'section-raised'],
+              beatIndex % 2 === 1 && 'story-flip',
+              isRaised(beat.id) && 'section-raised',
             ]}
             id={beat.id}
             aria-labelledby={`${beat.id}-heading`}
@@ -514,99 +835,43 @@ const canonical = new URL('/', Astro.site);
           );
         })
       }
-
       {
-        /*
-         * The reader has just watched Argus read a pull request, which is the
-         * moment the question changes: not "does it find things" but "what else
-         * does it do while it is in there". For anything that reads a stranger's
-         * branch and then writes in public, that is the question that decides
-         * whether the rest of the page matters.
-         *
-         * A benchmark used to stand here. It was one deliberately broken app and
-         * one class of flaw, which is a fine thing to have measured and a poor
-         * thing to headline: a figure a reader cannot check is an invitation to
-         * argue with the figure. These three are checkable — every one of them is
-         * a promise in the code, on the page it is documented on.
-         */
-      }
-      <section class="section section-raised" id="trust" aria-labelledby="trust-heading">
-        <div class="shell">
-          <p class="eyebrow reveal">Trust</p>
-          <h2 class="heading reveal" id="trust-heading">It reads your branch. Here is the rest.</h2>
+        /* The question half, and the same window as the floor two acts up: what
+           changed between them is who answers. Panel left, so it alternates
+           against the last beat.
 
-          <ul class="guards">
-            {
-              GUARDS.map(({ title, detail }) => (
-                <li class="guard reveal">
-                  <h3 class="guard-title">{title}</h3>
-                  <p class="guard-body">{detail}</p>
-                </li>
-              ))
-            }
-          </ul>
-
-          <div class="prose reveal guards-note">
-            <p>
-              Apache 2.0, and it runs on your own infrastructure. Which is the only claim on this
-              page that matters: read it, run it on a repository you own, and judge it there.
-            </p>
-            <p><a href="/guide/channels/github/">What a review is allowed to do</a></p>
-          </div>
-        </div>
-      </section>
-
-      {
-        /* Two columns, panel on the left, which is the shape the middle beat has
-           — so this alternates against the section under it instead of making a
-           third "copy left, thing right" in a row. */
+           Split out of the tools section it used to share, because that section
+           is now the Toolbox and this is a Colleague-only capability: the Guide's
+           MCP channel serves `consult` on a colleague and not on a toolbox, so a
+           toolbox section demonstrating it would have been showing the one thing
+           the shape cannot do. */
       }
       <section
-        class="section story story-flip"
-        id="your-tools"
-        aria-labelledby="your-tools-heading"
+        class:list={['section', 'story', 'story-flip', isRaised('ask-argus') && 'section-raised']}
+        id="ask-argus"
+        aria-labelledby="ask-argus-heading"
       >
         <div class="shell story-inner">
           <div class="story-copy">
-            <p class="eyebrow reveal">Your tools</p>
-            <h2 class="heading reveal" id="your-tools-heading">
-              Ask it from the AI you already use.
-            </h2>
+            <p class="eyebrow reveal">The question</p>
+            <h2 class="heading reveal" id="ask-argus-heading">Now ask Argus itself.</h2>
 
             <div class="prose reveal">
               <p>
-                Argus speaks MCP, so the assistant already open on your machine can consult it. It
-                hands over the question, Argus answers out of what your organization knows, and the
-                answer arrives where you were working.
+                Your editor again, and the same protocol. What is different is who answers: you
+                hand the question over, and Argus answers it out of what your organization knows.
               </p>
               <p class="claim">Your organization's knowledge never leaves Argus.</p>
-            </div>
-
-            <ul class="pills reveal">
-              {
-                CLIENT_MARKS.map((mark) => (
-                  <li class="pill">
-                    <VendorLogo mark={mark} size={16} />
-                    {mark.title}
-                  </li>
-                ))
-              }
-              <li class="pill pill-open">anything that speaks MCP</li>
-            </ul>
-
-            <div class="prose reveal pills-note">
-              <p class="footnote">
-                Examples of clients, not a supported list. The protocol is the contract, and Argus
-                certifies nobody's client.
-              </p>
               <p><a href="/guide/channels/mcp/">How the MCP channel works</a></p>
             </div>
           </div>
 
           {
-            /* The same panel the story uses, because it is the same kind of
-               evidence — only the surface changed, from a pull request to
-               whatever editor the reader already has open. */
+            /* Deliberately the same panel as the floor's, down to the head: it is
+               the same window on the same protocol, and the argument is that only
+               the answer changed. Written out twice rather than extracted, because
+               Astro scopes a stylesheet to its own component and every class in
+               here is defined in this page's. */
           }
           <div class="panel reveal">
             <p class="panel-head">
@@ -638,47 +903,47 @@ const canonical = new URL('/', Astro.site);
         </div>
       </section>
 
-      <section class="section section-raised" id="your-ai" aria-labelledby="your-ai-heading">
-        <div class="shell split">
-          <div class="split-main">
-            <p class="eyebrow reveal">Your AI</p>
-            <h2 class="heading reveal" id="your-ai-heading">Use your own AI.</h2>
+      {
+        /*
+         * The reader has just watched Argus read a pull request, which is the
+         * moment the question changes: not "does it find things" but "what else
+         * does it do while it is in there". For anything that reads a stranger's
+         * branch and then writes in public, that is the question that decides
+         * whether the rest of the page matters.
+         *
+         * A benchmark used to stand here. It was one deliberately broken app and
+         * one class of flaw, which is a fine thing to have measured and a poor
+         * thing to headline: a figure a reader cannot check is an invitation to
+         * argue with the figure. These three are checkable — every one of them is
+         * a promise in the code, on the page it is documented on.
+         */
+      }
+      <section
+        class:list={['section', isRaised('trust') && 'section-raised']}
+        id="trust"
+        aria-labelledby="trust-heading"
+      >
+        <div class="shell">
+          <p class="eyebrow reveal">Trust</p>
+          <h2 class="heading reveal" id="trust-heading">It reads your branch. Here is the rest.</h2>
 
-            <div class="prose reveal">
-              <p>
-                Argus ships no model. Point it at whatever speaks the protocol: a hosted API, or
-                something running on hardware you own.
-              </p>
-              <p class="claim">Run it on your own machines and your code never leaves them.</p>
-              <p class="footnote">
-                Examples of servers that speak it, not a supported list. Argus implements the
-                protocol and certifies nobody's server.
-              </p>
-              <p><a href="/guide/llm-providers/">What Argus needs from a model</a></p>
-            </div>
-          </div>
+          <ul class="guards">
+            {
+              GUARDS.map(({ title, detail }) => (
+                <li class="guard reveal">
+                  <h3 class="guard-title">{title}</h3>
+                  <p class="guard-body">{detail}</p>
+                </li>
+              ))
+            }
+          </ul>
 
-          <div class="reel reveal">
-            <ul class="reel-column">
-              {
-                PROVIDER_MARKS.map((mark) => (
-                  <li class="reel-item">
-                    <VendorLogo mark={mark} />
-                    {mark.title}
-                  </li>
-                ))
-              }
-            </ul>
-            <ul class="reel-column" aria-hidden="true">
-              {
-                PROVIDER_MARKS.map((mark) => (
-                  <li class="reel-item">
-                    <VendorLogo mark={mark} />
-                    {mark.title}
-                  </li>
-                ))
-              }
-            </ul>
+          <div class="prose reveal guards-note">
+            <p>
+              Apache 2.0, and it runs on your own infrastructure. Which is the only claim on this
+              page that matters: read it, run it on a repository you own, and judge it there.
+            </p>
+            <p><a href="/guide/channels/github/">What a review is allowed to do</a></p>
           </div>
         </div>
       </section>
@@ -1438,6 +1703,21 @@ const canonical = new URL('/', Astro.site);
         background-color: var(--color-surface);
       }
 
+      /*
+       * Work rather than speech: no card, no fill, and a rule in `primary` down
+       * the left. The two messages either side of them are boxes, so the run of
+       * steps between reads as the machine part of the exchange without anything
+       * having to say so.
+       */
+      .step {
+        padding: 0.1rem 0 0.1rem 0.75rem;
+        border-left: 2px solid var(--color-primary);
+        font-family: var(--font-mono);
+        font-size: 0.75rem;
+        line-height: 1.7;
+        color: var(--color-text-muted);
+      }
+
       .message-past {
         background-color: transparent;
         color: var(--color-text-muted);
@@ -1907,6 +2187,7 @@ const canonical = new URL('/', Astro.site);
           }
 
           .code-line,
+          .step,
           .message-now,
           .remembered {
             animation-name: land;