# Twelve Pages — Full Handbook Corpus Index

> Complete structured index of all 66 visual 12-page handbooks (792 illustrated pages across 8 ecosystems) published at https://twelve-pages.com.

All handbooks, topics, diagrams, and illustrations are AI-authored under human editorial direction and print QA. Always verify critical commands, security policies, and vendor pricing against official documentation.

- Concise Directory: https://twelve-pages.com/llms.txt
- AI & Editorial Disclosure: https://twelve-pages.com/editorial
- Sitemap: https://twelve-pages.com/sitemap.xml
- RSS Feed: https://twelve-pages.com/rss.xml
- JSON Feed: https://twelve-pages.com/feed.json

## Google AI & Creative Studios (13 Handbooks)

Topic Hub: https://twelve-pages.com/topics/google

Publication-grade 12-page visual handbooks covering Google AI Ultra's creative studios, Antigravity 2.0 customizations & swarms, Gemini 3.8 Live & Omni 1.2 Flash voice/video pipelines, agentic Firebase & Android CLI workflows, and autonomous browser agents.

### Google Flow

> Cinematic AI filmmaking studio powered by Veo 3.1, Ingredients consistency, Frames-to-Video transitions, and Scenebuilder.

- Web: https://twelve-pages.com/guides/google/google-flow
- Markdown: https://twelve-pages.com/guides/google/google-flow.md
- PDF: https://twelve-pages.com/guides/google/google-flow/Google_Flow_Complete_How_To_Guide.pdf (4.3 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Flow Agent Storyboarding, Ingredients Consistency (@Tags), Start & End Frame Keyframing, Camera & Lens Direction, Native Dialogue & SFX, Scenebuilder Timeline
- Core Takeaways:
  - Three Engines, One Studio: Unifies Gemini Omni Flash, Imagen 4 / Nano Banana, and Veo 3.1 in one browser & mobile workspace.
  - Built for Continuity: Lock faces, outfits, and props across dozens of shots using Ingredients and Save-Last-Frame anchors.
  - Zero Experience Needed: Plain-English workflows, visual UI maps, copy-paste prompt formulas, and credit-saving habits.
- Chapters:
  1. Inside This Guide & What Google Flow Actually Is — Most AI video tools give you a single text box that produces random 5-second clips. Google Flow (flow.google) is a complete digital film studio built to tell multi-shot stories with consistent characters, sound, and editing.
  2. Getting Started: Account Setup, Plans & Credit Math — You can start experimenting with Google Flow in under two minutes for free, then scale up only if you need longer productions, premium models, or 4K exports.
  3. The Google Flow Workspace: Annotated Visual Tour — When you open a project in flow.google, everything lives inside one dark-mode studio screen. Use the numbered callouts below to orient yourself in seconds.
  4. The 6-Step Filmmaking Pipeline (Start to Finish) — Beginners often make the mistake of jumping straight to video generation. Follow this proven 6-step studio order to build a cohesive 30-second short film on your very first try—without wasting credits.
  5. Solving "Character Drift" with Flow Agent & Ingredients — The #1 frustration in AI video is watching your main character morph into a stranger from Shot 1 to Shot 2. Google Flow solves this with two paired tools: Agent Instructions and Ingredients to Video.
  6. Generation Modes & "Frames to Video" Keyframing — Every shot in Google Flow starts by choosing one of three generation modes. Picking the right mode before typing saves hours of trial-and-error.
  7. The 8-Block Director Prompt Formula — Treat Google Flow's prompt box like a film director's cue sheet—not a search engine. Ordering your prompt from big visual rules down to specific audio cues gives Veo 3.1 crystal-clear instructions.
  8. Visual Camera Movement & Lens Cheat Sheet — Avoid generic words like "moving camera." Veo 3.1 is trained on real cinematography terminology—use the exact movement phrases below to direct intentional, rock-steady shots.
  9. Directing Synchronized Dialogue, SFX & Ambience — With Audio toggled ON, Veo 3.1 generates lip-synced speech, physical Foley sound effects, and room ambience simultaneously with video pixels—no external lip-sync plugin required.
  10. Assembling Your Film in Scenebuilder & Beyond — Once your clips are generated, open Scenebuilder at the bottom of the workspace. Unlike rigid storyboards, Scenebuilder is a flexible "generate, then assemble" timeline with AI continuity superpowers.
  11. Troubleshooting Clinic & Creator Cheat Sheet — Keep this final page handy while working in flow.google. Almost every frustrating generation has a fast, predictable fix.

### Google Antigravity & Jules

> Agent-first desktop IDE, parallel subagents, skills/MCP customization, and asynchronous GitHub PR automation with Jules.

- Web: https://twelve-pages.com/guides/google/google-antigravity-and-jules
- Markdown: https://twelve-pages.com/guides/google/google-antigravity-and-jules.md
- PDF: https://twelve-pages.com/guides/google/google-antigravity-and-jules/Google_Antigravity_and_Jules_Complete_How_To_Guide.pdf (3.4 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Antigravity 2.0 Desktop App, Antigravity IDE (Tab & Cmd+I), Jules Async GitHub Workflows, Subagents & Parallel Swarms, Rules, Skills, Plugins & MCP, CLI (agy) & Python SDK
- Core Takeaways:
  - Four Unified Surfaces: Work seamlessly across the Desktop App, VS Code-based IDE, Terminal CLI (agy), and Python SDK.
  - Jules DNA Built Right In: Includes the complete late-2026 Jules-to-Antigravity migration map for async branches, PRs, and cron runs.
  - Powered by AI Ultra: Unlock 5x–20x frontier Gemini quotas so multi-agent swarms and overnight /goal runs never stall.
- Chapters:
  1. The Big Picture: Antigravity + Jules in One Studio — Google Antigravity (antigravity.google) is Google's flagship agent-first software creation platform—designed not just to autocomplete lines of code, but to plan, build, test, browse, and ship entire projects alongside you.
  2. First-Time Setup & Your Google AI Ultra Advantage — You don't need to be a senior software engineer to use Antigravity. Non-coders use Antigravity 2.0 to generate guides, websites, and automations, while engineers pair it with the IDE and CLI.
  3. Antigravity 2.0 Desktop App: Annotated Visual Tour — Antigravity 2.0 separates high-level thinking from raw code files. You converse in the center Chat Canvas while live subagents, terminals, artifacts, and file diffs update in the right-hand Auxiliary Pane.
  4. Antigravity IDE: Three Speeds of AI Pair Programming — Built on VS Code so all your favorite extensions and themes carry over, Antigravity IDE gives you three distinct gears depending on whether you are editing one line, one function, or twenty files.
  5. Steering Agents with / Slash Commands & @ Mentions — Typing a single slash command at the start of your prompt shifts Antigravity into specialized operating modes—from interactive design interviews to unstoppable overnight execution.
  6. The 6-Step Agentic Build Loop (Idea to Verified PR) — Whether you are building a personal dashboard from scratch or adding a feature to an existing repo, this 6-step loop keeps you in full control while the agent handles the heavy lifting.
  7. Google Jules: Async Pioneer & Antigravity Migration — Google Jules (jules.google) introduced "fire-and-forget" asynchronous engineering—cloning GitHub repos into cloud Linux VMs, proposing a plan, running tests, and opening Pull Requests while you worked elsewhere.
  8. Multiplying Yourself: Subagents & Native Swarms — With a Google AI Ultra plan, you aren't limited to a single single-threaded assistant. Antigravity can dispatch specialized specialist agents—or an entire collaborative team—that work simultaneously.
  9. Customizing Antigravity: Rules, Skills, Plugins & MCP — Out of the box, Antigravity is a brilliant generalist. With five modular customization building blocks, you turn it into a specialist tailored to your exact voice, codebase, and third-party apps.
  10. Headless Power: agy CLI, Python SDK & Cron Jobs — When you want agentic power directly inside your macOS terminal, automated Python scripts, or recurring morning briefings, reach for these three headless workflows.
  11. Safety Controls, Troubleshooting & Quick Cheat Sheet — Autonomous agents are only fun when you trust their boundaries. Antigravity gives you granular global and per-project guardrails under Settings → Permissions & Sandbox.

### Google Whisk

> Image-first visual remixing studio blending Subject, Scene & Style cards, hidden Gemini captions, Seed locking, and Whisk Animate.

- Web: https://twelve-pages.com/guides/google/google-whisk
- Markdown: https://twelve-pages.com/guides/google/google-whisk.md
- PDF: https://twelve-pages.com/guides/google/google-whisk/Google_Whisk_Complete_How_To_Guide.pdf (3.9 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Subject + Scene + Style Blending, Hidden Gemini Caption Editing, Nano Banana 2 & Imagen 4, Conversational Refine Loop, Seed Lock Consistency, Whisk Animate (Veo) & Flow Pipeline
- Core Takeaways:
  - Prompt With Pictures: Drag photos, sketches, or textures into Subject, Scene, and Style slots instead of writing 200-word prompts.
  - Essence Over Copy-Paste: Gemini understands your references and paints fresh, cohesive variations powered by Nano Banana 2 & Imagen.
  - Built to Feed Google Flow: Turn winning Whisk creations into 8-second Veo animations—or export them straight into Flow Ingredients.
- Chapters:
  1. What Is Google Whisk (And Why It Feels Like Magic) — Describing an exact artistic style or product shape in words is hard. Google Whisk (labs.google/fx/tools/whisk) flips AI art upside down: you show Google three reference images—Subject, Scene, and Style—and Whisk remixes them into something brand new.
  2. First Launch, AI Ultra Perks & Aspect Ratio Guide — Whisk is built for zero-friction play: you can roll built-in dice presets within five seconds of opening the page, or click Start From Scratch to upload your own photos and brand assets.
  3. The Google Whisk Workspace: Annotated Visual Tour — Whisk keeps its workspace intentionally tactile—like spreading reference polaroids on a designer's desk. Master these 7 numbered controls to unlock full precision.
  4. How to Mix Subject, Scene & Style Like an Art Director — Think of Whisk's three slots like cooking ingredients: Subject is the "Who/What", Scene is the "Where", and Style is the "Medium & Mood". You can fill all three—or leave any slot empty!
  5. One Subject, Infinite Worlds: Style-Transfer Mastery — Keeping your Subject slot locked while swapping only the Style card is the fastest way to explore ten wildly different visual directions for a brand, story, or gift in two minutes.
  6. Unlocking Precision via Hidden Gemini Captions — Ninety percent of casual users never click the small View / Edit Caption icon on their uploaded cards—yet it is the single most powerful control in all of Google Whisk.
  7. Polishing Winners: Refine Chat, Text Signs & Seeds — When an output is 90% right, don't hit Remix and lose the composition you love. Use Whisk's Refine loop, Nano Banana 2 typography, and Seed Locking to dial in the final 10%.
  8. 5 Real-World Creative Recipes You Can Build Today — Not sure what to make first? Plug your own photos into any of these five proven slot recipes for instant studio-grade results.
  9. Mastering Whisk Animate: From Still Card to Living Clip — Hover over any favorite Whisk image and click Animate. Powered by Google's Veo video engine, Whisk transforms your static frame into a fluid 8-second MP4 clip right inside your browser.
  10. Power Pipeline: Design in Whisk, Direct in Google Flow — Now that you have both the Google Flow guide and this Google Whisk guide, combining the two unlocks Google AI Ultra's ultimate creative workflow—and why Google integrated Whisk's DNA directly into the Flow ecosystem.
  11. Troubleshooting Clinic & Pre-Flight Cheat Sheet — Keep this page open next to Whisk whenever an output surprises you—every quirk has a fast, reliable fix.

### Google Vids

> Workspace AI video presentation studio turning Docs & Slides into narrated storyboards with AI voiceovers, avatars, teleprompter, and Veo B-roll.

- Web: https://twelve-pages.com/guides/google/google-vids
- Markdown: https://twelve-pages.com/guides/google/google-vids.md
- PDF: https://twelve-pages.com/guides/google/google-vids/Google_Vids_Complete_How_To_Guide.pdf (4.4 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: "Help me create" + @Drive, AI Voiceovers & 24-Lang Avatars, Recording Studio & Teleprompter, Veo 3.1 Custom B-Roll, Transcript Trim & Auto-Ducking, Real-Time Workspace Collab
- Core Takeaways:
  - From Google Doc to Storyboard: Reference any Doc, Slide deck, or PDF with @mentions—Gemini builds scenes, scripts, music, and B-roll in seconds.
  - Camera-Optional Storytelling: Narrate via lifelike Gemini AI Voiceovers and AI Avatars, or record smoothly with the built-in scrolling Teleprompter.
  - Edit Video Like Slides & Docs: Delete "ums" right in the text transcript, generate custom Veo clips in the sidebar, and collaborate live in Drive.
- Chapters:
  1. What Is Google Vids (And Why Teams Love It) — Traditional video editors force you onto intimidating multi-track timelines before you even have a story. Google Vids (vids.google.com) sits right alongside Docs, Sheets, and Slides—combining slide-simple scene cards with Gemini scripting, studio recording, and custom Veo generation.
  2. Getting Started, Project Formats & AI Ultra Perks — Because Google Vids lives natively inside Google Drive, there is nothing to install, render locally, or back up—every edit saves to the cloud automatically in real time.
  3. The Google Vids Workspace: Annotated Visual Tour — If you have ever used Google Slides, you already know 70% of Google Vids. Learn these 7 numbered studio controls to command the remaining 30% like a seasoned video producer.
  4. Turning Docs & Slides Into Videos With @Drive — Staring at a blank timeline is history. Typing @ inside Help me create grounds Gemini directly in your own Google Docs, Slide decks, and PDFs—so facts, metrics, and structure never get hallucinated.
  5. Narrating Your Story: AI Voices, Avatars & Studio — Great audio makes even simple visuals feel expensive. Google Vids gives you three mix-and-match narration paths—and automatically syncs scene timing to your spoken words.
  6. Custom Veo B-Roll, Imagen Visuals & Lyria Music — Stock footage gets you a fast first draft, but generic office handshakes rarely match your brand. With Google AI Ultra, you can generate bespoke 8-second Veo 3.1 video clips, custom graphics, and AI music right inside the right-hand rail.
  7. Timeline Polish: Timing Markers & Audio Ducking — What separates an amateur slide export from a broadcast-grade explainer? Three habits: staggered Object Timing, restrained Transitions, and balanced Audio Ducking.
  8. 5 Real-World Google Vids Recipes You Can Ship Today — Each recipe pairs a specific Workspace input with the fastest narration and visual workflow—turning hours of editing or live meetings into reusable 2-minute assets.
  9. Workspace Collaboration, Captions & Delivery Guide — No more emailing 800 MB Final_v7_REAL.mp4 attachments back and forth. Reviewers comment directly on scenes in their browser just like a Google Doc—and you only export MP4 when ready to publish externally.
  10. Power Pipeline: Combining Whisk + Flow + Vids — Together with our Google Whisk and Google Flow guides, Google Vids completes your three-part Google AI Ultra studio—taking any idea from wild visual concept to polished, multi-minute narrated presentation.
  11. Troubleshooting Clinic & Pre-Flight Cheat Sheet — Bookmark this final page for instant fixes to the seven most common Google Vids hiccups—plus a 6-point pre-flight checklist before sharing with leadership or clients.

### Google Stitch

> AI-native UI/UX design studio turning prompts, sketches, and screenshots into multi-screen flows, Figma Auto-Layout frames, and Tailwind code.

- Web: https://twelve-pages.com/guides/google/google-stitch
- Markdown: https://twelve-pages.com/guides/google/google-stitch.md
- PDF: https://twelve-pages.com/guides/google/google-stitch/Google_Stitch_Complete_How_To_Guide.pdf (3.9 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Prompt & Sketch to UI, Infinite Multi-Screen Canvas, Standard & Experimental Modes, Global Themes & DESIGN.md, One-Click Paste to Figma, HTML/Tailwind & Antigravity MCP
- Core Takeaways:
  - Napkin to Production UI: Transform plain-English app goals, whiteboard wireframes, or screenshots into crisp Mobile and Web interfaces in seconds.
  - Cohesive Design Systems: Switch Light/Dark modes, accent palettes, fonts, corner radii, and portable DESIGN.md rules across entire user flows.
  - Built for Figma & Antigravity: Paste editable Auto-Layout layers straight into Figma—or stream clean HTML/Tailwind via MCP into Google Antigravity.
- Chapters:
  1. What Is Google Stitch (And Why It Changes UI Design) — Traditional image generators paint flat pictures of apps filled with garbled text that developers have to rebuild from scratch. Google Stitch (stitch.withgoogle.com, born from Google Labs and Galileo AI) is a true AI-native interface studio: it thinks in real layout trees, design tokens, multi-screen user flows, editable Figma layers, and clean semantic frontend code.
  2. First Launch: Targets, Modes & Monthly Allowances — Before typing your first prompt at stitch.withgoogle.com, two quick toggles at the bottom of the composer shape everything Stitch builds: your Device Target (Mobile vs. Web) and your Model Mode (Standard vs. Experimental).
  3. The Google Stitch Workspace: Annotated Visual Tour — Stitch combines an expansive multi-screen canvas with a conversational design agent and global theme tokens. Master these 7 numbered controls to steer every pixel and code export cleanly.
  4. From Napkin Sketch or Screenshot to Production UI — Sometimes drawing three boxes on dotted paper is ten times faster than explaining a spatial layout in words. Switch Stitch to Experimental Mode, click the attachment icon, and let Gemini Vision translate rough ink into polished UI and clean DOM structure.
  5. Writing High-Precision UI Prompts & Mastering Themes — Vague prompts like "make a finance app" yield generic templates. Giving Stitch five structured ingredients produces agency-grade layouts—which you can then restyle across radically different aesthetics in one click.
  6. Building Cohesive Multi-Screen Flows & Surgical Edits — Real software isn't one hero screen—it is an end-to-end journey. Stitch's infinite canvas and Agent Manager let you map 4 to 8 connected screens that share identical navigation chrome, spacing rhythm, and theme tokens.
  7. Design-to-Dev Handoff: Paste to Figma & Clean Code — Stitch eliminates the dead-end "static mockup trap." Whether your next stop is a collaborative design critique in Figma or a live repository in Google Antigravity, your work travels with full structure intact.
  8. 5 Copy-Paste Stitch Recipes for Mobile & Web Apps — Paste any of these five battle-tested prompts straight into Stitch—each is engineered with clear hierarchy, realistic domain copy, and crisp theme tokens so it renders cleanly on the very first run.
  9. Elevating AI Mockups into Shippable, Accessible UX — Left unguided, any AI UI tool will happily pack twelve charts onto one phone screen or place pale mint text on a white button. Apply these four senior UX guardrails inside Stitch so your designs pass real engineering and accessibility reviews.
  10. Power Pipeline: Design in Stitch, Ship in Antigravity — Pairing Google Stitch with your Google Antigravity & Jules setup creates Google's flagship end-to-end software factory: Stitch acts as your instant UX & design-system studio, Antigravity builds the real full-stack application via MCP, and Jules handles background verification.
  11. Troubleshooting Clinic & Pre-Flight Cheat Sheet — Keep this page handy alongside stitch.withgoogle.com—every common UI generation hiccup has a reliable 10-second fix.

### Google Opal

> Visual no-code AI mini-app studio chaining Gemini, Imagen, Veo, Lyria, and Web Search nodes into shareable interactive apps.

- Web: https://twelve-pages.com/guides/google/google-opal
- Markdown: https://twelve-pages.com/guides/google/google-opal.md
- PDF: https://twelve-pages.com/guides/google/google-opal/Google_Opal_Complete_How_To_Guide.pdf (3.9 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Natural-Language App Builder, Visual Node-Graph Canvas, @Variable Step Chaining, Gemini + Imagen + Veo + Lyria, Gallery Remixing & Themes, 1-Click Publishing & Drive Sync
- Core Takeaways:
  - Speak an App Into Existence: Describe what your tool should do in plain English and watch Opal wire a working multi-step workflow in seconds.
  - Chat + Visual Graph Sync: Switch seamlessly between conversational edits and surgical node-by-node prompt, tool, and model tweaks.
  - Instant Link Sharing: Publish polished interactive web mini-apps stored safely in Google Drive—zero servers, API keys, or deployment setup.
- Chapters:
  1. What Is Google Opal (And Why Mini-Apps Beat Single Prompts) — Standard chat prompts crumble when a task needs five distinct stages—like researching a live URL, writing a script, painting four matching scenes, and formatting a clean webpage. Google Opal (opal.withgoogle.com / opal.google) lets anyone build reusable, shareable AI mini-apps visually without writing a single line of code.
  2. Getting Started & Where Opal Fits in Your AI Stack — Opal bridges the gap between casual chat assistants and full software engineering: you get the structured power of multi-step pipelines with zero boilerplate, package installs, or cloud billing setup.
  3. The Google Opal Studio: Annotated Visual Tour — Opal's superpower is bi-directional sync: ask the bottom chat bar to add a feature and watch new cards appear on the canvas—or click any card directly to fine-tune its prompt, model, and @Variables.
  4. Opal's Building Blocks: Every Node Type Explained — Every Opal mini-app—from a two-step summarizer to a ten-node multimedia studio—is assembled from four foundational node families working together in sequence or in parallel.
  5. Mastering Multi-Step Chains & @Variable Chips — The magic of Opal happens when Step 2 automatically builds on Step 1's output—for example, letting Gemini write an ultra-detailed visual art prompt first, then feeding that exact prompt into Imagen 4 via an @ tag.
  6. Crafting Polished App Interfaces & Gallery Remixing — People who open your published Opal link never see your node graph unless they choose to remix it—they experience a sleek, standalone interactive web mini-app. A few thoughtful UX touches make your tool feel custom-coded.
  7. Debugging in the Console & Cutting Wait Time in Half — Nothing kills mini-app magic faster than a 45-second loading spinner or one broken step derailing the final screen. Use Opal's Step Console and Parallel Fan-Out wiring to keep apps fast and resilient.
  8. 5 High-Impact Mini-Apps You Can Build in 10 Minutes — Paste any blueprint below into Opal's Conversational Chat Builder to auto-scaffold the graph, then customize the individual node prompts to fit your workflow.
  9. Publishing, Sharing Links & Managing Drive Files — With traditional AI code projects, sharing a prototype with a colleague means wrestling with cloud hosting and leaked API keys. Opal handles identity, compute, and Google Drive file permissions natively.
  10. Power Pipeline: Validate in Opal, Scale in Antigravity — Smart builders never spend two weeks coding a full-stack app before knowing if users care—or if the AI pipeline even works! Use Google Opal as your rapid product lab, then graduate proven winners into AI Studio and Google Antigravity.
  11. Troubleshooting Clinic & Pre-Flight Cheat Sheet — Keep this page handy whenever a workflow step misbehaves—every common Google Opal quirk has a reliable 10-second fix.

### Google AI Studio

> Flagship Gemini developer & power-user workbench for 1M+ token video/PDF analysis, Stream Realtime screen share, Build vibe-coding, and SDKs.

- Web: https://twelve-pages.com/guides/google/google-ai-studio
- Markdown: https://twelve-pages.com/guides/google/google-ai-studio.md
- PDF: https://twelve-pages.com/guides/google/google-ai-studio/Google_AI_Studio_Complete_How_To_Guide.pdf (4.1 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: 1M+ Token Multimodal Playground, Stream Realtime (Voice + Screen Share), Build Mode Vibe-Coding & Cloud Run, Google Search & URL Context, Visual JSON Schema Builder, Multi-Speaker TTS, Nano Banana & Veo
- Core Takeaways:
  - Zero Code Required to Start: Drop in 1-hour videos, 500-page PDFs, or share your live screen to solve complex work right in your browser.
  - Full Dial & Tool Control: Unlock System Instructions, Thinking levels, Compare Mode, Python Code Execution, and guaranteed JSON output.
  - Idea to Live App in Minutes: Describe an app in plain English inside Build mode, publish to a custom URL, or export clean Gemini SDK code.
- Chapters:
  1. What Is Google AI Studio (And Why Non-Coders Love It Too) — Think of consumer Gemini (gemini.google.com) like an automatic family sedan, and Google AI Studio (aistudio.google.com) as the open cockpit with every pro dial unlocked. Originally built for developers, it has quietly become the secret weapon of researchers, creators, analysts, and first-time app builders.
  2. Picking the Right Model, Privacy Tier & Run Dials — Before uploading your first file, take sixty seconds to learn two essentials: which Gemini engine fits your task, and the critical data-privacy boundary between AI Studio's Free Tier and Paid Billing Tier.
  3. The Google AI Studio Workspace: Annotated Tour — Everything in AI Studio lives inside a clean three-column layout: Modes on the left, your Conversation & System Instructions in the center, and Model & Tool Dials on the right.
  4. 1M+ Token Superpowers: Drop Everything In at Once — Most AI tools chop long documents into tiny fragments and only "see" a handful of paragraphs at a time. Gemini's native 1,048,576-token window holds an entire hour of video, 1,500 pages of PDFs, or 30,000 lines of code in active memory simultaneously.
  5. System Instructions, Live Grounding & Python Sandbox — Stop repeating "be concise, don't make things up, format as a table" in every message. Moving your rules into System Instructions and flipping on AI Studio's built-in tools transforms Gemini from a chatbot into a verifiable analyst.
  6. Stream Realtime & Instant Apps in Build Mode — Two tabs in AI Studio's left sidebar regularly make first-time users gasp out loud: Stream Realtime (where Gemini watches your live screen and talks you through anything) and Build (where plain English turns into a live deployed web or Android app).
  7. Structured Outputs & Multi-Speaker Media Studio — Whether you want to turn 50 messy PDF invoices into a clean spreadsheet or turn dry research notes into a lifelike two-host audio briefing, AI Studio gives you dedicated visual interfaces for both.
  8. 5 Real-World Recipes You Can Run in Under 5 Minutes — You don't need to write a single line of code to save hours with AI Studio. Try any of these five battle-tested recipes using your own files today.
  9. API Keys, Get Code & Scaling in Antigravity — When a prompt or prototype inside AI Studio works so well you want to automate it in Python/TypeScript or turn it into a production company product, AI Studio hands you clean starter code in seconds.
  10. The Complete Google AI Ultra Ecosystem Map — Wondering when to open Google AI Studio versus Antigravity, Stitch, Opal, Whisk, Vids, or Flow? Here is how the entire Google AI Ultra suite snaps together like a single modular studio.
  11. Troubleshooting Clinic & Pre-Flight Cheat Sheet — Keep this final reference page handy whenever an API call, long file upload, or Build preview hits a snag—almost every issue has a 10-second fix.

### Google NotebookLM

> Zero-hallucination research studio for 500+ sources, live interactive Join Audio Overviews, Video Overviews, and clickable Mind Maps.

- Web: https://twelve-pages.com/guides/google/google-notebooklm
- Markdown: https://twelve-pages.com/guides/google/google-notebooklm.md
- PDF: https://twelve-pages.com/guides/google/google-notebooklm/Google_NotebookLM_Complete_How_To_Guide.pdf (4.2 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Zero-Hallucination Grounding, 500+ Sources (AI Ultra), Interactive Audio ("Join" Live), Narrated Video Overviews, Clickable Mind Maps, Mobile App & Chat-Only Sharing
- Core Takeaways:
  - Zero Outside Hallucinations: Every claim links to clickable inline citations ([1] [2]) that jump straight to the exact highlighted quote in your files.
  - AI Ultra Scale (500+ Sources): Load up to 500–600 sources per notebook—up to 500,000 words per file—backed by 5x–20x priority Studio compute.
  - Read, Listen, Watch & Map: Transform dense folders into 2-host podcasts you can join live on mic, visual Video Overviews, and branching Mind Maps.
- Chapters:
  1. Why NotebookLM Changes How You Learn & Research — Standard AI chatbots draw from the entire open internet—blending facts with plausible-sounding guesses. Google NotebookLM (notebooklm.google.com, integrated across the Gemini ecosystem as Gemini Notebook) builds a strict walled garden around the exact files you upload, turning Gemini into an instant expert on your world alone.
  2. Google AI Ultra Super-Limits & Supported Sources — While free accounts cap out at 50 files per project, your Google AI Ultra membership turns each notebook into an enterprise-scale knowledge vault holding hundreds of books, transcripts, and slide decks simultaneously.
  3. The 3-Panel NotebookLM Studio: Visual Tour — NotebookLM organizes everything into one clean left-to-right flow: Sources on the left, grounded Chat in the center, and multimodal Studio outputs & saved notes on the right.
  4. Mastering Checkboxes, Citations & the Notes Loop — Because NotebookLM trusts your uploaded sources as ground truth, garbage in equals garbage out. Three simple curation habits separate casual users from research pros.
  5. Audio Overviews & Stepping Live Into the Podcast (Join) — NotebookLM's viral two-host podcast engine has evolved into a four-format audio studio supporting 50+ languages, custom producer instructions, and live two-way voice participation.
  6. Video Overviews, Mind Maps & Active Study Suite — Some concepts—like system architectures, historical timelines, or biochemical pathways—click 10x faster visually than in audio alone. The right-hand Studio panel turns raw text into visual explainers and interactive study decks.
  7. Power Prompting: Cross-Examining 500 Sources at Once — Don't just ask NotebookLM "Summarize this." Because Gemini holds all checked documents inside one massive grounded context window, you can run forensic cross-document audits that would take a human research team weeks.
  8. 5 Real-World NotebookLM Power Recipes — Ready to put your 500-source Google AI Ultra capacity to work? Use these five proven blueprints to turn sprawling folders into clarity in a single afternoon.
  9. NotebookLM Mobile App & Team Sharing Modes — Your research vault no longer lives purely in a desktop tab. With the native NotebookLM app for iOS and Android plus granular sharing controls, you can capture sources on the move and publish interactive knowledge portals for anyone.
  10. Power Pipeline: Deep Research → NotebookLM → Vids — NotebookLM deliberately stays inside its walled garden—which means pairing it with Gemini Deep Research (for open-web scouting) and Google Vids / Slides / Whisk / Flow (for visual storytelling) unlocks Google AI Ultra's ultimate end-to-end workflow.
  11. Troubleshooting Clinic & Pre-Flight Cheat Sheet — Keep this page handy whenever a source refuses to import or an output misses the mark—every quirk has a fast, reliable fix.

### Gemini Deep Research, Canvas & Gems

> Autonomous multi-hundred-site research dossiers, split-screen Canvas live apps with embedded AI, and custom Drive-synced Gems.

- Web: https://twelve-pages.com/guides/google/google-gemini-deep-research-canvas-and-gems
- Markdown: https://twelve-pages.com/guides/google/google-gemini-deep-research-canvas-and-gems.md
- PDF: https://twelve-pages.com/guides/google/google-gemini-deep-research-canvas-and-gems/Google_Gemini_Deep_Research_Canvas_and_Gems_Complete_How_To_Guide.pdf (4.0 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Autonomous Deep Research, Private Uploads + Live Web, Split-Screen Gemini Canvas, "Add Gemini Features" Apps, Custom Gems & Live Drive Sync, Deep Think & Scheduled Actions
- Core Takeaways:
  - Hours of Research in Minutes: Approve a custom Research Plan, blend Google Drive + Gmail + hundreds of websites, and get a cited executive dossier.
  - From Blank Page to Live App: Co-write docs with Tone & Length sliders or transform any report into a live web dashboard, infographic, or quiz in Canvas.
  - Permanent AI Specialists: Build Custom Gems grounded in live-synced Google Docs and Workspace tools—and put recurring briefings on autopilot.
- Chapters:
  1. Beyond Chat: How Gemini's Power Trio Works Together — Treating Google Gemini (gemini.google.com) like a simple question-and-answer box leaves 80% of its power untouched. Inside that single interface live three interconnected studios—Deep Research, Canvas, and Custom Gems—that act as your personal research agency, interactive workshop, and specialist staff.
  2. What Your Google AI Ultra Plan Unlocks in Gemini — Your Google AI Ultra membership upgrades every layer of gemini.google.com and the Gemini mobile app—giving you priority access to Google's deepest reasoning engine, highest daily Deep Research ceilings, massive memory, and background automation.
  3. The Gemini Power Workspace: Annotated Visual Tour — Once you activate Canvas or open a Deep Research report, Gemini transforms from a single column into a full dual-pane production studio. Master these 7 numbered controls to fly through any project.
  4. Mastering Deep Research: Your Autonomous Analyst — Standard AI search skims five snippets and guesses an answer in three seconds. Gemini Deep Research works like a dedicated consulting analyst: it designs a multi-point plan, browses hundreds of pages iteratively, cross-checks your private files, and writes a cited executive report while you do other work.
  5. Deep Research Brief Formula & Post-Report Magic — Great Deep Research prompts read like an assignment to a sharp human chief of staff: tell Gemini what decision you are making, what private context you attached, and what evidence counts.
  6. Gemini Canvas: Co-Writing & Instant Interactive Apps — Standard chat forces you to regenerate an entire 1,500-word draft just to soften paragraph four. Selecting the Canvas pill opens a persistent side-by-side studio where you and Gemini edit living documents—or build working web software—in real time.
  7. Advanced Canvas: "Add Gemini Features" & Live Sharing — Here is the most underrated feature in all of Google Gemini: Canvas doesn't just build static calculators—clicking ✨ Add Gemini Features embeds live Gemini intelligence inside the web app you just built, with zero API keys or billing setup!
  8. Building Custom Gems: Your Permanent AI Dream Team — Any time you catch yourself pasting the same role description, style rules, or reference files twice, stop and build a Custom Gem. Open Gems in the left rail, click + New Gem, and turn a repeatable prompt into a one-click specialist on web and mobile.
  9. 6 High-Impact Recipes You Can Copy & Run Today — Test-drive the full suite in ten minutes with these six battle-tested blueprints—two for Deep Research, two for Canvas, and two reusable Custom Gems.
  10. Studio Synergy: Research to Live App, Notebook & Video — Inside your Google AI Ultra creative suite, Google Docs acts as the universal baton. Watch how a single question flows across five Google tools in twenty minutes to produce an entire executive launch kit.
  11. Troubleshooting Clinic & Power-User Cheat Sheet — Keep this reference page handy—every quirk across Deep Research, Canvas, and Custom Gems has a fast, predictable 10-second fix.

### Google Project Mariner

> Autonomous browser-use agent & Gemini Agent Mode running up to 10 parallel cloud browsers, Teach & Repeat skills, and safety gates.

- Web: https://twelve-pages.com/guides/google/google-project-mariner
- Markdown: https://twelve-pages.com/guides/google/google-project-mariner.md
- PDF: https://twelve-pages.com/guides/google/google-project-mariner/Google_Project_Mariner_Complete_How_To_Guide.pdf (4.2 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Up to 10 Parallel Cloud Browsers, Teach & Repeat Workflows, Live Pixel & DOM Reasoning, Human-in-the-Loop Safety Gates, Gemini Agent Mode & Chrome, Gemini Computer Use API
- Core Takeaways:
  - From Reading to Acting: Mariner reads live pixels, buttons, dropdowns, and dynamic JS apps—scrolling, typing, and navigating tabs for you.
  - Keep Your Local Mouse Free: Dispatch up to 10 simultaneous missions inside isolated cloud virtual browsers while you stay focused on your own screen.
  - You Hold the Final Key: Built-in safety gates pause automatically before logins, payments, form submissions, or any irreversible action.
- Chapters:
  1. From Chatting With the Web to Acting on the Web — Standard AI chatbots summarize pages they can read, but freeze the moment a site hides prices behind interactive date pickers, multi-step filters, or dynamic JavaScript carts. Pioneered by Google DeepMind in Google Labs and now powering Gemini Agent Mode and Chrome's agentic browsing across Google AI Ultra, Project Mariner gives Gemini eyes and hands inside a real browser.
  2. Accessing Mariner & Picking the Right Google Agent — What began as Google DeepMind's standalone labs.google/mariner research prototype has graduated across the entire Google AI Ultra suite—giving you priority cloud-browser concurrency wherever you work.
  3. Mission Control Workspace: Annotated Visual Tour — Unlike black-box automation tools that hide what they are doing until something goes wrong, Mariner shows every click, scroll, and thought in real time. Master these 7 controls to steer like a fleet captain.
  4. Scaling Yourself: 10 Parallel Cloud Virtual Browsers — Early computer-use tools hijacked your physical cursor—forcing you to sit with your hands off the keyboard while the AI clicked slowly. Project Mariner runs inside Google Cloud Virtual Machines, freeing your computer completely.
  5. The 5-Part Project Mariner Mission Formula — Prompting a browser agent is different from prompting a chatbot. Ambiguous instructions cause agents to wander across 30 tabs; crisp boundaries turn Mariner into a laser-focused executive assistant.
  6. Teach & Repeat + Human-in-the-Loop Safety Gates — Every industry has quirky internal portals, multi-level dropdowns, or custom formatting habits that take 300 words to explain—but only 30 seconds to show. That is why Mariner introduced Teach and Repeat alongside strict confirmation gates.
  7. Gemini Agent Mode: Everyday Life Admin on Autopilot — Inside gemini.google.com, Agent Mode fuses Project Mariner's live web navigation with Gemini's multimodal vision and your connected Google Workspace apps (Calendar, Gmail, Maps, Keep, and Docs).
  8. 5 High-ROI Workflows Ready to Copy & Run — The best Mariner tasks share one trait: high tab-switching drudgery for humans, clear structured outputs at the finish line. Start with any of these five battle-tested playbooks.
  9. Security, Privacy & Smart Delegation Habits — Giving an AI agent a live browser requires thoughtful guardrails. Google engineered Mariner around isolated virtual machines, prompt-injection defenses, and strict human confirmation—here is how to stay 100% safe.
  10. Power Pipelines & Building Custom Mariner Agents — Project Mariner shines brightest as the live web sensor at the front of your Google AI Ultra stack—feeding fresh, real-world data straight into Sheets, NotebookLM, Opal, and Antigravity.
  11. Troubleshooting Clinic & Pre-Flight Cheat Sheet — Live websites throw curveballs—CAPTCHA walls, infinite-scroll traps, and regional popups. Keep these 7 instant fixes handy whenever an agent session stalls.

### Antigravity 2.0 Customizations, Skills & Swarms

> Tailor Google Antigravity 2.0, IDE, CLI (agy), and Python SDK with progressive SKILL.md modules, AGENTS.md rules, lifecycle hooks.json, namespaced plugins, and message-board agent swarms.

- Web: https://twelve-pages.com/guides/google/antigravity-2-customizations-and-swarms
- Markdown: https://twelve-pages.com/guides/google/antigravity-2-customizations-and-swarms.md
- PDF: https://twelve-pages.com/guides/google/antigravity-2-customizations-and-swarms/Antigravity_2_Customizations_and_Swarms_Complete_How_To_Guide.pdf (3.2 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: 5-Tier Loading Priority, Progressive SKILL.md, 6-Event Lifecycle Hooks, JSONC Plugins & MCP, Parallel #channel Swarms, agy CLI & Python SDK
- Core Takeaways:
  - Zero-Bloat Progressive Context: Keep token windows lean with metadata-first skills, walk-up directory rules, and deterministic 5-tier precedence across every workspace.
  - Event-Driven Guardrails & Bundles: Intercept tool calls with camelCase lifecycle hooks and ship cohesive plugins uniting rules, skills, hooks, and namespaced MCP servers.
  - Parallel Multi-Agent Swarms: Coordinate isolated worktree authors, dedicated verifiers, stall monitors, and scoped channels from one shared message board.
- Chapters:
  1. One Portable Customization Layer Across Four Surfaces — Every project carries unwritten habits—naming rules, release checklists, safety boundaries, and favorite internal tools. Antigravity turns those habits into portable files that travel seamlessly across the desktop app, editor, terminal, and Python pipelines.
  2. 5-Tier Loading Priority & Surface Decision Matrix — When multiple skills, rules, or plugins share a name, Antigravity resolves collisions deterministically. Higher tiers override lower ones, while resolved-path deduplication guarantees no rule file is ever injected twice in the same turn.
  3. Annotated Tour: Inside the Antigravity 2.0 Workspace — Antigravity 2.0 pairs a workspace-aware sidebar on the left, a context-rich chat canvas and live Swarm Board in the center, and an HTML Auxiliary Pane on the right that tracks live subagents, files, and terminals.
  4. Progressive Disclosure: Skills & Hierarchical Rules — Stuffing 40 runbooks into every prompt ruins reasoning accuracy and burns tokens. Antigravity solves this with progressive disclosure: lightweight signposts sit in memory at startup, while heavy procedures open only when the task calls for them.
  5. Lifecycle Hooks & Color-Coded Config Anatomy — Rules advise the model politely; hooks enforce behavior in code. Placed in hooks.json at your customization or plugin root, synchronous type: "command" scripts receive camelCase protojson on stdin and steer execution on stdout.
  6. Plugins Packaging & Safe Registry Operations — When a workflow combines a skill, an always-on rule, a safety hook, and an MCP server, package them into a plugin at ~/.gemini/config/plugins/<name>/ (or .agents/plugins/<name>/) so teams can install or toggle the whole stack at once.
  7. Native Agent Swarms & Parallel Topologies — When work splits cleanly into independent files or questions, a swarm spawns dedicated worker agents—each in its own fresh conversation—coordinating through one shared message board while you stay responsive as coordinator.
  8. 5 Real-World Copy-Paste Configuration Recipes — Drop these five tested patterns straight into .agents/, ~/.gemini/config/plugins/, your coordinator prompt, or a Python automation script to stand up reliable workflows in minutes.
  9. Permissions, Sandboxing & Python SDK Governance — Autonomous agents and multi-worker swarms move fast, so clear permission boundaries matter. Antigravity layers global security defaults, per-project overrides, OS sandboxes, and least-privilege SDK capabilities so speed never compromises safety.
  10. Cross-Tool Synergy: Full 4-Stage Engineering Pipeline — Each Antigravity primitive shines individually, yet their real leverage appears when chained together: lightweight rules frame context, hooks and plugins guard execution, a channel-scoped swarm builds in parallel, and a verifier signs off before commit.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Most customization and swarm glitches stem from seven predictable gotchas—broken link keys, unfiltered RPC responses, hook casing mismatches, or noisy board channels. Spot the symptom below and apply the 10-second fix.

### Gemini 3.8 Live & Omni 1.2 Flash Studio

> Build low-latency bidirectional voice/vision agents with Gemini 3.8 Live (Extended Thinking, NON_BLOCKING tools, Live Translate) and multi-shot 4K generative video workflows with Gemini Omni 1.2 Flash.

- Web: https://twelve-pages.com/guides/google/gemini-live-and-omni-flash
- Markdown: https://twelve-pages.com/guides/google/gemini-live-and-omni-flash.md
- PDF: https://twelve-pages.com/guides/google/gemini-live-and-omni-flash/Gemini_Live_and_Omni_Flash_Complete_How_To_Guide.pdf (3.8 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: gemini-3.8-live & Extended Thinking, Hybrid VAD & 70+ Language Translate, gemini-omni-1.2-flash (360p–4K), Natural-Language Media Binding, 6 Image Refs & 30s Extensions, Ephemeral Tokens & WebRTC Bridges
- Core Takeaways:
  - Zero-Lag Duplex Voice & Vision: Stream 16kHz PCM audio and JPEG video frames bidirectionally while Extended Thinking speaks natural fillers during async tool calls.
  - Stateful 4K Cinema Studio: Generate 3s–15s clips, interpolate keyframes, strip and regenerate scores, or extend scenes to 30 seconds over the Interactions API.
  - Production-Hardened SDKs: Build securely on google-genai >= 2.30.1 and @google/genai >= 2.29.1 with resumption tokens and WebRTC partners.
- Chapters:
  1. Two Engines, One Unified SDK Mental Model — Modern multimodal apps split cleanly into two complementary rhythms: an always-open WebSocket conduit for sub-second human conversation, and a stateful Interactions loop for asynchronous 4K video creation and multi-turn refinement.
  2. SDK Installation, Model Matrix & Media Specifications — Every workflow in this guide runs on the unified late-2026 Google GenAI SDKs. Install the current packages below so typed Interactions steps, output_video helpers, and 3.8 Live fields work out of the box.
  3. The Live & Omni Studio Cockpit: 7 Key Controls — Whether you run a custom web workbench or terminal pipeline, every production deployment wires together these seven live-stream and asynchronous cinema controls.
  4. Duplex Streaming & Background Extended Thinking — Gemini 3.8 Live separates real-time conversational flow from deep problem-solving. While gemini-3.8-live replies instantaneously, gemini-3.8-live-extended-thinking reasons quietly in the background and speaks natural fillers while async tools execute.
  5. Live Transcribe, 70+ Language Translate & Prompt Anatomy — Beyond open-ended assistants, the Live API includes dedicated low-latency models for streaming captions and simultaneous interpretation—plus turnkey WebRTC partners for browser and telephony apps.
  6. Gemini Omni 1.2 Flash: Interactions API & Keyframes — Every gemini-omni-1.2-flash creation runs through client.interactions.create, pairing uploaded Files API assets with natural-language directions to render 3s–15s videos from scratch or between exact keyframes.
  7. Reference Binding, Surgical Edits & 30-Second Extensions — Omni 1.2 Flash abandons rigid XML markup in favor of natural-language asset binding—letting you guide characters with up to 6 reference images, refine existing clips, strip audio for new scores, and extend stories to 30 seconds.
  8. 5 Real-World Copy-Paste Production Recipes — Drop these five proven patterns directly into your Python, TypeScript, or CLI pipelines—each tuned to late-2026 SDK signatures and safe parameter limits.
  9. Production Session Hardening, Tokens & Regional Guardrails — Demo scripts run for 30 seconds; production apps stay connected for hours from untrusted browsers. Use these four guardrails to eliminate dropped calls, context limits, and leaked API keys.
  10. End-to-End Studio: Live Voice Director to 4K Omni Master — Combine Gemini's multimodal lineup into a single automated production house—from live spoken creative direction and bespoke Nano Banana 2.1 keyframes to 4K Omni cinema, expressive TTS voiceover, and WebRTC preview.
  11. Troubleshooting Clinic (Top 7 Fixes) & Pre-Flight Checklist — Bookmark this final page. Almost every runtime error in Live streaming or Omni video creation traces back to one of these seven protocol mismatches.

### Agentic Firebase & Android CLI Workflows

> Ship full-stack mobile and web apps with firebase-tools MCP, Firebase AI Logic + App Check, Data Connect, Android CLI, live Device Hub mirroring, Compose Preview sidecars, and XML Journey tests.

- Web: https://twelve-pages.com/guides/google/agentic-firebase-and-android-cli
- Markdown: https://twelve-pages.com/guides/google/agentic-firebase-and-android-cli.md
- PDF: https://twelve-pages.com/guides/google/agentic-firebase-and-android-cli/Agentic_Firebase_and_Android_CLI_Complete_How_To_Guide.pdf (2.2 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Firebase MCP & Agent Skills, Gemini 3.8 Flash & Live, Play Integrity App Check, android CLI & Delta Builds, Compose Preview Sidecar, Device Hub & XML Journeys
- Core Takeaways:
  - Cloud-to-Code Backend: Query Firestore, inspect Data Connect GraphQL, and diagnose App Hosting logs safely via scoped firebase mcp.
  - Protected Gemini 3.8 Apps: Ship Android Kotlin experiences on gemini-3.8-flash and gemini-3.8-live gated by Firebase App Check.
  - Closed-Loop Device QA: Audit Compose bounds_url trees, stream AVDs in Device Hub, and run strict sequential XML <journey> tests.
- Chapters:
  1. The Full-Stack Mental Model: Cloud Meets Pixels — Modern mobile agents no longer stop at writing Kotlin files in the dark. By pairing Firebase MCP on the cloud side with the android CLI and its live UI sidecars on the device side, an agent can verify schemas, builds, Compose bounds, and tap-by-tap user journeys in one continuous loop.
  2. Installation, Auth & Backend-to-Device Matrix — Set up both toolchains in under three minutes. Keep Firebase MCP tightly scoped per project directory while initializing the android CLI globally for fast SDK, emulator, and Studio access.
  3. Annotated Android Device Hub & Compose Preview Cockpit — When both Android sidecar plugins run alongside your terminal, you get instant pixel feedback in the IDE while your agent inspects exact coordinates, composable bounds, and incremental layout diffs over loopback HTTP and CLI.
  4. Firebase MCP: Inspecting Live Cloud State & Rules — Running firebase-tools@latest mcp gives your coding agent a live, least-privilege window into your Firebase backend—so database schemas, Security Rules, GraphQL operations, and deploy logs stay aligned with your Android client.
  5. Firebase AI Logic + App Check: Kotlin & Prompt Anatomy — Firebase AI Logic lets your Android app invoke Gemini directly from Kotlin without standing up a custom proxy server—while Firebase App Check proves every request originates from your genuine app binary.
  6. android CLI Mastery & Compose Preview Sidecar Loop — Replace slow trial-and-error Gradle cycles with fast delta deployments, live Android Knowledge Base queries, and headless Compose Preview rendering that exposes every composable's coordinates and accessibility semantics.
  7. Device Hub Sidecar, Visual Targeting & XML Journeys — Previews confirm static layout; real journeys prove behavior. Combine the Device Hub sidecar and android emulator CLI with JSON-first inspection, visual box resolution, and strict sequential XML journey scripts.
  8. 5 Real-World Copy-Paste Recipes — Drop these five battle-tested command and code recipes straight into your terminal, Gradle config, or agent prompt to eliminate repetitive boilerplate.
  9. App Check Enforcements, Least-Privilege MCP & Fleet Ops — Production AI mobile apps require tight boundaries at every hop—limiting what your coding agent can mutate in Firebase, proving app identity at runtime, and testing safely across remote hardware.
  10. Cross-Tool Synergy: From Cloud Schema to Verified APK — Watch how all four toolchains interlock in a single sprint—passing validated schemas, protected Gemini 3.8 clients, accessibility-checked Compose trees, and sequential XML journey reports cleanly from stage to stage.
  11. Troubleshooting Clinic & 6-Point Pre-Flight Checklist — Hit a blank pane, dropped Live session, or misbehaving ADB command? Match your symptom below for a 10-second root-cause fix.

## Anthropic Claude & Workspace Studios (15 Handbooks)

Topic Hub: https://twelve-pages.com/topics/claude

Publication-grade 12-page visual handbooks for Anthropic's agentic coding, autonomous digital coworker, security, and collaborative workspace suite—covering Claude Meetings, Duet, Design, Whiteboards, Sheets, Dashboards & Data, Cowork & Computer Use, Skills, Claude Code Mods, Autonomous Loops, Code Projects & Coordinator, Channels & Remote Control, Claude in Chrome & Persistent Memory, Security & Mythos 5.2, and Managed Agents & MCP.

### Claude Code Mods

> Customizing Claude Code from the inside with in-process TypeScript/JavaScript mods—building live terminal HUDs, prompt/tool interceptors, custom slash commands, and sec-default guardrails.

- Web: https://twelve-pages.com/guides/claude/claude-code-mods
- Markdown: https://twelve-pages.com/guides/claude/claude-code-mods.md
- PDF: https://twelve-pages.com/guides/claude/claude-code-mods/Claude_Code_Mods_Complete_How_To_Guide.pdf (3.3 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: In-Process TS/JS Engine, register(on, options), Before / After / Around Hooks, Custom Terminal & App HUDs, Hot-Reload dev-mods, sec-default Governance
- Core Takeaways:
  - Middleware Agent Control: Intercept, rewrite, time, or short-circuit prompts and tool calls in memory via Express-style ($, e, next) pipelines.
  - Programmable Terminal UI: Mount live token gauges, cache TTL timers, and side panes across both the CLI and Claude Code Desktop using ui.render.
  - Zero-Restart Hot Reload: Describe a workflow tweak in plain English and watch Claude Code build and hot-reload session dev-mods instantaneously.
- Chapters:
  1. Why Claude Code Mods Change Everything — Classic shell hooks spawn slow external subprocesses that can only say yes or no, while MCP servers sit outside the agent waiting to be called. Claude Code Mods run inside the live process as native TypeScript and JavaScript middleware—letting you reshape prompts, rewrite tool calls, and paint custom UI frames at sub-millisecond speed.
  2. Prerequisites, File Layout & Extension Matrix — A Claude Code Mod is simply a standard Claude Code plugin whose hooks/hooks.json declares a "modules" array. There is no build step, bundler, or tsconfig.json required—Claude Code compiles and validates your TypeScript natively at load time.
  3. Annotated Tour: Mod-Enhanced Claude Code Cockpit — Mods transform Claude Code from a scrolling text stream into an instrumented cockpit. Below are the seven live touchpoints where TypeScript mods render telemetry, intercept risky commands, and expose instant local controls.
  4. Anatomy of a Mod: register(on, options) — Every mod exports a single register(on, options) function. Using on(eventName, filter, handler), your handler receives ($, e, next)—giving you four clean middleware patterns: before, instead of, after, and around.
  5. The Mods API ($), Zero-NPM Rule & /commands — Inside a mod, standard Node globals like require('fs'), process.env, and external npm packages are intentionally off-limits. Instead, every host action flows through the structured $ Mods API so Claude Code can statically audit what a plugin touches before it ever runs.
  6. “Vibe-Modding”: Live Hot-Reload Without TypeScript Mastery — You never have to memorize event schemas to build a mod. Describe the behavior you want in plain English right inside an active Claude Code session: Claude writes the TypeScript into ~/.claude/dev-mods/<session-id>/, validates it, and hot-reloads it on save with zero restart.
  7. Customizing the UI: HUDs, Gauges & Custom Panels — Unlike external CLI wrappers, a single ui.render handler renders seamlessly in both the terminal TUI and the Claude Code Desktop app—using declarative layout primitives (box, row, text, badge, progress) instead of brittle ANSI escape codes.
  8. 5 Real-World Copy-Paste Mod Recipes — Paste any prompt below directly into Claude Code to generate and hot-load the mod inside ~/.claude/dev-mods/ in under a minute—then promote your favorites to ~/.claude/plugins/.
  9. Security, Load Order & sec-default Governance — Understanding one architectural truth prevents serious security mistakes: Claude Code Mods run in-process with your full OS user privileges—they are capability-audited via $, not isolated inside a hypervisor VM.
  10. Cross-Tool Synergy: The 4-Layer Agent Stack — Mods do not replace Skills, MCP servers, or Git worktrees—they complete the stack by supplying the missing deterministic runtime layer that keeps autonomous multi-agent coding fast, visible, and safe.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Ninety-five percent of mod hiccups trace back to one of seven predictable causes. Use this table for ten-second fixes before shipping a mod to your daily workflow or team repository.

### Claude Whiteboards

> Turning messy voice and text brainstorms into real-time multiplayer visual canvases—mastering region-box prompting, retro clustering, Doc/Slide handoffs, and Miro/Lucid exports.

- Web: https://twelve-pages.com/guides/claude/claude-whiteboards
- Markdown: https://twelve-pages.com/guides/claude/claude-whiteboards.md
- PDF: https://twelve-pages.com/guides/claude/claude-whiteboards/Claude_Whiteboards_Complete_How_To_Guide.pdf (3.3 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Voice-to-Board Structuring, Region-Box AI Prompting, Real-Time Multiplayer, Retro & Theme Clustering, 1-Click Doc & Slide Handoff, Miro, Lucid & Vani Export
- Core Takeaways:
  - Win the First 30 Minutes: Speak a rambling product monologue or drop 80 raw sticky notes and watch Claude organize clean swimlanes, owners, and themes in seconds.
  - Surgical Region Edits: Drag a selection box around any messy corner of a massive board to expand sub-flows or assign dates without disturbing surrounding work.
  - Zero-Copy-Paste Handoffs: Turn finished spatial boards directly into polished Claude Docs, executive Slide Decks, or editable Lucid, Miro, and Zoho Vani canvases.
- Chapters:
  1. Conquering the “Messy First 30 Minutes” of Team Work — Traditional diagramming tools assume you already know which boxes and arrows belong on the screen, leaving teams staring at an intimidating blank grid. Anthropic built Claude Whiteboards as an AI-native, multiplayer thinking canvas inside the Artifacts studio—where raw human thought meets live spatial structure.
  2. Plans, Activation & Visual Workspace Decision Matrix — Claude Whiteboards runs as an interactive spatial Artifact across web (claude.ai), Claude Desktop (macOS and Windows), and mobile apps—with distinct default switches depending on your subscription tier.
  3. Annotated Tour: Inside the Claude Whiteboards Studio — Opening a Whiteboard splits your Claude window into a conversational steering column on the left and an infinite, zoomable multiplayer canvas on the right—keeping dialogue and spatial layout synchronized.
  4. Voice & Text Brain Dumps to Structured Swimlanes — The fastest way to build a complex whiteboard is not touching your mouse at all. Speak out loud for three minutes—backtracking, correcting dates, and thinking on your feet—and let Claude untangle the chronology into crisp spatial swimlanes.
  5. Surgical Region-Box Prompting & Spatial Anatomy — Early AI diagram tools suffered from a maddening flaw: asking the AI to tweak three nodes triggered a full-board regeneration that scrambled everything your team spent twenty minutes arranging. Region-Box Prompting solves this permanently.
  6. Running Live Multiplayer Workshops & Retrospectives — In a standard 45-minute sprint retrospective, teams burn 25 minutes silently typing stickies and dragging similar cards into piles—leaving barely 10 minutes to solve actual problems. Multiplayer Claude Whiteboards compresses sorting to 20 seconds.
  7. Downstream Handoffs: Docs, Slides, Miro & Lucid — Most brainstorm boards die five minutes after the Zoom call ends because nobody wants to spend Friday afternoon re-typing 60 sticky notes into a PRD, slide deck, or architecture tool. Claude Whiteboards turns spatial consensus directly into deliverables.
  8. 5 Real-World Copy-Paste Whiteboard Recipes — Paste any recipe below into a Claude chat or active Claude Project (or pair it with a voice brain dump or lassoed region) to produce clean, executive-ready spatial canvases immediately.
  9. Team Permissions, Governance & Version Checkpoints — Early-stage strategy boards often contain unannounced product roadmaps, M&A evaluations, or security architecture gaps. Understanding workspace visibility boundaries, external export policies, and version history keeps sensitive canvases safe.
  10. Cross-Tool Synergy: From Call Transcript to Shipped Code — Claude Whiteboards shines brightest as the central spatial router connecting Anthropic’s broader workspace studio—bridging raw discovery in Claude Projects straight into Claude Sheets, Claude Docs, Lucid/Miro, and Claude Code.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Use this quick diagnostic clinic whenever a layout shifts unexpectedly, an enterprise button is hidden, or a large team workshop feels crowded—followed by our 6-point facilitator checklist.

### Claude Dashboards & Data

> Connecting warehouses and CRMs to natural-language analytics—building auditable SQL charts, Certified Queries, Scrollytellers, Visual Shorts, and credential-safe live team shares.

- Web: https://twelve-pages.com/guides/claude/claude-dashboards-and-data
- Markdown: https://twelve-pages.com/guides/claude/claude-dashboards-and-data.md
- PDF: https://twelve-pages.com/guides/claude/claude-dashboards-and-data/Claude_Dashboards_and_Data_Complete_How_To_Guide.pdf (3.6 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Snowflake • BigQuery • Redshift, ClickHouse • Databricks • CRM, Auditable SQL & Timestamps, Certified Queries, Scrollytellers & Visual Shorts, Credential-Safe Live Sharing
- Core Takeaways:
  - Plain English to Live SQL: Ask business questions in natural language while Claude inspects warehouse schemas, executes real SQL, and renders interactive charts.
  - 100% Auditable Metrics: Every tile exposes its exact SQL query, refresh timestamp, and Certified Query badge so numbers never drift across teams.
  - Dashboards to Data Stories: Turn any live board into a scrolling narrative Scrollyteller, a narrated Visual Short, or a governed BI workbook in one prompt.
- Chapters:
  1. From Claude Dashboards to Claude Data — Traditional self-serve business intelligence either traps business teams in multi-week ticket queues or lets unvetted AI prompts invent conflicting SQL numbers. Claude Data (introduced in beta as Claude Dashboards) bridges that gap by pairing conversational warehouse exploration with auditable SQL, semantic governance, and narrative storytelling formats.
  2. Plans, Connectors & Output Format Decision Matrix — Claude Data runs across paid Claude tiers while scaling governance controls for multi-team organizations. Matching the right connection pattern and output format upfront saves hours of rework.
  3. Annotated Tour: Claude Data & Dashboard Studio — Claude Data splits your workspace into a conversational analyst thread on the left and a live, auditable artifact canvas on the right—complete with interactive filters, Certified Query badges, SQL inspection, and credential-safe sharing.
  4. Connecting Warehouses, Semantic Layers & Auditable SQL — Great natural-language analytics starts before the first prompt. Pointing Claude Data at clean analytical schemas and semantic MCP layers eliminates messy raw-table guesswork and sluggish full-table scans.
  5. Iterative Dashboard Building & Analytics Prompt Anatomy — The fastest analysts never ask for a 12-chart mega-dashboard on Turn 1. They validate grain and totals first, assemble interactive tiles on Turn 2, and layer controls and anomaly annotations on Turn 3.
  6. Certified Queries: Ending “Two Numbers for Revenue” — Every fast-growing company hits the same analytics failure mode: Marketing presents $51.2M ARR at 9:00 AM, Finance presents $48.6M ARR at 9:15 AM, and the meeting derails into debugging SQL filters. Certified Queries solve this permanently inside Claude Data.
  7. Beyond Charts: Scrollytellers, Visual Shorts & BI Handoffs — Dashboards answer what happened for people who already know where to look. Narrative formats—Scrollytellers and Visual Shorts—align busy executives in two minutes without sacrificing warehouse rigor.
  8. 5 Real-World Copy-Paste Claude Data & Dashboard Recipes — Adapt the schema or semantic metric names in brackets and paste these prompts straight into Claude Data. Every recipe enforces UTC boundaries, clean exclusions, and SQL auditability.
  9. Credential-Safe Live Sharing & Enterprise Governance — Historically, sharing a live AI-generated chart meant either sending dead screenshots or dangerously handing out shared database service-account keys. Claude Data’s Live Sharing architecture separates viewing approved visuals from holding raw database credentials.
  10. Cross-Tool Synergy Pipeline Across Your Stack — Claude Data shines brightest as the connective hub of a quarterly planning loop—pulling governed warehouse truth upstream and feeding financial scenario models, strategy whiteboards, executive stories, and deep Python notebooks downstream.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Almost every natural-language analytics hiccup comes down to timezone cutoffs, join cardinality, partition filters, or intentional credential boundaries. Keep this page handy before publishing any board.

### Claude Skills

> Packaging reusable domain expertise across Claude.ai, Claude Desktop, and Claude Code—mastering 3-tier progressive disclosure, SKILL.md anatomy, skill-creator, and executable scripts.

- Web: https://twelve-pages.com/guides/claude/claude-skills
- Markdown: https://twelve-pages.com/guides/claude/claude-skills.md
- PDF: https://twelve-pages.com/guides/claude/claude-skills/Claude_Skills_Complete_How_To_Guide.pdf (2.8 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: 3-Tier Progressive Disclosure, SKILL.md Open Format, Claude.ai • Desktop • Code, skill-creator Meta-Skill, Bundled Python & Bash Scripts, pptx • xlsx • docx • pdf
- Core Takeaways:
  - Zero Context Bloat: Preload ~50–100 tokens of YAML metadata per skill so Claude carries 100+ capabilities without slowing down.
  - Write Once, Run Everywhere: One portable SKILL.md folder runs across Claude.ai, Claude Desktop, Cowork, Claude Code, and the Messages API.
  - Deterministic Script Execution: Offload fragile math, schema linting, and document checks into bundled Python and Bash scripts inside secure sandboxes.
- Chapters:
  1. Solving Context Window Bloat Forever — Pasting giant SOP manuals into every system prompt wastes thousands of tokens and dilutes Claude’s attention. Anthropic’s 3-Tier Progressive Disclosure lets Claude keep 100+ specialized skills on standby at a ~50-token idle cost—opening full instructions and scripts only when needed.
  2. Cross-Surface Setup & Customization Matrix — Anthropic designed SKILL.md as an open, portable standard. Activating Skills takes under a minute in Claude.ai or Claude Desktop and zero configuration on disk inside Claude Code.
  3. Annotated Tour: Claude Skills Studio & Folder Tree — Whether a skill is uploaded as a .zip in Claude.ai or placed inside .claude/skills/ in Claude Code, the exact same runtime handshake unfolds: toggle capabilities, match YAML frontmatter, read SKILL.md, and execute scripts.
  4. Anatomy of a Skill Folder & Trigger Engineering — Until a skill is triggered, Claude cannot see a single line of its Markdown body or scripts—only its YAML name and description. Writing razor-sharp frontmatter is the highest-leverage habit in skill authoring.
  5. Lean <500-Line Bodies & Executable Scripts — Once triggered, SKILL.md competes directly with your conversation and code files for attention. Keep SKILL.md crisp, imperative, and under 500 lines—delegating reference tables to references/ and brittle checks to scripts/.
  6. Iterating With skill-creator & .zip Packaging — Instead of hand-writing boilerplate from scratch, invoke Anthropic’s built-in skill-creator skill. It interviews you, turns messy chat breakthroughs into clean folders, benchmarks trigger accuracy, and packages valid .zip uploads.
  7. Document Skills & Multi-Skill Composition — You never have to choose just one active skill per turn. Claude automatically composes your custom brand or analytics skills alongside Anthropic’s four built-in Office document skills—delivering studio-grade files across every Claude surface.
  8. 5 Real-World Copy-Paste SKILL.md Blueprints — Use these five high-leverage blueprints as templates for your own organization. Notice how each pairs a trigger-rich YAML description with lean instructions and a deterministic Level 3 script or reference file.
  9. Team Distribution, Security Auditing & Governance — Once a skill saves you an hour a week, multiplying that leverage across your team takes clean distribution channels—paired with disciplined security review whenever importing external skills.
  10. Cross-Tool Synergy: MCP + Skills + Sandbox — MCP Servers and Claude Skills solve opposite halves of enterprise AI: MCP gives Claude live, authenticated hands into your systems, while Skills teach Claude your team’s institutional playbook for turning that raw data into finished work.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Nearly every skill issue comes down to YAML trigger phrasing, archive folder nesting, or sandbox toggles. Keep this page beside you when shipping or debugging any custom skill.

### Claude Cowork & Computer Use

> Automating multi-step knowledge work across Desktop, Web, and Mobile—mastering background macOS Computer Use, built-in browser tasks, recurring /schedule runs, and SaaS connectors.

- Web: https://twelve-pages.com/guides/claude/claude-cowork-and-computer-use
- Markdown: https://twelve-pages.com/guides/claude/claude-cowork-and-computer-use.md
- PDF: https://twelve-pages.com/guides/claude/claude-cowork-and-computer-use/Claude_Cowork_and_Computer_Use_Complete_How_To_Guide.pdf (2.9 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: One Claude Unified Recents, 3-Tier Execution Routing, Background macOS Spaces, Scoped Local Folder Mounts, Cloud & Chrome Schedules, Human-in-the-Loop Gates
- Core Takeaways:
  - Start Anywhere, Continue Everywhere: Kick off a task on Claude Desktop, monitor live progress from iOS or Android on your commute, and review results in one unified Recents list.
  - Keep Your Cursor Free: Background Computer Use operates inside an isolated macOS Space behind the scenes—auto-pausing cleanly if you ever step into that window.
  - Fastest Tool First, Safe by Design: Claude routes through direct MCP APIs first, built-in browser second, and desktop UI clicks last—pausing for approval before payments or sends.
- Chapters:
  1. The “One Claude” Mental Model & Execution Routing — Instead of treating chat, browser automation, and desktop control as separate apps, Anthropic unified them into One Claude. Whether you open Claude Desktop on macOS, claude.ai on the web, or the iOS/Android mobile app, every Cowork task lives inside one synchronized Recents timeline backed by cloud remote sessions.
  2. Plan Tiers, macOS Grants & Ecosystem Decision Matrix — Cowork and Computer Use span Pro, Max, Team, and Enterprise subscriptions, pairing cloud remote execution with explicit, revocable macOS permissions whenever local files or desktop windows are involved.
  3. Annotated Tour: Inside the Claude Cowork Workspace — One unified window connects your cross-device Recents feed, active connector badges, scoped local folder mounts, live Background macOS Space previews, and human-in-the-loop safety gates.
  4. Mastering the 3-Tier Tool Hierarchy — Great Cowork operators think in layers. Rather than asking Claude to click around your screen for data that already lives behind a clean API, you guide workflows through a cascading waterfall: structured MCP pipes first, browser lenses second, and desktop pixels third.
  5. Prompt & Task Anatomy + Scoped Folder Mounts — Vague prompts like “clean up my invoices” invite guesswork. Combining five explicit building blocks—Goal, Scope, Connectors, Fallback, and Confirmation Gate—gives Claude crystal-clear guardrails on the very first run.
  6. Background macOS Computer Use Without Hijacking Your Mouse — Earlier desktop agents locked you out of your own Mac, yanking your mouse cursor across the screen every two seconds. Claude’s Background macOS Computer Use runs clicks, scrolling, and keystrokes inside a hidden Space while your active cursor stays completely yours.
  7. Two Recurring Engines: Cowork /schedule vs. Chrome Schedules — Once a manual workflow works reliably, promote it to autopilot. Anthropic gives you two distinct scheduling engines—knowing which one runs with your laptop lid closed and which one relies on your live browser cookies prevents missed morning runs.
  8. 5 Real-World Copy-Paste Cowork Recipes — Paste any recipe below directly into Claude Desktop or claude.ai. Each prompt names its exact connectors, folder bounds, fallback tier, and safety approval gate so you get repeatable results with zero surprises.
  9. Governance, Privacy & Human-in-the-Loop Safety Gates — Giving an AI agent access to your email, files, and desktop buttons demands clear boundaries. Anthropic pairs least-privilege folder mounts and macOS privacy switches with mandatory confirmation gates before irreversible actions occur.
  10. Cross-Tool Synergy: Automated Morning Briefing & Ops Loop — Cowork reaches its peak leverage when it acts as the conductor across Anthropic’s entire studio—combining MCP Connectors, Background Computer Use, Claude Skills, and Claude Sheets / Data into one seamless daily loop.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Use this diagnostic table whenever a macOS permission blocks a click, a scheduled task skips overnight, or Claude picks a slow UI route instead of an API—followed by our 6-point pre-flight checklist.

### Claude Sheets & Interactive Artifacts

> Building live multi-tab spreadsheets with cross-sheet formulas, dropdowns, charts, multiplayer edits, and .xlsx round-tripping alongside interactive MCP-connected Artifacts.

- Web: https://twelve-pages.com/guides/claude/claude-sheets-and-artifacts
- Markdown: https://twelve-pages.com/guides/claude/claude-sheets-and-artifacts.md
- PDF: https://twelve-pages.com/guides/claude/claude-sheets-and-artifacts/Claude_Sheets_and_Artifacts_Complete_How_To_Guide.pdf (2.9 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Multi-Tab Workbooks, Dynamic Excel Formulas, Live Cell-Outline Audit, Real-Time Multiplayer, MCP-Connected Artifacts, .xlsx & .csv Round-Trip
- Core Takeaways:
  - Live Formulas, Zero Guesswork: Build structured multi-tab spreadsheets powered by real SUMIFS, XLOOKUP, dropdowns, and conditional formatting—never static hardcoded totals.
  - Cell-by-Cell Transparency: Watch green live cell outlines trace every Claude edit as it lands while teammates co-edit simultaneously in shared spaces.
  - Sheets to Live Web Apps: Promote any model or workflow into an interactive web Artifact wired directly to live MCP connectors with viewer-scoped permissions.
- Chapters:
  1. The Artifacts Studio: Live Grids & Connected Apps — Old AI chat workflows forced you to copy raw tables out of a message bubble or settle for frozen static previews. Inside Claude’s Artifacts Studio—sitting alongside Claude Whiteboards and Claude Data—Claude Sheets gives you a live multiplayer workbook while Interactive Artifacts turn workflows into durable, MCP-connected web applications.
  2. Setup, Admin Controls & 4-Way Ecosystem Matrix — Claude Sheets and MCP-connected Interactive Artifacts ship across paid Claude plans. Turning on the right organization toggles upfront unlocks smooth saving, reopening, and team sharing.
  3. Annotated Tour: Claude Sheets Split-Screen Workspace — Claude Sheets pairs your conversational prompt thread on the left with a responsive, multiplayer spreadsheet canvas on the right—highlighting every formula and cell edit in real time.
  4. Multi-Tab Modeling, Formulas & Interactive Controls — A trustworthy workbook separates raw inputs from calculation logic and executive summaries. Claude Sheets natively writes cross-tab formulas, interactive cell controls, and live charts so changing one driver recalculates the entire model cleanly.
  5. Color-Coded Spreadsheet & Artifact Prompt Anatomy — Vague prompts like “make me a budget spreadsheet” tempt models to type static numbers into total rows. Specifying tabs, input validation, formula types, styling, and export rules upfront produces audit-ready workbooks on the first pass.
  6. Live Cell-Outline Audit & Real-Time Multiplayer — Traditional AI document tools overwrite an entire file behind a loading spinner, forcing you to hunt for what changed. Claude Sheets renders every edit live in front of you and supports simultaneous team co-editing.
  7. Interactive MCP-Connected Web Artifacts — Sometimes a spreadsheet grid isn’t enough—you want interactive sliders, custom buttons, or a live triage console. Modern Interactive Artifacts act as durable “thick artifacts” saved in your Artifacts library that rehydrate live state via MCP connectors.
  8. 5 Real-World Copy-Paste Sheets & Artifact Recipes — Swap the bracketed team names or connector targets and paste these blueprints straight into Claude. Each recipe enforces formula discipline, visual clarity, and clean downstream handoffs.
  9. Enterprise Governance, Export Fidelity & Round-Tripping — Shipping spreadsheets and live web apps inside a company requires clear admin guardrails, predictable .xlsx and .csv export fidelity, and knowing when to graduate heavy workbooks to dedicated Excel tooling.
  10. Cross-Tool Synergy Pipeline Across Your Workspace — Claude Sheets and Interactive Artifacts work best as the calculation and app layer between raw systems of record and final executive deliverables—connecting seamlessly with Claude Whiteboards, Claude Data, and Slide Decks.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Most spreadsheet and interactive Artifact hiccups trace back to static literal pastes, missing Excel formula anchors, flat CSV exports, or viewer MCP authentication boundaries. Keep this clinic nearby before sharing.

### Claude Code Autonomous Loops & Code Artifacts

> Running unattended multi-turn /goal completion contracts, supervising parallel sessions in claude agents, CLI-to-Desktop /resume, and publishing live PR walkthrough Artifacts.

- Web: https://twelve-pages.com/guides/claude/claude-code-autonomous-loops
- Markdown: https://twelve-pages.com/guides/claude/claude-code-autonomous-loops.md
- PDF: https://twelve-pages.com/guides/claude/claude-code-autonomous-loops/Claude_Code_Autonomous_Loops_Complete_How_To_Guide.pdf (2.5 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: /goal Evaluator Loops, Goal + Rider Specs, claude agents Fleet UI, /fork • /branch • /rewind, --worktree Isolation, Live Code Artifacts
- Core Takeaways:
  - Outcome-Driven Autonomy: Replace turn-by-turn babysitting with a /goal contract checked after every turn by an independent evaluator model.
  - Parallel Fleet Control: Dispatch isolated --worktree runs, monitor workers with claude agents, and jump into Desktop via /resume.
  - Live Shareable Proofs: Publish dynamic PR walkthroughs, diff maps, and release checklists directly to private claude.ai Code Artifacts.
- Chapters:
  1. From Chat Turns to Self-Verifying Engineering Loops — Traditional AI coding is conversational: you type a prompt, watch Claude edit three files, spot a failing test, and nudge it again. Autonomous Loops flip that rhythm—you define the finish line once with /goal, and an independent evaluator keeps Claude working until objective proof confirms the job is done.
  2. Prerequisites, Model Tiers & Command Matrix — Autonomous loops work out of the box across both the Claude Code CLI and Claude Code Desktop. Pairing isolated Git worktrees with right-sized model tiers and subagent definitions keeps multi-hour runs fast, affordable, and cleanly reversible.
  3. Annotated Tour: Fleet Dashboard & Desktop Review — Power users rarely babysit a single terminal prompt. Instead, they supervise parallel worktrees in claude agents and jump straight into Claude Code Desktop via /resume to inspect live diffs and loop telemetry.
  4. Engineering /goal Contracts & Goal + Rider Specs — A loop is only as sharp as its exit condition. Vague prompts like “improve performance” confuse the evaluator, whereas concrete contracts backed by a Goal + Rider Markdown pair power hours of disciplined, self-correcting work.
  5. Anatomy of a Bulletproof /goal & Rider Contract — Whether you write a one-line /goal command or a multi-phase Rider file, packing these five color-coded clauses eliminates drift, endless loops, and silent corner-cutting.
  6. Parallel Fleet Supervision & Safe Session Navigation — Long autonomous runs shine when you parallelize cleanly and recover fearlessly. Combining specialist .claude/agents/, /subtask, claude agents, and atomic /rewind lets one engineer direct an entire squad of isolated workers.
  7. Claude Code Artifacts: Live Shareable Engineering Output — When an autonomous loop finishes 400 lines of changes across twelve files, dumping a wall of Markdown into Slack wastes your team’s time. Claude Code Artifacts publish rich, interactive engineering pages directly from your session to private, live-updating claude.ai URLs.
  8. 5 Real-World Copy-Paste Loop & Fleet Recipes — Drop any recipe below into a fresh claude --worktree <branch> session. Each prompt pairs a verifiable exit gate with clear boundaries so the evaluator knows precisely when to advance or stop.
  9. Guardrails for Long-Running Autonomous Loops — Giving an agent thirty turns of autonomy demands engineering discipline. Without hard spend limits, isolated worktrees, and anti-cheating rules, an eager model can burn budget, mutate shared branches, or quiet a failing test by relaxing assertions.
  10. Cross-Tool Synergy: From Spec to Live PR Artifact — Autonomous loops shine brightest when every stage plays its natural role: Markdown specs anchor intent, isolated worktrees and specialist subagents execute safely, Desktop /resume speeds human review, and Code Artifacts communicate the result.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Almost every autonomous loop hiccup stems from ambiguous exit criteria, noisy context buildup, or missing environment isolation. Keep this ten-second triage table beside your terminal before kicking off unattended runs.

### Claude Managed Agents & MCP Connectors

> Connecting Remote HTTPS/SSE and local stdio MCP servers across Claude surfaces and self-hosting cma-server agent sandboxes with scoped OAuth and Bedrock/Vertex routing.

- Web: https://twelve-pages.com/guides/claude/claude-managed-agents-and-mcp
- Markdown: https://twelve-pages.com/guides/claude/claude-managed-agents-and-mcp.md
- PDF: https://twelve-pages.com/guides/claude/claude-managed-agents-and-mcp/Claude_Managed_Agents_and_MCP_Complete_How_To_Guide.pdf (2.8 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Brain / Hands Decoupling, Self-Hosted cma-server, Remote HTTPS/SSE /mcp, OAuth 2.1 & Secret Vaults, Bedrock • Vertex • Foundry, Zero-Secret Sandboxes
- Core Takeaways:
  - Zero DIY Harness Plumbing: Skip fragile custom retry loops—Managed Agents handle tool turns, streaming checkpoints, and durable state recovery out of the box.
  - Vault-Isolated Credentials: Store OAuth tokens and API keys inside server-side Vaults so sandboxed bash containers never touch raw secrets.
  - Cloud or VPC Sovereignty: Run on Anthropic’s managed cloud or self-host cma-server with PostgreSQL and route inference to Bedrock, Vertex, or Foundry.
- Chapters:
  1. Decoupling the Agent Brain From the Hands — Traditional agent scripts tangle LLM reasoning, state persistence, untrusted shell commands, and raw API keys inside one brittle process. Claude Managed Agents separate the stateful reasoning loop (“brain”) from disposable execution containers and authenticated remote /mcp connectors (“hands”).
  2. Prerequisites & Deployment Topology Matrix — Not every workflow needs a self-hosted cluster, and not every connector belongs on a developer laptop. Use the topology matrix below to pick the exact runtime and MCP transport that matches your security, reachability, and residency requirements.
  3. Annotated Tour: Connectors, Vaults & Session Monitor — Whether you register connectors in Claude Settings or orchestrate headless sessions via cma-server, four unified panels govern every run: the Remote /mcp registry, live session loop telemetry, the OAuth Vault broker, and per-tool read/write gates.
  4. Decoupling the Brain From the Hands — Building your own production agent loop looks simple on day one—until timeouts, partial tool errors, context compaction, and shell escapes break in production. Managed Agents separate the durable cognitive loop from isolated execution workspaces.
  5. Color-Coded Remote MCP & cma-server Anatomy — Managed Agents keep configuration cleanly partitioned: agent definitions declare endpoints and prompts, sessions bind runtime Vaults, and cma-server wires PostgreSQL persistence, model routing, and sandbox egress.
  6. Remote HTTPS/SSE Connectors & OAuth Vaults — Remote MCP moves integrations off local laptops onto standard https://.../mcp endpoints. Combined with OAuth 2.1 and Vaults, one connector works seamlessly across Claude Web, Mobile, Cowork, and headless Managed Agents.
  7. Self-Hosting cma-server in Your VPC — Regulated industries and teams with internal-only microservices can run the entire Managed Agents control plane inside their own Kubernetes cluster or VPC using cma-server—retaining 100% session sovereignty.
  8. 5 Real-World Managed Agent & MCP Blueprints — Use these five production blueprints as starting templates. Notice how every design isolates secrets in Vaults, trims exposed MCP tools to essentials, and pairs sandboxed execution with clear human approval boundaries.
  9. Security, Blast-Radius Containment & Schema Hygiene — Connecting autonomous agents to live company systems introduces two distinct risks: oversized blast radii if a tool mutates data unchecked, and indirect prompt injection hidden inside external tickets, PR comments, or database rows.
  10. Cross-Tool Synergy: Skills + Managed Agents + MCP — Claude Skills teach your team’s rules and formatting standards, cma-server orchestrates durable multi-turn loops, and Remote /mcp Connectors supply live authenticated data—producing verified Data and Code artifacts automatically.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Most Managed Agent and Remote MCP snags come from proxy buffering, OAuth redirect URIs, PgBouncer listener pooling, or bloated tool lists. Use this quick clinic to diagnose and resolve issues in seconds.

### Claude Meetings

> Turning live Google Meet calls into visible co-creation sessions—mastering calendar auto-join, external-guest guardrails, live Whiteboards, Docs & Sheets, Interactive Connectors, and the post-meeting claude.ai hub.

- Web: https://twelve-pages.com/guides/claude/claude-meetings
- Markdown: https://twelve-pages.com/guides/claude/claude-meetings.md
- PDF: https://twelve-pages.com/guides/claude/claude-meetings/Claude_Meetings_Complete_How_To_Guide.pdf (3.3 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Visible Google Meet Teammate, Auto-Join & 1:1 Skip Rules, External-Guest Guardrail, Spoken & Chat Execution, Live Artifacts & Connectors, Post-Meeting Hub & Sync
- Core Takeaways:
  - Build During the Call: Address Claude aloud or in Meet chat to draft Docs, Sheets, and Whiteboards live while teammates co-edit before anyone hangs up.
  - Zero-Stealth Trust: Appears openly in the attendee roster, posts a transparency notice in Meet chat, and auto-leaves if an unapproved external guest enters.
  - Every Call Becomes a Hub: Wraps every session into a dedicated claude.ai meeting page with transcript, owner action items, Artifacts, and partner syncs.
- Chapters:
  1. Moving From Passive Note-Taker to Live Call Teammate — Conventional meeting bots sit silently in the corner and email a generic summary twenty minutes after everyone has moved on—leaving your team with the actual documents, spreadsheets, and architecture boards still unbuilt. Claude Meetings flips the workflow inside out by acting as a visible, real-time workspace builder inside Google Meet.
  2. Plans, Beta Pricing, Setup & Meeting Tool Matrix — Launched in November 2026 beta exclusively for Claude Team and Claude Enterprise workspaces (not Free, Pro, or Max), Claude Meetings launches first on Google Meet with strict security and quota rules.
  3. Annotated Tour: Inside a Live Claude Meetings Session — When Claude enters your Google Meet call, the experience bridges the video call window and a shared claude.ai live workspace—keeping human voices, Meet chat answers, Artifacts, and Interactive Connectors synchronized in real time.
  4. Real-Time In-Call Execution: Build Work While You Talk — The signature breakthrough of Claude Meetings is closing the gap between talking and shipping. Instead of ending a 45-minute call with only a to-do list, your team leaves with the actual Whiteboard, PRD Doc, or financial Sheet drafted and reviewed together live.
  5. Joining Mechanics, Guest Guardrails & Prompt Anatomy — Knowing exactly when Claude enters, when it refuses or leaves, and how to phrase crisp mid-call prompts keeps every session predictable and clutter-free.
  6. Live CRM Lookups & Side-by-Side Interactive Connectors — Instead of pausing a decision while someone shares their screen to dig through five browser tabs, Claude Meetings pulls live numbers from your connected data warehouse and opens native Interactive Connectors (MCP Apps) right beside your call workspace.
  7. Post-Meeting claude.ai Hub & Transcript Ecosystem — The moment you hang up Google Meet, Claude Meetings automatically compiles every spoken detail and co-created deliverable onto one dedicated, internal claude.ai meeting page—while connecting cleanly with the transcript platforms your teams already run.
  8. 5 Real-World Copy-Paste Claude Meetings Recipes — Say any of these prompts aloud (starting clearly with “Claude, ...”), paste them into Google Meet chat mid-call, or run the final recipe inside your dedicated claude.ai meeting hub immediately after hanging up.
  9. Governance, Custom Roles & Security Boundaries — Live call transcription and CRM lookups touch sensitive company discussions. Anthropic enforces visible anti-stealth design, strict external-guest shutoffs, granular Enterprise custom roles, and clear beta exclusions for high-compliance workspaces.
  10. Cross-Tool Synergy: From Calendar Invite to Shipped Work — Claude Meetings acts as the live conversational front door to Anthropic’s workspace suite—connecting Google Calendar, live Google Meet co-editing, Interactive Connectors, the claude.ai post-meeting hub, partner intelligence platforms, and Claude Code.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Use this diagnostic clinic whenever Claude unexpectedly skips or leaves a Google Meet call, a connector quota warning appears, or an Enterprise toggle is hidden—followed by our 6-point meeting readiness checklist.

### Claude Duet

> Operating Anthropic's proactive Opus 5.5 cloud chief of staff—delivering Morning Briefs, persistent Cloud VM and headless browser sweeps, topic Channels, and Human-in-the-Loop approval gates.

- Web: https://twelve-pages.com/guides/claude/claude-duet
- Markdown: https://twelve-pages.com/guides/claude/claude-duet.md
- PDF: https://twelve-pages.com/guides/claude/claude-duet/Claude_Duet_Complete_How_To_Guide.pdf (3.2 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Proactive Morning Brief, Persistent Cloud VM & Browser, Claude Opus 5.5 Engine, 4-Tab Studio & Channels, Shared Memory & Skills, HITL Approval Gates
- Core Takeaways:
  - It Messages You First: Instead of waiting for prompts, Duet sweeps Gmail, Calendar, Slack, and connected apps every few hours and sends a concise Morning Brief of real decisions.
  - Works While Your Laptop Sleeps: Every task executes inside an isolated Cloud VM with a headless browser on Anthropic servers—finishing deep research or financial forecasts with your phone powered off.
  - Autonomous Read, Gated Write: Duet researches, models, and drafts freely overnight, yet hard-stops behind an Approval Gate with full payload previews before sending, paying, signing, or deleting.
- Chapters:
  1. From Reactive Chat to an Always-On Cloud Chief of Staff — Traditional AI chat sits completely silent until you open a browser tab and type a prompt. Launched on October 21, 2026 as a research preview powered by Claude Opus 5.5, Claude Duet flips that relationship upside down: it monitors your connected tools asynchronously in the cloud and reaches out only when something genuinely deserves your judgment.
  2. Plans, Usage Quotas & Ecosystem Decision Matrix — Claude Duet debuted on October 21, 2026 as a US waitlist research preview across standalone iOS, Android, and web (claude.ai)—drawing directly from your subscription’s unified model usage pool at no extra monthly fee.
  3. Annotated Tour: Inside the Claude Duet Studio — Whether opened on iOS, Android, or claude.ai, Claude Duet organizes proactive intelligence across four clean workspace tabs alongside dedicated Channels and an unmistakable Human-in-the-Loop Approval Gate.
  4. Mastering the Morning Brief & Overnight Sweeps — Most professionals start their morning drowning in 90 unread emails, 14 Slack channels, and double-booked calendar invites. Duet’s Morning Brief (Claude Digest) clears that clutter before your alarm rings—handing you only high-leverage choices with replies already written.
  5. Cloud VM, Headless Browser & Routine Prompt Anatomy — Unlike mobile chat wrappers that pause the moment your screen dims, Claude Duet commands an isolated Cloud Virtual Machine with a built-in headless cloud browser and execution sandbox—turning multi-hour research and modeling into async background jobs.
  6. Organizing Work Into Channels With Unified Memory & Skills — Asking one continuous chat thread to manage payroll, executive hiring, and a product launch quickly creates mental whiplash. Duet’s Channels separate workstreams into clean, purpose-built rooms while sharing one unified Claude Memory and Skills brain underneath.
  7. The Human-in-the-Loop (HITL) Approval Gate — Proactive autonomy only earns trust when an agent knows exactly where preparation stops and irreversible action begins. Claude Duet enforces a hard architectural boundary between autonomous background prep and external state-changing writes.
  8. 5 Real-World Copy-Paste Claude Duet Recipes — Drop any of these production-ready blueprints into a dedicated Duet Channel or the Make tab. Each recipe pairs tight connector boundaries with a concrete Make deliverable and explicit Approval Gate pause.
  9. Security Boundaries, Privacy & Research Preview Governance — Granting an always-on cloud agent access to email, calendars, and financial tools demands rigorous engineering safeguards—and honest clarity about which compliance controls exist today during the Research Preview versus commercial Team and Enterprise plans.
  10. Cross-Tool Synergy: From Duet Morning Brief to Shipped Work — Claude Duet is your 24/7 radar and morning dispatcher—not an isolated silo. Because it shares unified Claude Memory, Skills, and account connectors, overnight discoveries flow effortlessly into Claude Projects, Sheets, Cowork, and Claude Code.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Use this diagnostic clinic whenever background sweeps hit quota walls, Morning Briefs feel chatty, or an expected write pauses waiting for review—followed by a 6-point launch readiness checklist.

### Claude Design

> Turning real codebases and brand guidelines into on-brand interactive prototypes, wireframes, decks, and product one-pagers—with live Control Knobs, inline comments, and Figma MCP or Claude Code handoffs.

- Web: https://twelve-pages.com/guides/claude/claude-design
- Markdown: https://twelve-pages.com/guides/claude/claude-design.md
- PDF: https://twelve-pages.com/guides/claude/claude-design/Claude_Design_Complete_How_To_Guide.pdf (3.1 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Codebase & Brand Onboarding, 4 Visual Deliverable Modes, Live Studio Control Knobs, Inline Comments & Direct Tweaks, Figma MCP & Code Connect, Claude Code & Gamma Export
- Core Takeaways:
  - Never Start Off-Brand: Ingest React, Tailwind, shadcn/ui, tokens.json, and brand PDFs during onboarding so every frame uses your real system tokens.
  - Dial, Comment, Tweak Live: Adjust layout density, dark mode, type scale, radii, and variants through live Control Knobs and inline pins without hand-editing code.
  - Round-Trip Everywhere: Sync editable auto-layout layers via Figma MCP & Code Connect, hand components to Claude Code, or export to Gamma and headless stacks.
- Chapters:
  1. Bridging Conversation, Brand Systems, and Real Code — Generic AI UI generators invent throwaway buttons and mismatched fonts on every prompt. Anthropic Labs built Claude Design as an interactive visual prototyping studio grounded in your team’s living Design System—so conversational ideas look and behave like your actual product from Draft 1.
  2. Plans, Activation & Design Surface Decision Matrix — Born in Anthropic Labs, Claude Design operates across web (claude.ai and claude.ai/design), Claude Desktop (macOS and Windows), mobile review apps, and Claude Code workflows—powered by Anthropic’s vision-capable Claude Opus models.
  3. Annotated Tour: Inside the Claude Design Studio — Every Claude Design session unites three live panels: a brand-aware prompt and comment stream on the left, an interactive clickable preview canvas in the center, and real-time Control Knobs on the right.
  4. Codebase & Brand Onboarding: Your Living Design System — The secret to shipping production-grade visuals in Claude Design happens in the first two minutes. During onboarding, Claude ingests your actual frontend codebase and brand assets to construct a reusable Design System that governs every prototype, deck, and one-pager.
  5. The 4 Deliverable Modes & 5-Part Prompt Anatomy — Once your Design System is locked in, a single workspace switches smoothly across four core output formats—serving product, design, engineering, and marketing workflows without shifting tools.
  6. Refining Live: Control Knobs, Comments & Variants — Traditional AI chat tools punish small visual tweaks: asking to “make cards slightly tighter and softer” often triggers a slow full-screen rewrite that scrambles copy you already approved. Claude Design gives you three fast, surgical refinement levers.
  7. Bidirectional Handoffs: Figma, Claude Code & Web Stacks — Design momentum collapses when prototypes stay trapped as throwaway mockups. Claude Design provides clean round-trip bridges into Figma, Claude Code, Gamma, and modern headless web architectures.
  8. 5 Real-World Copy-Paste Claude Design Recipes — Paste any recipe below into Claude Design with your published Design System active to produce high-precision prototypes, UX wireframes, slide decks, product one-pagers, or Figma-to-Code round-trips immediately.
  9. Collaboration, Org Governance & Sharing Permissions — Interactive prototypes often reveal unannounced features, pricing models, and proprietary design tokens. Claude Design enforces org-scoped sharing boundaries, role-based review controls, and Design System governance across every tier.
  10. Cross-Tool Synergy: From Discovery to Shipped Code — Claude Design acts as the visual synthesis hub in Anthropic’s wider ecosystem—converting early strategy from Claude Meetings, Projects, and Whiteboards into living prototypes that flow smoothly into Figma, Gamma, Claude Code, and Claude Security.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Use this diagnostic reference whenever generated screens drift off-brand, Control Knobs behave unexpectedly, or a Figma/Code handoff needs repair—followed by our 6-point launch checklist.

### Claude Code Projects & Proactive Coordinator

> Orchestrating parallel cloud worker branches with Claude Fable 5.2, Opus 5.5, and Haiku 5.5 alongside the Session Rail HUD, /btw and /fork context hygiene, Background MCP tasks, and identity safeguards.

- Web: https://twelve-pages.com/guides/claude/claude-code-projects-and-coordinator
- Markdown: https://twelve-pages.com/guides/claude/claude-code-projects-and-coordinator.md
- PDF: https://twelve-pages.com/guides/claude/claude-code-projects-and-coordinator/Claude_Code_Projects_and_Coordinator_Complete_How_To_Guide.pdf (2.8 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Proactive Coordinator, Parallel Cloud Branches, Fable 5.2 • 2.5x Fast Mode, /btw • /fork • /rewind, Session Rail HUD, Background MCP & Jupyter
- Core Takeaways:
  - Coordinated Cloud Fleet: Dispatch full cloud Claude Code workers across isolated repository copies and Git branches while one parent coordinator reconciles diffs.
  - Zero-Pollution Context: Spin off side questions with /btw, explore competing implementations with /fork, and roll back cleanly via /rewind or /clear.
  - Non-Blocking & Guarded: Track subagents in the Session Rail HUD, run async Background MCP tasks, sync Jupyter cells live, and lock down client-identity leaks.
- Chapters:
  1. From Static Context Folder to Proactive Engineering Hub — Earlier versions of Projects acted like passive filing cabinets holding pinned docs while you drove every coding step by hand. In November 2026, Anthropic transformed Claude Code Projects into a cloud-backed multi-agent workspace—led by a Proactive Coordinator that plans, delegates, monitors, and reconciles work across parallel branches automatically.
  2. Model Tiers, Cloud Setup & Coordination Decision Matrix — Pairing the right Claude model tier with the right execution pattern keeps multi-agent engineering blazingly fast without burning through your context or rate limits. Use the setup guide and comparison matrix below to pick the cleanest surface for every task.
  3. Annotated Tour: Session Rail HUD & Coordinated Studio — Inside Claude Code Desktop, VS Code, and claude.ai/code, the unified Project Studio pairs your conversational Coordinator on the left with the live Session Rail HUD on the right—tracking workers, context meters, and async MCP jobs in real time.
  4. Proactive Coordinator & Parallel Branch Reconciliation — Instead of manually juggling five terminal tabs and copying diffs by hand, the Proactive Coordinator acts as your automated tech lead—fanning tasks across isolated cloud Claude Code sessions and bringing cleanly reconciled branches back to one thread.
  5. Context Hygiene: /btw, /fork, /rewind & Directive Anatomy — Multi-hour coding sessions fail when tangential questions, dead-end refactors, and raw stack traces pollute the Coordinator’s context window. Keep your primary timeline razor-sharp with four dedicated context-hygiene controls.
  6. Background MCP Tasks & Live Jupyter Notebook Cell Sync — Slow integration test suites, warehouse exports, and interactive data notebooks no longer hold your terminal hostage. Background MCP routing and real-time Jupyter cell sync let engineering and data exploration run smoothly side by side.
  7. Expanded Auto-Mode Gateway & Client-Identity Safeguards — Giving autonomous cloud workers and MCP tools room to move fast requires guardrails that stop dangerous commands and block subtle privacy leaks. November 2026 releases pair expanded Auto-Mode gateway policies with strict client-identity protections.
  8. 5 Real-World Copy-Paste Project & Coordinator Recipes — Use these concrete, ready-to-run prompts and slash-command flows inside any connected Claude Code Project to dispatch cloud worker branches, isolate side investigations, and reconcile verified code cleanly.
  9. Team Collaboration, Enterprise Governance & Safety Matrix — Scaling Claude Code Projects from solo hacker sessions to an engineering organization means giving teammates transparent visibility without exposing secrets, risking accidental branch edits, or bypassing compliance gateways.
  10. Cross-Tool Synergy: From Spec to Reconciled Production PRs — Claude Code Projects acts as the execution hub of the broader Anthropic workspace—turning spatial roadmaps from Claude Whiteboards and Design specs into coordinated parallel branches verified by Claude Security and remote MCP tools.
  11. Troubleshooting Clinic & Coordinator Pre-Flight — Use this diagnostic reference whenever parallel workers hit merge conflicts, async MCP tasks stall, or safety policies trigger unexpected blocks—followed by our 6-point checklist before launching multi-branch sprints.

### Claude Security & Mythos 5.2

> Deploying continuous, reasoning-driven application security with Claude Mythos 5.2—mastering Deep Baseline Scans, living Threat Models, automated fix verification, and Claude Code MCP remediation.

- Web: https://twelve-pages.com/guides/claude/claude-security-and-mythos
- Markdown: https://twelve-pages.com/guides/claude/claude-security-and-mythos.md
- PDF: https://twelve-pages.com/guides/claude/claude-security-and-mythos/Claude_Security_and_Mythos_Complete_How_To_Guide.pdf (3.5 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Mythos 5.2 (89.6% CVE Score), Deep Baseline & Threat Model, Continuous Commit Scanning, Auto Fix-Lifecycle Tracking, Claude Security MCP Connector, Management API & Webhooks
- Core Takeaways:
  - Reasons Like a Researcher: Traces multi-file data flows, cross-service auth bypasses, IDORs, and subtle race conditions instead of relying on noisy regex patterns.
  - Living Threat Model Memory: Generates an editable, repository-grounded threat topology on day one, then scores every new commit against real production reachability.
  - Closed-Loop Remediation: Automatically verifies fixes when commits land, reopens regressions, and pipes live findings directly into Claude Code via MCP.
- Chapters:
  1. Beyond Pattern Matching: Reasoning-Driven Application Security — Traditional static security scanners inspect one file at a time against rigid rule signatures, drowning engineering teams in false alarms while missing the clever multi-file logic flaws attackers actually exploit. In November 2026, Anthropic expanded Claude Security into public beta for Claude Enterprise, powered by Claude Mythos 5.2—a frontier reasoning engine built to hunt, verify, and track real vulnerabilities end to end.
  2. Setup, Verification Programs & AppSec Decision Matrix — Whether you are securing private corporate microservices inside Claude Enterprise or hardening critical open-source software through Anthropic’s vetted researcher programs, understanding how Mythos 5.2 access is packaged gets your team scanning in minutes.
  3. Annotated Tour: Inside the Claude Security Console — The Claude Security console unifies your project’s editable architecture assumptions, Mythos 5.2 findings, stateful fix verification, and developer MCP handoffs inside one clean workspace.
  4. Deep Baseline Scans & Living Project Threat Models — Why do legacy scanners raise thousands of pointless alerts? Because they do not know which services face the public internet, where authentication happens, or which tables store sensitive keys. Claude Security solves this on day one with a Deep Baseline Scan that builds your editable Project Threat Model.
  5. Stochastic Deep Reasoning & 5-Part Audit Anatomy — Attackers rarely exploit obvious textbook typos anymore—they chain subtle authorization assumptions across multiple files and asynchronous jobs. Here are the five vulnerability classes where Mythos 5.2 shines, plus the 5-part formula for steering Threat Models and Claude Code audits.
  6. Continuous Commit Monitoring & Auto Fix-Lifecycle Tracking — Anthropic’s Project Glasswing coalition surfaced an urgent lesson: frontier AI uncovers deep bugs faster than human teams can track spreadsheets of tickets. Claude Security closes that operational gap with complexity-weighted commit scanning and a stateful fix-lifecycle engine.
  7. MCP Remediation Loop, Management API & Webhooks — Security findings only get fixed quickly when they meet developers inside the editor and fit cleanly into existing SecOps pipelines. Claude Security bridges both worlds with its native MCP Connector and event-driven REST Management API.
  8. 5 Real-World Copy-Paste Security Recipes — Use these production-ready prompts inside Claude Code (with the Claude Security MCP connector enabled) and Claude Security consoles, plus a clean webhook gate pattern for platform teams.
  9. Enterprise Governance, Privacy & Cyber Verification — A frontier model capable of discovering ~89.6% of historical CVEs demands rigorous governance. Anthropic pairs Claude Security with strict enterprise data boundaries, least-privilege repository tokens, and tiered researcher vetting through the Cyber Verification Program (CVP).
  10. Cross-Tool Synergy: From Architecture Spec to Verified Patch — Application security breaks down when architects, security analysts, and developers live in disconnected tools. Connecting Claude Projects, Claude Security (Mythos 5.2), Claude Code, and Claude Docs/Sheets creates a self-healing security loop.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Use this diagnostic playbook whenever cross-repo traces look incomplete, an internal helper triggers a false alarm, or an MCP session cannot pull live findings—plus our 6-point Enterprise launch checklist.

### Claude Code Channels, Remote Control & Dispatch

> Connect live local terminal sessions to webhooks, CI/CD, Sentry, and chat bridges with Channels, steer active repos from mobile via Remote Control, and isolate cross-device Dispatch runs.

- Web: https://twelve-pages.com/guides/claude/claude-code-channels-and-remote-control
- Markdown: https://twelve-pages.com/guides/claude/claude-code-channels-and-remote-control.md
- PDF: https://twelve-pages.com/guides/claude/claude-code-channels-and-remote-control/Claude_Code_Channels_and_Remote_Control_Complete_How_To_Guide.pdf (2.9 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Event-Driven Channels, Webhooks, CI/CD & Sentry, Telegram & Discord Bridges, Live Mobile Remote Control, Parallel Worktree Spawning, Hardened Sandbox Guardrails
- Core Takeaways:
  - Channels: Always-Warm Intake: Push CI failures, GitHub PR reviews, Sentry exceptions, and Telegram messages directly into an open session over MCP stdio.
  - Remote Control: Local Power Anywhere: Monitor, approve, and steer live local sessions from iOS, Android, or claude.ai/code while keeping local git, files, and MCPs intact.
  - Dispatch & Hardened Boundaries: Navigate cross-device Cowork routing safely with strict pairing allowlists, OS sandboxing, worktree isolation, and Deny → Ask → Allow gates.
- Chapters:
  1. From Desk-Bound Terminals to Continuous Cross-Device Flow — Traditional coding agents freeze the moment you walk away from your keyboard or wait for an engineer to notice a broken build manually. Anthropic’s Channels, Remote Control, and cross-device Dispatch architecture eliminate that bottleneck by wiring live external signals and mobile viewports straight into your active workspace.
  2. Setup, Pairing & Choosing the Right Execution Mode — Channels and Remote Control share one core goal—letting work continue smoothly when you step away from your desk—yet each carries distinct runtime requirements, authentication rules, and ideal workloads.
  3. Annotated Tour: Inside a Channels & Remote Control Bridge — When you combine an active Channel server with Remote Control, your local terminal handles repository reads, isolated Git worktrees, and test execution while syncing every prompt and approval cleanly to your phone.
  4. Claude Code Channels: Turning Alerts Into Autonomous Fixes — Introduced in Claude Code v2.1.80+, Channels invert the normal Model Context Protocol flow. Rather than waiting for Claude to query an external tool, a Channel server runs as a local stdio subprocess and pushes real-time events straight into your open session.
  5. Custom Webhook Channels & Event Anatomy — Building your own Channel for GitHub, GitLab, Sentry, or internal deploy pipelines takes under fifty lines of TypeScript using Bun and the MCP SDK. Every reliable channel follows a clear five-part contract.
  6. Remote Control: Steering Local Sessions From Anywhere — Sometimes you do not want a cloud container—you want the exact repository, environment variables, local database, and stdio MCP tools already running on your computer. Remote Control turns your phone or any browser into a secure live window into that local machine.
  7. Dispatch, Cowork Routing & Hardened Execution — Alongside developer-focused Remote Control, Anthropic launched Dispatch inside Claude Cowork to let knowledge workers send mobile tasks to an awake Claude Desktop app. Examining how Dispatch evolved reveals why hardened sandbox boundaries are mandatory whenever remote surfaces command local machines.
  8. 5 Real-World Copy-Paste Automation Recipes — Put Channels, Remote Control, Git worktrees, and hardened sandbox rules into practice immediately with these five field-tested patterns designed for solo builders and engineering teams.
  9. Security Boundaries, Token Scoping & Hardened Guardrails — Connecting external webhooks, chat bots, and mobile clients to a terminal capable of running shell commands demands defense in depth. Lock down identity, input validation, tool permissions, and filesystem visibility at every boundary.
  10. Cross-Tool Synergy: From Alert to Verified Merge Anywhere — When wired together, Anthropic’s remote capabilities form one cohesive engineering pipeline: webhooks wake a warm session, Git worktrees and OS sandboxes contain every edit, Remote Control puts live diffs in your pocket, and two-way Channels close the loop with your team.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Use this clinic whenever channel alerts drop silently, Remote Control shows offline on your phone, or sandbox flags fail—followed by a 6-point pre-flight check before leaving a bridge unattended.

### Claude in Chrome & Persistent Memory

> Bridge authenticated Chrome tabs to Claude Code and Claude Desktop for live console and DOM forensics while compounding knowledge via /memories CRUD, CLAUDE.md, and Auto-Dream consolidation.

- Web: https://twelve-pages.com/guides/claude/claude-in-chrome-and-persistent-memory
- Markdown: https://twelve-pages.com/guides/claude/claude-in-chrome-and-persistent-memory.md
- PDF: https://twelve-pages.com/guides/claude/claude-in-chrome-and-persistent-memory/Claude_in_Chrome_and_Persistent_Memory_Complete_How_To_Guide.pdf (3.4 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Live Tab & Session Bridge, Console & Network Forensics, Allowlists & Prompt Safety, /memories CRUD & JIT Recall, CLAUDE.md vs MEMORY.md, Idle Auto-Dream Consolidation
- Core Takeaways:
  - See What Your Browser Sees: Connect claude --chrome and Claude Desktop directly to real logged-in tabs to inspect console logs, failing API calls, and live DOM state.
  - Remember Across Sessions: Pair static CLAUDE.md team rules with dynamic /memories files loaded just in time so prompts stay crisp and token-lean.
  - Self-Cleaning Knowledge: Enforce per-site allowlists, injection classifiers, and background Auto-Dream cycles that resolve stale notes before context bloats.
- Chapters:
  1. Bridging Live Browser Vision With Long-Term Agent Memory — AI assistants traditionally lose their footing in two predictable places: they cannot see the live web app running inside your signed-in browser, and they wake up with total amnesia every time you start a new session. Pairing Claude in Chrome with Anthropic’s Persistent Memory architecture closes both gaps in one seamless loop.
  2. Setup, Extension Permissions & Memory Decision Matrix — Generally available across paid Claude plans (Pro, Max, Team, Ultra, and Enterprise), the Claude in Chrome extension pairs with both Claude Desktop and Claude Code while Anthropic’s memory stack separates human rules from learned state.
  3. Annotated Tour: Chrome Extension Bridge & Memory View — Inside a paired session, the Claude in Chrome side panel shares live tab context, console errors, and permission boundaries directly with your Claude Code terminal or Claude Desktop workspace and persistent /memories store.
  4. Live Chrome QA: Console Forensics & DOM Verification — Copy-pasting browser errors into chat wastes minutes and drops critical context. With claude --chrome or Claude Desktop connected to your extension, Claude drives the actual staging browser, catches runtime errors itself, patches your code, and re-tests immediately.
  5. 5-Part Browser-to-Memory Anatomy & Chrome Shortcuts — Great browser workflows don’t stop at fixing one bug—they isolate the target tab, gather telemetry, verify the patch, save the earned lesson into /memories, and automate repeatable checks as saved Chrome / shortcuts.
  6. Anthropic’s Native /memories Tool & Just-in-Time Recall — Instead of dumping sprawling chat histories into every prompt, Anthropic’s native Memory Tool (memory_20250818) gives Claude a structured /memories filesystem to manage long-term facts across sessions using just-in-time retrieval.
  7. Idle “Dreaming” Consolidation: Curing Agent Memory Rot — After fifteen or twenty busy sessions, raw auto-memory turns messy: yesterday’s workaround contradicts today’s refactor, relative phrases like “last Tuesday” lose meaning, and MEMORY.md overflows its 200-line ceiling. Inspired by biological REM sleep, Anthropic’s Auto-Dream reorganizes memory offline while you rest.
  8. 5 Real-World Copy-Paste Chrome & Memory Recipes — Drop these battle-tested prompts straight into claude --chrome, Claude Desktop, Chrome side-panel shortcuts, or your custom API agent loop to pair live browser inspection with clean persistent memory updates.
  9. Browser Security, Allowlists & Memory Hygiene — Because Claude in Chrome inherits your live cookies and MEMORY.md acts as high-authority startup guidance, browser security and memory sanitization belong in the same threat model.
  10. Cross-Tool Synergy: Live Browser to Living Memory — When connected end to end, Claude in Chrome, Claude Desktop, Claude Code, /memories CRUD, and Auto-Dream form a closed engineering flywheel where every debugging session accelerates every session that follows.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Keep this rapid-diagnostic guide nearby whenever the Chrome extension drops its bridge, a site permission blocks unexpectedly, or MEMORY.md trims older facts—followed by your 6-point launch checklist.

## OpenAI Codex, Agents & Realtime Studios (5 Handbooks)

Topic Hub: https://twelve-pages.com/topics/openai

Publication-grade 12-page visual handbooks for OpenAI's agentic developer and workspace platform—covering Codex CLI & Codex Cloud, the OpenAI Agents API & SDK, ChatGPT Projects, Memory & Deep Research, ChatGPT Canvas, Spaces & Computer Use, and low-latency Realtime Voice & Vision agents.

### OpenAI Codex CLI & Codex Cloud

> Configure TOML sandboxes, AGENTS.md constitutions, on-demand SKILL.md modules, GPT-6.1 Sol tiers, and parallel Codex Cloud PR containers.

- Web: https://twelve-pages.com/guides/openai/codex-cli-and-cloud
- Markdown: https://twelve-pages.com/guides/openai/codex-cli-and-cloud.md
- PDF: https://twelve-pages.com/guides/openai/codex-cli-and-cloud/OpenAI_Codex_CLI_and_Cloud_Complete_How_To_Guide.pdf (2.8 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: ~/.codex/config.toml, AGENTS.md, SKILL.md Modules, GPT-6.1 Sol, 3 Sandbox Tiers, Cloud PR Fleet
- Core Takeaways:
  - Sandboxed Terminal Speed: Run rapid edit-test loops locally on GPT-6.1 Sol with deterministic read-only, local-container, and full-host isolation.
  - Hierarchical Repo Memory: Encode team rules once in AGENTS.md and keep base prompts lean via progressive SKILL.md modules.
  - Parallel Cloud PR Fleet: Hand off heavy migrations and overnight issue queues via /cloud into isolated containers that ship tested PRs.
- Chapters:
  1. Local Terminal Speed Meets Isolated Cloud Fleet — Modern software engineering splits naturally into two rhythms: tight, interactive problem solving at your keyboard and heavy, parallelizable chores you would rather delegate overnight. Codex bridges both with one unified configuration, rulebook, and skill format.
  2. Setup, GPT-6.1 Sol & Approval-Sandbox Matrix — Getting started with Codex CLI takes under sixty seconds. Install the binary, authenticate with your ChatGPT or OpenAI API account, and choose the narrowest sandbox and approval pairing your current task requires.
  3. Annotated Tour: Codex CLI Terminal Cockpit — Codex CLI packs policy awareness, live diffs, sandbox boundaries, and cloud handoff into one keyboard-first terminal cockpit. Study these seven touchpoints before running your first autonomous loop.
  4. Mastering config.toml, MCPs & AGENTS.md — Two plain-text files govern almost everything Codex does: ~/.codex/config.toml controls your model, sandbox defaults, and MCP tools, while hierarchical AGENTS.md files serve as your repository’s living engineering constitution.
  5. On-Demand Skills: Keep Context Lean with SKILL.md — Stuffing twenty playbooks into AGENTS.md wastes precious context tokens and distracts the model. Codex solves this with progressive disclosure: only tiny skill names and trigger descriptions load at startup, while full SKILL.md instructions load only when a task matches.
  6. Terminal Power Workflows with GPT-6.1 Sol — Because GPT-6.1 Sol pairs a ~500k+ token window with low-latency tool execution, Codex CLI shines at tight verify-as-you-go loops. Give it a concrete verification signal up front and watch it self-correct before you review a single line.
  7. Codex Cloud Fleets: Parallel Containers to Clean PRs — When a task spans dozens of packages, takes twenty minutes of test suites, or repeats across multiple services, stop babysitting one terminal tab. Codex Cloud clones your repo into isolated cloud containers that run for hours or days and return review-ready PRs.
  8. 5 Real-World Copy-Paste Recipes — Adapt these five battle-tested blueprints for your daily engineering workflow. Notice how each pairs the right sandbox tier with a concrete verification command or Cloud PR handoff.
  9. Security, Secret Hygiene & Enterprise Governance — Autonomous agents move fast—which makes clear boundaries non-negotiable. Codex separates build-time setup secrets from runtime environment access and disables untrusted outbound networking by default so credentials never leak through generated code or logs.
  10. Cross-Tool Synergy: From Terminal Prototype to Production Fleet — Codex does not live in isolation. It forms the engineering backbone of OpenAI’s broader ecosystem—connecting rapid local terminal exploration, scalable Cloud pull-request fleets, and custom production agents built with the OpenAI Agents SDK or ChatGPT Spaces.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Most Codex CLI or Codex Cloud hiccups trace back to one of seven predictable setup or sandbox snags. Use these ten-second fixes to get unblocked fast, then verify your repo with the pre-flight checklist.

### OpenAI Agents API & SDK

> Architect production multi-agent systems with handoffs, Agents-as-Tools, parallel input/output guardrails, built-in tracing, and stateful MCP sessions.

- Web: https://twelve-pages.com/guides/openai/agents-api-and-sdk
- Markdown: https://twelve-pages.com/guides/openai/agents-api-and-sdk.md
- PDF: https://twelve-pages.com/guides/openai/agents-api-and-sdk/OpenAI_Agents_API_and_SDK_Complete_How_To_Guide.pdf (2.6 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Python & TypeScript, Managed Agents API, Handoffs & Tools, Parallel Guardrails, Built-In Tracing, Redis & MCP State
- Core Takeaways:
  - Minimal Core Primitives: Build deterministic agent loops using just Agent, Runner, tools, handoffs, and guardrails—with zero bloated abstractions.
  - Parallel Safety & Traces: Run fast input/output guardrails alongside model turns and inspect every span, latency spike, and token cost out of the box.
  - Portable State & MCP: Graduate seamlessly from local SQLiteSession prototypes to Redis clusters and persistent MCP servers or the hosted Agents API.
- Chapters:
  1. Minimal Primitives, Production Harness — OpenAI’s Agents SDK—published as openai-agents for Python and @openai/agents for TypeScript—turns the experimental simplicity of Swarm into a battle-tested runtime, paired with the managed Agents API when you want OpenAI to host the loop for you.
  2. Installation, Language Parity & Decision Matrix — Both the Python and TypeScript SDKs share nearly identical concepts and defaults. Install your language runtime in one command, export OPENAI_API_KEY, and decide whether your loop runs in your own app process or inside OpenAI’s managed Agents API.
  3. Annotated Tour: OpenAI Traces & Run Inspector — Every run in the Agents SDK and Agents API emits a nested tree of spans automatically. Here are the seven diagnostic touchpoints inside the OpenAI Traces dashboard for spotting latency, handoff errors, and guardrail hits in seconds.
  4. Orchestration: Handoffs vs. Agents-as-Tools — Multi-agent engineering boils down to one architectural choice: should the specialist take over the conversation and speak directly to the user (Handoff), or perform a focused subtask and return data to a central manager (Agent-as-Tool)?
  5. Structured Tool Contracts & Typed Outputs — Reliable agents never rely on regex parsing. The Agents SDK generates strict JSON Schemas straight from your Python type hints (Pydantic) or TypeScript Zod definitions—and automatically feeds validation errors back to the model for deterministic self-correction.
  6. Defense-in-Depth Guardrails & Built-In Tracing — Treat prompts as guidance and Guardrails as enforceable gates. By running fast lightweight classifiers in parallel with your main agent, you block prompt injections, PII leaks, and off-topic abuse without adding extra serial latency.
  7. Durable State & Stateful MCP Server Sessions — Stateless scripts forget everything after one reply. The Agents SDK provides a drop-in Session protocol—starting with zero-setup SQLiteSession locally and scaling horizontally with RedisSession—alongside first-class connectors for persistent MCP tool servers.
  8. 5 Real-World Copy-Paste Recipes — Drop these five proven architectural patterns straight into your Python or TypeScript service. Each recipe pairs the exact SDK primitives needed for fast, deterministic execution.
  9. Production Ops, Evals & Cost Control — Shipping agents to production requires predictable latency, strict loop budgets, and continuous regression testing. The SDK exposes clean hooks for custom telemetry pipelines, eval datasets, and tiered model routing.
  10. Cross-Tool Synergy: Full OpenAI Agent Stack — The Agents API and SDK sit at the center of OpenAI’s builder ecosystem—connecting developer-built tools from Codex CLI, sub-second Realtime Voice interfaces, and visual Canvas / Spaces human-in-the-loop checkpoints into one cohesive architecture.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Almost every multi-agent bug traces back to one of seven well-known runtime traps. Use this quick clinic to diagnose failures in ten seconds, then clear the six-point pre-flight checklist before shipping to production.

### ChatGPT Canvas, Spaces & Computer Use

> Master surgical split-pane Canvas diffs, multiplayer Spaces and Pages, and gated Agent Mode browser and desktop workflows.

- Web: https://twelve-pages.com/guides/openai/chatgpt-canvas-and-spaces
- Markdown: https://twelve-pages.com/guides/openai/chatgpt-canvas-and-spaces.md
- PDF: https://twelve-pages.com/guides/openai/chatgpt-canvas-and-spaces/ChatGPT_Canvas_Spaces_and_Computer_Use_Complete_How_To_Guide.pdf (2.5 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Split-Pane Canvas, Inline Shortcuts, Version Diffs, Multiplayer Spaces, Shared Pages, Gated Computer Use
- Core Takeaways:
  - Surgical Split-Pane Canvas: Highlight exact paragraphs or code blocks for targeted rewrites, inline comments, live React previews, and instant diff rollbacks.
  - Multiplayer Spaces & Pages: Unite teammates, persistent files, custom instructions, and living co-authored Pages in one shared workspace.
  - Gated Computer Execution: Delegate multi-step browser and connector workflows across Slack, Drive, and Salesforce behind explicit approval gates.
- Chapters:
  1. From Single-Player Chat to Multiplayer & Delegated Work — Traditional chat threads force you to scroll endlessly through linear replies whenever you revise a document, share context with a team, or ask an assistant to act in another app. ChatGPT separates those jobs into three purpose-built surfaces: Canvas for surgical co-editing, Spaces & Pages for multiplayer collaboration, and Agent Mode / Computer Use for delegated execution.
  2. Surface & Entitlement Decision Matrix — Every ChatGPT tier unlocks different limits across collaborative workspaces and autonomous virtual computers. Use the tables below to verify what your plan includes and pick the right surface before starting a project.
  3. Annotated Tour: Canvas Split-Pane & Space Controls — When Canvas opens inside a Space or chat, ChatGPT shifts from a single scrolling column into a synchronized dual-pane studio. Learn the seven controls below to steer edits without accidentally rewriting healthy work.
  4. Mastering Canvas Surgical Edits — The fastest way to ruin a strong draft in standard chat is asking for a small tweak and watching the model rewrite paragraphs you already approved. Canvas eliminates collateral drift by pairing region highlighting with targeted shortcuts, inline review pins, live UI previews, and reversible version diffs.
  5. Prompt Anatomy for Surgical Canvas & Shared Spaces — Vague prompts trigger whole-document rewrites and drift across team sessions. Use these six color-coded building blocks to lock scope inside Canvas and give shared Spaces crisp, durable rules that every teammate’s thread respects.
  6. Projects vs. Multiplayer Spaces & Live Pages — OpenAI evolved the older solo Library mindset into two distinct layers: private Projects for personal deep work, and multiplayer Spaces anchored by living Pages where human teammates, ChatGPT, and specialized agents share one persistent source of truth.
  7. Agent Mode & ChatGPT Work Computer Use — When information lives behind authenticated web portals or spans multiple business apps, copy-pasting screenshots slows you down. Agent Mode equips ChatGPT with a sandboxed virtual browser, terminal, and authorized connectors—executing multi-step workflows while pausing at strict human confirmation gates before irreversible actions.
  8. 5 Real-World Copy-Paste Recipes — Drop any prompt below straight into ChatGPT Canvas, a team Space, or an Agent Mode session. Each recipe pairs tight scoping with explicit output targets and safe confirmation boundaries so you get production-grade results on the first run.
  9. Workspace Governance, Permissions & Boundaries — Multiplayer Spaces and virtual computers multiply team velocity—which means permissions, connector scopes, and training boundaries must be crystal clear before you invite colleagues or connect production systems.
  10. Cross-Tool Synergy: From Space Page to Production — ChatGPT Canvas and Spaces sit at the front of OpenAI’s product stack. Once your team aligns on a spec inside a living Space Page and validates a UI prototype in Canvas, you can hand clean requirements straight into Codex CLI / Cloud PRs and automate recurring workflows with the OpenAI Agents SDK.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Most workspace snags come from ambiguous scope, preview sandbox rules, or paused authentication gates. Keep this seven-issue diagnostic chart handy for ten-second fixes.

### OpenAI Realtime Voice & Vision

> Build sub-second speech-to-speech and live vision agents across WebRTC, WebSockets, and SIP telephony with native VAD barge-in and async MCP.

- Web: https://twelve-pages.com/guides/openai/realtime-voice-and-vision
- Markdown: https://twelve-pages.com/guides/openai/realtime-voice-and-vision.md
- PDF: https://twelve-pages.com/guides/openai/realtime-voice-and-vision/OpenAI_Realtime_Voice_and_Vision_Complete_How_To_Guide.pdf (2.6 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: gpt-realtime-2.1, WebRTC Ephemeral Auth, SIP / PSTN Bridge, addImage() Vision, VAD Barge-In, Async MCP Calls
- Core Takeaways:
  - Native Speech-to-Speech: Stream audio directly in and out at ~250ms latency while preserving tone, laughter, hesitation, and natural cadence.
  - Live Camera & Screen Vision: Inject camera or screen frames mid-conversation with addImage() so the assistant sees what you see without stalling audio.
  - Full-Duplex & Async Tools: Interrupt cleanly with interrupt() and resolve slow CRM or database lookups via non-blocking sendMcpResponse().
- Chapters:
  1. Single-Model Speech-to-Speech & Live Vision — Traditional voice bots chain three separate models together—speech-to-text, a text LLM, and text-to-speech—introducing awkward 1.5–3 second pauses and erasing vocal emotion. OpenAI’s gpt-realtime-2.1 processes audio and visual frames inside one native multimodal stream.
  2. Model Tiers & Transport Selection Matrix — Every Realtime build begins with two architectural choices: which native speech-to-speech model fits your reasoning and budget profile, and which network transport carries your audio frames cleanly from the user’s device to OpenAI.
  3. Annotated Tour: Realtime Session Inspector — Unlike stateless text chat, a Realtime session coordinates audio waveforms, camera frames, voice activity boundaries, and background tool calls simultaneously. Here are the seven live telemetry points inside a healthy session.
  4. WebRTC Ephemeral Secrets, WebSockets & SIP — Golden Rule: Never embed your permanent OPENAI_API_KEY in browser JavaScript or mobile bundles. Instead, mint a single-use ephemeral key on your backend via POST /v1/realtime/client_secrets and hand only that short-lived token to the client.
  5. Live Vision via addImage() & Voice Personas — Unlike text models where you upload an image and wait for a turn, addImage() lets your app push camera or screen frames silently into an ongoing voice conversation—giving the assistant shared eyes without interrupting audio.
  6. Native VAD, Barge-In & Async MCP Calls — Natural conversation demands two hard engineering guarantees: when the user cuts in, buffered assistant audio must stop within milliseconds; and when the model runs a slow database query, the voice channel must never go dead silent.
  7. Production Audio Hygiene & Guardrails — Ninety percent of “the AI interrupted itself” or “the phone audio sounded robotic” bug reports are acoustic and codec hygiene issues—not model defects. Lock down these four production layers before going live.
  8. 5 Real-World Copy-Paste Recipes — Use these five field-tested patterns to go from blank repository to production-grade voice and vision experiences—pairing the right model, transport, and tool mechanics for each job.
  9. Latency Budgeting, Telemetry & Recovery — Sub-second voice feels effortless only when every hop in the audio path stays inside budget. Instrument these four timing checkpoints and build clean reconnect logic before exposing mobile users to spotty cellular handoffs.
  10. Cross-Tool Synergy: Voice to Specialist Agents — Realtime models shine at low-latency conversation and live visual triage—not deep 30-second code or SQL reasoning. Pair your Realtime frontend with background Agents SDK specialists and post-call ChatGPT Spaces Pages.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Almost every Realtime production hiccup maps to one of these seven transport, audio, or token issues. Run through this clinic and the six-point checklist before shipping to users.

### ChatGPT Projects, Memory & Deep Research

> Organize durable workspaces inside ChatGPT Projects, seal confidential work behind Project-Only Memory walls, steer autonomous Deep Research plans, and schedule proactive Tasks & Dots briefings.

- Web: https://twelve-pages.com/guides/openai/chatgpt-projects-memory-and-deep-research
- Markdown: https://twelve-pages.com/guides/openai/chatgpt-projects-memory-and-deep-research.md
- PDF: https://twelve-pages.com/guides/openai/chatgpt-projects-memory-and-deep-research/ChatGPT_Projects_Memory_and_Deep_Research_Complete_How_To_Guide.pdf (3.1 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Project Instructions & Files, Project-Only Memory Isolation, Autonomous Deep Research, Plan Edit & Live Steering, Scheduled Tasks & Dots, Canvas & Spaces Handoffs
- Core Takeaways:
  - Scoped Project Vaults: Bundle overriding instructions, sibling conversations, and up to 40 canonical reference files inside a clean workspace container.
  - Zero-Leak Memory Walls: Switch on Project-Only memory to seal confidential work away from personal chat history—and lock shared team workspaces automatically.
  - Steered Deep Synthesis: Review and edit multi-step research plans before launch, steer live browsing, verify citations, and export directly into Canvas or Spaces.
- Chapters:
  1. Moving From Ephemeral Chats to Compounding Knowledge — Treating ChatGPT like a blank scratchpad means re-uploading the same PDFs every Monday, accidentally mixing personal preferences into client briefs, and sifting through unverified web summaries. In 2026, ChatGPT organizes durable work around three interlocking pillars: Projects for structured context, Memory Boundaries for privacy, and Deep Research & Proactive Tasks for autonomous synthesis.
  2. Plans, Quotas, Setup & Memory Isolation Matrix — In 2026, OpenAI unlocks Projects, Deep Research, and Scheduled Tasks across consumer and enterprise tiers with distinct file limits, reset windows, and privacy guarantees.
  3. Annotated Tour: Inside Projects & Deep Research — When you launch a Deep Research run inside a ChatGPT Project, the interface pairs your isolated project vault on the left with a structured, editable research viewer on the right—keeping memory walls, reference PDFs, live steering, and citations in one workspace.
  4. Mastering Projects & Memory Isolation Walls — Most ChatGPT memory mistakes happen silently: you switch from planning a weekend trip to reviewing an acquisition NDA, and personal preferences spill into the draft. Configuring Projects with intentional memory walls stops cross-contamination before it starts.
  5. Color-Coded Project & Deep Research Anatomy — Vague research prompts waste Deep Research monthly allowances on generic blog summaries. Combining these six color-coded clauses keeps your Project instructions airtight and steers Deep Research toward primary sources on the very first pass.
  6. Autonomous Deep Research: Steer, Verify & Ship — Powered by OpenAI’s GPT-5 reasoning stack (with faster lightweight runs and exhaustive full passes), Deep Research spends 5 to 30 minutes autonomously browsing the web, reading your uploaded Project files, and checking connected workspace apps before returning a cited dossier.
  7. Proactive Tasks, Dots & Canvas / Spaces Handoffs — In 2026, ChatGPT moved from waiting for prompts to working proactively while you sleep. OpenAI retired the early Pulse morning card feed in mid-2026, unifying automation around user-steerable Scheduled Tasks and always-on ChatGPT Dots—which feed cleanly into Canvas and Spaces.
  8. 5 Real-World Copy-Paste Field Recipes — Drop any blueprint below straight into your Project settings, a new Deep Research session, or the Scheduled tasks prompt box. Every recipe specifies exact isolation rules, source priority, and handoff formatting so you skip rework.
  9. Privacy, Team Sharing & Memory Governance — Persistent memory and connected-app Deep Research touch your organization’s most sensitive documents. Knowing exactly when OpenAI trains on data, how shared Projects wall off personal memories, and when to reach for Temporary Chat keeps your workspace audit-ready.
  10. Cross-Tool Synergy: The Compounding Knowledge Loop — When you connect Projects, Deep Research, Scheduled Tasks & Dots, Canvas & Spaces, and Codex into one continuous loop, every completed research sprint strengthens the foundation for your next launch.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Use this field clinic whenever personal memories bleed into a client folder, Deep Research chases low-quality blogs, or a Scheduled Task lands late—followed by our 6-point setup checklist before starting a major research sprint.

## Vercel & Full-Stack AI Applications (4 Handbooks)

Topic Hub: https://twelve-pages.com/topics/vercel

Publication-grade 12-page visual handbooks for building production full-stack AI applications on Vercel—covering AI SDK 7 & AI Gateway, Durable Agents with eve, Workflow 5 & Queues, Next.js 16.3+ Cache Components & Partial Prefetching, and multi-platform bots with the Vercel Chat SDK.

### Vercel AI SDK 7 & AI Gateway

> Stream typed UI messages, ToolLoopAgent runs, and structured Output.object() calls through Vercel AI Gateway with OIDC auth, virtual models, budgets, and automatic provider failover.

- Web: https://twelve-pages.com/guides/vercel/ai-sdk-and-gateway
- Markdown: https://twelve-pages.com/guides/vercel/ai-sdk-and-gateway.md
- PDF: https://twelve-pages.com/guides/vercel/ai-sdk-and-gateway/Vercel_AI_SDK_and_Gateway_Complete_How_To_Guide.pdf (2.8 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Node 24 Fluid Compute, AI Gateway Routing, ToolLoopAgent, Output.object(), useChat & message.parts, Virtual Models & Budgets
- Core Takeaways:
  - One Unified TypeScript API: Call any foundation model via plain provider/model strings with shared streaming, tools, and structured schemas.
  - Automatic Provider Failover: Route around outages and rate limits across upstream hosts using VERCEL_OIDC_TOKEN, Virtual Models, and spend budgets.
  - Fluid Compute Streaming: Stream tokens and typed UI parts natively on Node.js 24 LTS with 300s default timeouts and Active CPU pricing.
- Chapters:
  1. One Streaming TypeScript Runtime, Multi-Provider Intelligence — AI SDK 7 and Vercel AI Gateway split responsibilities cleanly: your React UI and Next.js server speak one strongly typed streaming protocol on Node.js Fluid Compute, while AI Gateway handles provider credentials, automatic failover, and spend governance at the network boundary.
  2. Fluid Compute Setup & Modern AI SDK 7 Truths — AI SDK 7 requires Node.js 22+ and native ESM, pairing seamlessly with Vercel’s default Node.js 24 LTS runtime on Fluid Compute. Forget legacy Edge workarounds and outdated v4–v6 habits before writing your first route.
  3. Annotated Tour: @ai-sdk/devtools & Gateway Inspector — Pair local npx @ai-sdk/devtools (http://localhost:4983) with AI Gateway telemetry to trace every multi-step ToolLoopAgent turn, provider failover hop, typed UI part, and prompt cache hit in real time.
  4. Vercel AI Gateway Mastery: Routing, OIDC & Decisions — AI Gateway turns any provider/model string into a fault-tolerant, observable endpoint with zero markup on provider token rates, automatic health-based failover, and unified CLI management.
  5. Reliable Agents with ToolLoopAgent & Output.object() — Stop hand-writing fragile while loops or calling deprecated generateObject(). AI SDK 7 unifies autonomous multi-step tool execution inside ToolLoopAgent and strict JSON validation inside Output.object().
  6. Streaming React & Multimodal UIs with message.parts — AI SDK 7 replaces flat text strings with structured UIMessage.parts. Stream text deltas, typed tool cards, and custom data chunks cleanly from Fluid Compute routes into React useChat hooks.
  7. vercel.ts, Embeddings, Reranking & Coding Agents — Beyond chat routes, AI SDK 7 and AI Gateway power typed project configuration via vercel.ts, high-accuracy retrieval pipelines with embedMany and rerank, and centralized coding-agent traffic.
  8. 5 Real-World Copy-Paste Recipes — Drop these five production-ready patterns straight into Next.js App Router or Node.js 24 LTS services. Every recipe uses verified AI SDK 7 exports, plain provider/model routing, and Fluid Compute defaults.
  9. Cost Controls, Observability, Auth & Security Hygiene — Production AI apps fail expensively when credentials leak or loops run uncapped. AI Gateway stacks team, project, key, and user budgets with Zero Data Retention routing and OpenTelemetry-ready request logs.
  10. Cross-Tool Synergy: The Full Vercel AI Stack — AI SDK 7 and AI Gateway form the intelligence core of Vercel’s platform. Pair them cleanly with Workflow 5 for crash-safe multi-minute runs, Next.js Cache Components for instant UI shells, and Vercel Chat SDK for multi-platform bots.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Almost every AI SDK 7 or AI Gateway snag stems from a handful of outdated v4–v6 habits or environment mismatches. Match your symptom below for a ten-second fix, then clear the pre-flight checklist before deploying.

### Vercel Durable Agents, Workflows & Queues

> Build crash-safe agents and long-running pipelines using eve, Workflow 5 (WorkflowAgent, use workflow & use step), Vercel Queues, and Vercel Schedules.

- Web: https://twelve-pages.com/guides/vercel/durable-agents-and-workflows
- Markdown: https://twelve-pages.com/guides/vercel/durable-agents-and-workflows.md
- PDF: https://twelve-pages.com/guides/vercel/durable-agents-and-workflows/Vercel_Durable_Agents_and_Workflows_Complete_How_To_Guide.pdf (2.7 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Workflow 5 + WorkflowAgent, eve Framework, use workflow & use step, Vercel Queues, Vercel Schedules, Sandbox & Daemons
- Core Takeaways:
  - Crash-Safe Replay: Checkpoint every LLM call and side effect via "use step", sleep for days with zero idle compute, and replay cleanly past failures.
  - Durable Agent Runtimes: Embed WorkflowAgent inside existing apps or scaffold filesystem-first agents with eve, Slack channels, and @vercel/connect.
  - Queues, Clocks & MicroVMs: Buffer bursts on append-only @vercel/queue topics, schedule per-tenant jobs, and execute untrusted code inside Firecracker sandboxes.
- Chapters:
  1. Surviving Crashes, Deploys & Multi-Day Waits — Standard HTTP functions vanish after a few minutes, while real AI agents need to wait for human approvals, recover from upstream rate limits, and stream progress across browser reloads. Vercel solves this by layering deterministic replay and durable message logs underneath ordinary TypeScript functions.
  2. Ecosystem Decision Matrix & 60-Second Setup — Vercel offers six complementary durability primitives. Pick the highest-level abstraction that fits your workload instead of hand-rolling queue state machines or polling loops.
  3. Annotated Tour: Workflow Run & agent-runs Inspector — Debugging durable systems requires seeing both replay history and live agent tool spans. Inspect local and production runs with npx workflow web and vercel agent-runs across these seven diagnostic touchpoints.
  4. Workflow 5: "use workflow" vs. "use step" — The secret to error-free Workflow 5 code is knowing where each directive runs. Keep "use workflow" strictly for deterministic orchestration and move all real I/O, npm libraries, and network calls into "use step" functions.
  5. WorkflowAgent & eve Filesystem-First Agents — Whether you embed an agent inside an existing Next.js route with WorkflowAgent or build a dedicated multi-channel agent service with eve, durable checkpoints guarantee every reasoning turn and tool result survives failures.
  6. Human-in-the-Loop Hooks & Vercel Sandbox — Real production agents regularly pause for days waiting on human sign-off or execute untrusted AI-generated scripts. Workflows v5 hooks suspend execution at zero cost, while Vercel Sandbox jails untrusted code inside Firecracker microVMs.
  7. Vercel Queues & Vercel Schedules — Use Vercel Queues (@vercel/queue / Python vercel-queue) when you want direct control over topic publishing, buffering, and consumer groups, and Vercel Schedules (@vercel/schedules) to replace legacy crons with timezone-aware recurring or one-shot triggers.
  8. 5 Real-World Copy-Paste Recipes — Adapt these five field-tested patterns directly into your repository. Each pairs the right Vercel durability layer with explicit idempotency, timeout safety, and clean observability.
  9. Observability, Security & Production Operations — Durable systems run asynchronously for hours or days, which means silent failures or leaked secrets compound fast. Pair programmatic hydration and vercel agent-runs tracing with OIDC-backed credentials and graceful Daemon shutdowns.
  10. Cross-Tool Synergy: End-to-End Durable Agent Stack — Each Vercel primitive handles one clean responsibility. Wire Next.js or Chat SDK at the edge of user interaction, Workflow 5 or eve for durable state, AI Gateway and Sandbox for safe intelligence, and Queues plus Schedules for background scale.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Almost every Workflow, Queues, or Schedules snag comes from mixing sandbox scopes, skipping idempotency keys, or importing outdated v4 symbols. Keep these seven 10-second fixes handy before deploying.

### Next.js Cache Components & Partial Prefetching

> Adopt cacheComponents and partialPrefetching in Next.js 16.3+, grow instant static App Shells with use cache and Suspense, and lock regressions with @next/playwright instant().

- Web: https://twelve-pages.com/guides/vercel/nextjs-cache-components
- Markdown: https://twelve-pages.com/guides/vercel/nextjs-cache-components.md
- PDF: https://twelve-pages.com/guides/vercel/nextjs-cache-components/Nextjs_Cache_Components_and_Prefetching_Complete_How_To_Guide.pdf (2.9 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Next.js 16.3+ App Router, use cache & cacheLife, Granular Suspense, Incremental Codemods, Partial Prefetching, @next/playwright instant()
- Core Takeaways:
  - Instant Static Shells: Prerender rich navigation chrome, headings, and cached data frames on millisecond-fast first paint while live request holes stream cleanly.
  - Zero-Guesswork Migration: Adopt route by route with first-party codemods, Turbopack /_next/mcp runtime checks, and top-down validation loops.
  - Locked Production Proofs: Prevent silent regressions forever using @next/playwright instant() locks and Partial Prefetching URL-data sweeps.
- Chapters:
  1. Instant Static Shell + Streamed Request Holes — Traditional SSR makes the user wait for the slowest database query before painting a single pixel. Turning on cacheComponents: true flips that default: every App Router route prerenders an immediate App Shell and streams request-specific holes into <Suspense>.
  2. Prerequisites, Flag Migration & Strategy Matrix — Before flipping cacheComponents: true, verify that your project runs Next.js 16.3+ App Router and strip out legacy route-segment flags that conflict with fine-grained prerendering.
  3. Annotated Tour: next dev Overlay & /_next/mcp — Do not rely on HTTP 200 status codes or guesswork while migrating. Next.js 16.3+ pairs the browser dev overlay, amber Insights cards, and the live /_next/mcp server so you see every blocking read and React boundary in real time.
  4. Resolving the 3 Blocker Classes — Almost every prerender error during Cache Components adoption belongs to one of three predictable families. Fix the exact offending boundary rather than wrapping whole pages in a giant fallback.
  5. Mastering "use cache", cacheLife & Keys — When data is shared across visitors or changes on a predictable schedule, promote it into your static shell with "use cache" instead of streaming it on every request.
  6. Top-Down Loop & next-dev-loop Verification — Adopt one product feature at a time (e.g., app/settings/profile/**), walking strictly top-down from root layout to leaf pages while cross-checking /_next/mcp against a real browser.
  7. Partial Prefetching (partialPrefetching: true) — Legacy Next.js prefetched entire routes per URL. With partialPrefetching: true, default links reuse one shared App Shell across every dynamic parameter, while only opted-in <Link prefetch={true}> links pre-warm cached URL-specific data ahead of entry.
  8. 5 Real-World Copy-Paste Recipes — Drop these five production-tested patterns straight into Next.js 16.3+ App Router codebases. Every recipe respects non-blocking shell composition and clean mutation boundaries.
  9. Regression Proof with @next/playwright instant() — Timers are flaky and next dev does not prefetch. Guard your instant navigations with instant() from @next/playwright—a deterministic dynamic-data lock running against a real production build.
  10. Cross-Tool Synergy: From Static Shell to Live AI UI — Cache Components and Partial Prefetching form the presentation foundation of modern Vercel applications—pairing edge-delivered App Shells with Runtime Cache, AI SDK 7 streaming interfaces, and automated CI locks.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Most Cache Components and Partial Prefetching snags trace to one of seven concrete patterns. Match your error below for the ten-second fix, then verify your app against the pre-flight checklist.

### Multi-Platform Bots with Vercel Chat SDK

> Ship one TypeScript bot codebase across Slack, Teams, Discord, Telegram, GitHub, and Linear with @chat-adapter/*, Vercel Connect OAuth, Sandbox PR reviews, and Workflow approval cards.

- Web: https://twelve-pages.com/guides/vercel/multi-platform-chat-sdk
- Markdown: https://twelve-pages.com/guides/vercel/multi-platform-chat-sdk.md
- PDF: https://twelve-pages.com/guides/vercel/multi-platform-chat-sdk/Vercel_Multi_Platform_Chat_SDK_Complete_How_To_Guide.pdf (2.6 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Unified Chat Class, @chat-adapter/catalog, Slack, Teams & Discord, Telegram, GitHub & Linear, Vercel Connect OAuth, HITL Cards & Sandbox
- Core Takeaways:
  - Write Bot Logic Once: Handle @-mentions, subscribed threads, slash commands, and streamed AI replies in one shared handler across every platform adapter.
  - Zero-Secret Auth & Locks: Pair @vercel/connect short-lived OAuth tokens with Redis distributed thread locks so parallel messages never race or leak static keys.
  - Durable HITL & Sandboxes: Suspend Workflow 5 runs on Slack or Teams approval cards via createWebhook and audit PR diffs inside Vercel Sandbox microVMs.
- Chapters:
  1. Write Bot Logic Once, Native UX Everywhere — Every chat platform invents its own webhook signature scheme, markdown dialect, thread model, and button payload. Vercel Chat SDK (chat) normalizes incoming events into one clean TypeScript API while rendering authentic native cards, modals, and streaming replies per channel.
  2. Quickstart, @chat-adapter/catalog & Decision Matrix — Go from zero to a multi-platform bot in under a minute. Scaffold a Next.js template without prompts, inspect the bundled offline docs inside node_modules/chat/, and use @chat-adapter/catalog to query adapter capabilities statically.
  3. Annotated Tour: Cross-Platform Thread & Card Cockpit — Trace how a single user @-mention flows from an inbound webhook through Redis locking, AI SDK 7 streaming, and an interactive Human-in-the-Loop approval card that resumes a paused Workflow 5 run.
  4. Unified Chat Event Model & Native Adapters — Every adapter translates platform-specific events into four clean lifecycle hooks, letting you write interactive streaming bots, slash commands, Cards, and Modals once while honoring per-platform capabilities from @chat-adapter/catalog.
  5. Redis Thread Locks & Multi-Platform Handler Anatomy — Serverless webhook functions run concurrently across regions. Without a shared state layer, two rapid messages in the same thread overwrite each other’s context and post scrambled replies. Pairing @chat-adapter/redis with durable Workflow handoffs keeps every conversation deterministic.
  6. Zero-Secret Auth with @vercel/connect & Blob Tools — Static long-lived bot tokens sitting inside .env files create rotation headaches and wide blast radii. Pair Chat SDK with Vercel Connect (@vercel/connect/chat) for short-lived OAuth tokens and OIDC-signed triggers, and equip agents with approval-gated Vercel Blob tools.
  7. HITL Approval Cards & Sandbox PR Reviewers — Combine Chat SDK with Workflow 5 to pause multi-day approvals at zero compute cost until someone clicks a button in Slack or Teams, and spin up Vercel Sandbox microVMs whenever a developer @-mentions your bot on a GitHub pull request.
  8. 5 Real-World Copy-Paste Recipes — Start faster with these five production architectures drawn from node_modules/chat/resources/guides/. Each recipe pairs the exact adapters, AI SDK 7 primitives, and durability guards required for real traffic.
  9. Webhook Security, Feature Fallbacks & Replay Ops — Production bots face forged webhook probes, bursty retry storms, and subtle differences across messaging platforms. Lock down verification at the edge, inspect adapter capabilities before rendering rich UI, and test every channel offline with deterministic replay fixtures.
  10. Cross-Tool Synergy: From Mention to Durable Action — Vercel Chat SDK serves as the conversational front door of a unified full-stack AI architecture—connecting zero-secret OAuth credentials, gateway-routed reasoning, and crash-safe execution pods without custom glue servers.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Most multi-platform bot bugs trace back to one of seven predictable adapter, concurrency, or auth mistakes. Apply these ten-second fixes, then run the six-point checklist before shipping to production.

## AI Agent Engineering & Architecture (16 Handbooks)

Topic Hub: https://twelve-pages.com/topics/agent-engineering

Practical 12-page visual handbooks for context engineering, multi-agent orchestration, Orca workspaces & parallel Git worktrees, production MCP servers, Chrome DevTools & Playwright browser agents, document & web scraping pipelines (Docling, Crawl4AI & Firecrawl), OpenTelemetry & prompt caching, structured outputs & state machines, voice-first coding, vector RAG, security, evals, System One decisions, and local on-device AI.

### Spec-Driven Dev & Context Engineering

> Cross-vendor context architecture (AGENTS.md, CLAUDE.md, Cursor rules), progressive disclosure, and Spec-to-Plan-to-Tasks agent workflows.

- Web: https://twelve-pages.com/guides/agent-engineering/spec-driven-context-engineering
- Markdown: https://twelve-pages.com/guides/agent-engineering/spec-driven-context-engineering.md
- PDF: https://twelve-pages.com/guides/agent-engineering/spec-driven-context-engineering/Spec_Driven_Dev_and_Context_Engineering_Complete_How_To_Guide.pdf (3.2 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: One Canon (AGENTS.md), CLAUDE.md & .mdc Adapters, 4-Layer Progressive Disclosure, Spec → Plan → Tasks, Verifiable Acceptance Checks, Compaction & Handoff Hygiene
- Core Takeaways:
  - One Canon, Thin Adapters: Maintain one crisp AGENTS.md shared across Claude Code, Cursor, Antigravity, Copilot, Gemini CLI, and Codex.
  - 60–75% Leaner Context: Eliminate attention dilution with a 4-layer stack of path-scoped globs, trigger pointers, and on-demand skills.
  - Proof Over Vibe-Prompting: Replace fragile mega-prompts with durable repo specs and runnable acceptance checks that any fresh agent can verify.
- Chapters:
  1. Why Agents Thrash & The Core Mental Model — “The spec is the source of truth; the prompt is just the delivery truck.” When an AI coding agent loops, forgets conventions, or ships plausible-looking code that fails review, typing a longer, sterner chat prompt is the most expensive trap in modern software engineering.
  2. 5-Minute Repo Audit & Cross-Vendor Context Matrix — Every major AI coding tool reads persistent Markdown context from your repository—yet each uses different filenames, glob frontmatter, and load mechanics. Run this 5-minute audit before writing a single new rule.
  3. Annotated Tour: The “One Canon” Repository Layout — Here is how a clean, multi-tool repository looks in practice. Every project-wide convention lives once inside AGENTS.md, tool adapters stay under 35 lines, and deep subsystem docs or feature specs stay out of memory until needed.
  4. Progressive Disclosure & The 4-Layer Architecture — Every line in your root context file is re-processed on every turn of every session. Bloated 700-line handbooks create three compounding penalties: attention dilution (crucial rules get lost in the middle), silent rule collisions, and broken prompt-cache prefixes.
  5. Anatomy of a High-Signal AGENTS.md & JIT Triggers — Frontier coding models do not need flattery or restatements of standard ESLint rules—they can read your linter config directly. What they cannot guess are your repo's architectural boundaries, command quirks, and where hidden bodies are buried.
  6. The Spec-Driven Workflow: Spec → Plan → Tasks — When you jump straight from a vague chat prompt to code generation, the agent silently guesses scope, auth, formatting, and scale. Splitting work into three small Markdown files shifts your human effort to the highest-leverage 15 minutes: reviewing the route before wheels roll.
  7. Verifiable Acceptance Criteria & Stopping Context Rot — Two habits separate effortless agent sessions from late-afternoon meltdowns: phrasing every requirement so the agent can prove it mechanically, and managing your context window before “lost in the middle” attention poverty sets in.
  8. 5 Real-World Copy-Paste Context & Spec Recipes — Notice how short and calm your prompts become once truth lives in repository files. Copy and adapt these five high-leverage prompt recipes in Claude Code, Cursor, Antigravity, Copilot, or Codex CLI.
  9. Team Conventions, Monorepo Scopes & Git Hygiene — Context files are executable code—they run on a probabilistic LLM interpreter on every developer's laptop. Treating them with real software engineering discipline prevents three teammates' agents from pulling your codebase in three incompatible directions.
  10. End-to-End Synergy: One Feature, Zero Thrashing — See how every layer connects on a real feature—shipping a streaming 10,000-row Team Expense CSV Export without security leaks, memory timeouts, or mid-session amnesia.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Keep this final page beside your editor. Almost every case of “the model got dumber today” traces back to one of seven structural context or specification bugs—each with a 10-second fix.

### Subagents & Agent Orchestration

> Designing specialist subagents, context forks, least-privilege tool scoping, lifecycle hooks, and multi-agent coordinator-worker swarms.

- Web: https://twelve-pages.com/guides/agent-engineering/subagents-and-orchestration
- Markdown: https://twelve-pages.com/guides/agent-engineering/subagents-and-orchestration.md
- PDF: https://twelve-pages.com/guides/agent-engineering/subagents-and-orchestration/Subagents_and_Agent_Orchestration_Complete_How_To_Guide.pdf (3.0 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Context Isolation Architecture, .claude/agents/ & YAML Config, Forks vs. Clean-Slate Workers, Least-Privilege & PreToolUse Hooks, Fan-Out, Worktrees & Critic Loops, Claude • Antigravity • Cursor • Codex
- Core Takeaways:
  - Protect Your Main Context: Keep 80,000+ tokens of noisy file searches and test logs out of your lead session—only crisp summaries return.
  - Config-Enforced Safety: Prompts persuade, but configuration forbids. Lock scouts to read-only tools and gate shell calls with hooks.
  - Portable Across Ecosystems: Master one blueprint that maps cleanly across Claude Code, Google Antigravity, Cursor, Copilot, and Codex.
- Chapters:
  1. Why Context Isolation Beats One Giant Chat Thread — A subagent is a focused specialist spawned by your main coding agent to execute one bounded job inside its own private context window, governed by its own system prompt, model, and tool permissions, returning only a distilled final report.
  2. Four Multi-Agent Topologies & When to Delegate — "Multi-agent coding" actually describes four distinct operating patterns. Picking the right pattern before you write a prompt saves both wall-clock time and 3x–5x in wasted token spend.
  3. Annotated Tour: Subagent Spec & Live Dispatch Monitor — Every modern subagent system pairs a declarative definition file (left) with a live task & transcript monitor (right) so you can inspect active models, tool boundaries, and isolated worktrees at a glance.
  4. The 4 Topologies & Subagent Frontmatter Reference — A subagent file is plain Markdown: YAML frontmatter between --- fences on top, and the specialist's system prompt below. Only name and description are mandatory—every other key sharpens cost, isolation, or safety.
  5. Prompt Anatomy & 3 Production-Grade Subagents — You do not need twenty exotic agents. Ninety percent of real-world engineering teams get maximum leverage from just three tightly scoped specialists: a Scout, a Test-Runner, and a Skeptical Critic.
  6. Invocation Mechanics, Context Forks & Concurrency — Understanding what crosses the context boundary at launch—and when to reach for a fork or resume instead of a fresh spawn—eliminates the "amnesia tax" between pipeline stages.
  7. Least-Privilege Scoping & Command-Inspecting Hooks — Once subagents run unattended in the background—often reading untrusted web pages, GitHub issues, or third-party READMEs—prompt politeness is not a security boundary. Enforce blast-radius limits in configuration.
  8. 5 Copy-Paste Orchestration Recipes That Pay Off Daily — Drop these five battle-tested prompts straight into your coordinator session. Each combines explicit boundaries, isolation, and convergence rules so agents finish cleanly without babysitting.
  9. One Mental Model Across Every Major Coding Agent — In 2026, subagent concepts converged across the entire industry—and several editors even auto-load .claude/agents/ directly! Use this Rosetta Stone to translate any orchestration workflow in seconds.
  10. End-to-End Orchestration Pipeline & Cost Engineering — Smart orchestration pairs a frontier reasoning coordinator with fast, inexpensive specialist workers—delivering cleaner architecture and independent verification at a fraction of an all-frontier swarm bill.
  11. Troubleshooting Clinic & Pre-Flight Cheat Sheet — Keep this back-page clinic within reach whenever a custom subagent fails to trigger, loses context across stages, or stalls silently in the background.

### Git Worktrees & Parallel Agent Safety

> Running parallel coding agents without file collisions—covering Git worktree fleets, isolated ports/databases, safety hooks, and teardown.

- Web: https://twelve-pages.com/guides/agent-engineering/git-worktrees-and-parallel-safety
- Markdown: https://twelve-pages.com/guides/agent-engineering/git-worktrees-and-parallel-safety.md
- PDF: https://twelve-pages.com/guides/agent-engineering/git-worktrees-and-parallel-safety/Git_Worktrees_and_Parallel_Agent_Safety_Complete_How_To_Guide.pdf (3.1 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Shared .git Plumbing, 1-Agent-1-Branch Discipline, Env, Port & DB Isolation, PreToolUse Safety Hooks, Serial Human + CI Merge Gate, Claude, Antigravity, Orca & Cursor
- Core Takeaways:
  - Zero File Collisions: Give every parallel agent its own sibling working directory, index, and branch backed by a single shared .git store.
  - Full Runtime Separation: Isolate untracked state—node_modules, .env.local, deterministic ports 3001..3009, and test databases.
  - Defense-in-Depth Guardrails: Layer path-fencing PreToolUse hooks, pre-commit door inspectors, OS sandboxes, and a serial PR merge gate.
- Chapters:
  1. Why Parallel Agents Collide in a Single Directory — Git protects committed history inside .git, but gives your on-disk working tree zero concurrency protection. Pointing two autonomous coding agents at one folder turns shared mutable files into silent data loss before a commit ever exists.
  2. Choosing the Right Isolation Layer for Your Fleet — Not every parallel task needs a full virtual machine—and "just clone the repo five times" creates silent fetch drift and gigabytes of wasted history. Use this matrix to match isolation weight to task risk.
  3. Anatomy of a Well-Organized Multi-Agent Fleet — Keep linked worktrees as sibling folders beside your main repository (../wt-auth, ../wt-billing)—or inside a gitignored .worktrees/ directory—so file watchers, bundlers, and search tools never index duplicate trees.
  4. Git Worktrees End-to-End: Plumbing & Daily Commands — When you run git worktree add, Git does not duplicate your repository history. Instead, the new folder gets a tiny 1-line .git pointer file linking back to .git/worktrees/<name>/ for its private HEAD and staging index.
  5. Isolation Beyond Git: What Worktrees Do Not Copy — A fresh git worktree add checks out tracked source files only. Everything gitignored—dependencies, secret .env files, build caches, ports, and test databases—must be provisioned per workshop or agents will still collide at runtime.
  6. Turning Norms Into Physics: Hooks & Path Fences — Polite prompt instructions eventually lose to a confused model at step 60. Guard every workshop at two distinct doorways: an agent-native PreToolUse hook that blocks dangerous commands before execution, and a Git pre-commit hook that blocks broken code before packaging.
  7. Parallel Development, Serial Integration — The secret to landing five parallel agent branches without breaking main is simple: build in parallel, merge serially one PR at a time. Every remaining branch rebases onto the newly updated main inside its own workshop before advancing.
  8. 5 Copy-Paste Worktree Recipes for Daily Engineering — Keep these five battle-tested patterns handy whenever you want to parallelize a multi-slice roadmap, compare competing designs side by side, or ship an urgent hotfix without disturbing a running agent.
  9. Native Worktree Flags Across Modern Agent Harnesses — Before running manual git worktree add commands, check whether your coding harness manages worktrees natively. Built-in flags automatically place folders, track session state, and clean up idle trees—never fight your harness!
  10. End-to-End Fleet Pipeline: Spawn to Clean Repository — Here is how every piece in this guide locks together into one repeatable engineering pipeline—turning three concurrent tickets into three clean, linear commits on main with zero lost work.
  11. Troubleshooting Clinic & Fleet Pre-Flight Checklist — Ninety percent of worktree hiccups diagnose themselves with git worktree list -v and git -C <path> status. Use this table for 10-second recoveries when an agent or folder misbehaves.

### Vector Memory & Semantic Search (RAG)

> Building persistent semantic memory for AI agents with structure-aware chunking, Chroma, pgvector, Qdrant, local Ollama, and hybrid retrieval.

- Web: https://twelve-pages.com/guides/agent-engineering/vector-memory-and-rag
- Markdown: https://twelve-pages.com/guides/agent-engineering/vector-memory-and-rag.md
- PDF: https://twelve-pages.com/guides/agent-engineering/vector-memory-and-rag/Vector_Memory_and_Semantic_Search_RAG_Complete_How_To_Guide.pdf (3.1 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Chroma & Postgres pgvector, Local Ollama & OpenAI Embeddings, Structure-Aware Chunking, Hybrid BM25 + RRF Fusion, MCP search_vault Server, Episodic & Semantic Hygiene
- Core Takeaways:
  - Recall by Meaning, Not Wording: Find forgotten incidents, architecture trade-offs, and paraphrased notes in milliseconds across 10,000+ files.
  - 100% Offline or Pennies via API: Run privately for $0.00 on laptop RAM with Ollama, or index a 5,000-note vault for ~$0.09 via API.
  - One MCP Server, Every Agent: Expose search_vault once to power Claude Code, Antigravity, Cursor, and VS Code without bloating AGENTS.md.
- Chapters:
  1. Structural Maps vs. Semantic Metal Detectors — Tools like ripgrep, AST parsers, and knowledge graphs give your agent structural memory—they know how explicitly linked pieces connect. Semantic vector memory adds the missing half: instant recall by meaning, even when your query shares zero words with the note you wrote six months ago.
  2. Choosing Your Vector Stack & Embedding Model — Don't over-engineer Day 1. Start local with zero servers to babysit; graduate to Postgres or dedicated cluster engines only when multi-user concurrency, transactional joins, or million-chunk scale demand it.
  3. RAG Workbench & MCP Retrieval Inspector: UI Tour — Before wiring a vector store into your coding agent, always test it in the MCP Inspector (mcp dev memory_server.py). Seeing chunk boundaries, cosine similarity scores, and BM25 rank boosts side by side turns retrieval tuning from guesswork into a 5-minute visual check.
  4. Why Structure-Aware Chunking Decides Your Ceiling — An embedding compresses an entire passage into a single point in high-dimensional space. Cram five unrelated topics into one giant chunk and that point drifts to the mushy average of all five—matching nothing well. Slice too thin and single sentences lose their subject.
  5. Chunk Metadata, Prompt Grounding & Memory Hygiene — A bare paragraph reading "We lost 40k rows in 90 seconds" has no idea which system or year it belongs to. Prepending a structured header right onto the embedded text routinely improves recall more than buying a larger embedding model.
  6. End-to-End Build: Local Chroma + Ollama & pgvector — Install once with pip install chromadb ollama openai tiktoken rank_bm25. Because the store accepts any embed_fn(texts) function, switching between free offline Ollama and OpenAI APIs is a one-line import swap.
  7. Hybrid Search: Fixing the Exact-Keyword Blind Spot — Pure embeddings smooth away character-level precision—to a vector model, ERR_CONN_RESET_9, SKU-4810B, or useAuthSession() look nearly identical to close neighbors. Pairing dense vectors with classic BM25 lexical search gives you the best of both worlds.
  8. 5 Real-World RAG & Agent Memory Recipes — Match your exact use case to one of these five proven blueprints—from a 10-minute personal Obsidian second brain to a multi-tenant SaaS knowledge engine with database-enforced security.
  9. Exposing Vector Memory to AI Agents via MCP — Stuffing past notes into AGENTS.md taxes every single prompt turn whether relevant or not. Wrapping your hybrid retriever in a 40-line Model Context Protocol (MCP) server gives Claude Code, Antigravity, Cursor, and VS Code an on-demand search_vault superpower at zero idle token cost.
  10. Cross-Tool Memory Pipeline & Recall@5 Evaluation — Production agent engineering layers three complementary memory tiers—always-on rules, structural graphs, and semantic RAG—backed by a tiny golden-set benchmark so chunking tweaks never silently regress quality.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Almost every "dumb RAG" complaint traces back to one of seven mechanical bugs. Keep this diagnostic table within reach whenever retrieval scores look suspicious or an MCP client refuses to connect.

### AI Evals & Regression Testing

> Turning LLM vibe-checks into deterministic CI deploy gates with golden datasets, code scorers, calibrated LLM-as-judge, and Promptfoo.

- Web: https://twelve-pages.com/guides/agent-engineering/ai-evals-and-regression-testing
- Markdown: https://twelve-pages.com/guides/agent-engineering/ai-evals-and-regression-testing.md
- PDF: https://twelve-pages.com/guides/agent-engineering/ai-evals-and-regression-testing/AI_Evals_and_Regression_Testing_Complete_How_To_Guide.pdf (3.4 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Golden JSONL Datasets, Deterministic Pre-Screens, Calibrated LLM-as-a-Judge, promptfooconfig.yaml, RAG & Agent Trajectories, CI Gates & Live Sampling
- Core Takeaways:
  - Code First, Judge Second: Catch broken JSON/HTML schemas, missing citations, and bad tool args in 1ms for $0 before calling any judge model.
  - Bias-Proof Calibration: Neutralize verbosity, position, and self-preference bias using anchored rubrics, pairwise swaps, and TPR/TNR alignment.
  - Closed-Loop Deploy Gates: Block silent PR regressions against frozen baselines while promoting sampled 5–10% production failures into tomorrow's suite.
- Chapters:
  1. Why “Vibe Checks” Fail & The Core Mental Model — Traditional unit tests turn red when an endpoint throws HTTP 500 because software outputs are decidable. LLM apps fail silently: tweaking a prompt to fix three edge cases you stared at routinely breaks twelve customer workflows you forgot to re-test.
  2. Building Golden Datasets & Tooling Decision Matrix — The costliest rookie mistake is inventing 500 synthetic edge cases before writing a single scorer. Start with 5–10 real inputs—half proud production wins, half real user failures—and expand strictly when new failure modes surface.
  3. Annotated Tour: The Regression Matrix & Diff Viewer — Running npx promptfoo@latest view (or opening Braintrust/Langfuse) renders a side-by-side matrix comparing your production baseline against a candidate change. Here is how to spot a silent regression in ten seconds.
  4. Deterministic Code Scorers: Free, Fast & Flake-Free — If a requirement is decidable, write it in code. Python and TypeScript scorers execute in under a millisecond, cost $0.00, return identical verdicts on every run, and shield your LLM judge budget from structurally broken outputs.
  5. Calibrated LLM-as-a-Judge & Rubric Anatomy — Once structural checks pass, use an LLM judge to grade subjective quality—like groundedness or actionability. Without calibration, however, judges behave like lenient substitute teachers who reward polished verbosity over truth.
  6. Declarative Test Matrices with promptfooconfig.yaml — Declarative configuration lets you test two prompts across two models in a clean 2 × 2 matrix—combining zero-cost pre-screen assertions, latency ceilings, and calibrated rubric judges inside one version-controlled file.
  7. Evaluating RAG Pipelines & Agent Trajectories — Scoring only the final message of a RAG app or tool-using agent masks broken plumbing. If RAG fails, you need to know whether to fix the retriever or the prompt; if an agent succeeds by accident after calling the wrong tool, answer-only judges miss the bomb completely.
  8. 5 Real-World Copy-Paste Eval & Regression Recipes — Drop these five battle-tested patterns straight into your repository's evals/ folder to stand up datasets, code pre-screens, bias-proof pairwise judges, multi-model matrices, and agent trajectory checks.
  9. CI/CD Pull-Request Gating & Online Trace Monitoring — An evaluation suite sitting un-run on a laptop never stopped a bad deploy. Wire a fast, cost-capped smoke gate onto every pull request touching AI code, and pair it with sampled online scoring to catch real-world drift.
  10. Cross-Tool Synergy: Self-Verifying Agent Engineering — Evals unlock autonomous coding agents! When your spec.md defines target eval metrics and an isolated git worktree runs promptfoo as its local verification loop, an agent can iterate safely until proven better than production.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Keep this page beside your editor and CI dashboard. Almost every noisy score swing, false-green build, or surprise judge invoice maps directly to one of seven structural eval bugs below.

### Prompt Injection & Agent Security

> Defending tool-calling and browsing AI agents against indirect prompt injection, poisoned MCP servers, secret exfiltration, and unsafe output sinks.

- Web: https://twelve-pages.com/guides/agent-engineering/prompt-injection-and-agent-security
- Markdown: https://twelve-pages.com/guides/agent-engineering/prompt-injection-and-agent-security.md
- PDF: https://twelve-pages.com/guides/agent-engineering/prompt-injection-and-agent-security/Prompt_Injection_and_Agent_Security_Complete_How_To_Guide.pdf (3.4 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Lethal Trifecta Defense, OWASP LLM Top 10 (2025), Least-Privilege Tool Gates, Docker & MicroVM Sandboxes, MCP Supply-Chain Pinning, promptfoo CI Red-Teaming
- Core Takeaways:
  - Break the Lethal Trifecta: Neutralize silent data theft by severing the bridge between private data, untrusted inputs, and outbound network egress.
  - Architecture Over Prompts: Replace fragile “never leak secrets” wishes with deterministic sandboxes, argv sinks, and proxy-brokered credentials.
  - Continuous Red-Team Proof: Attack your own agents automatically on every pull request with promptfoo injection, BOLA, and exfiltration probes.
- Chapters:
  1. Why System Prompts Fail & The Lethal Trifecta — “A large language model receives instructions and data through the same channel and cannot reliably tell them apart.” Unlike parameterized SQL or CPU privilege rings, an LLM flattens your system prompt, user chat, fetched web pages, emails, and tool results into one shared token stream.
  2. Threat Landscape & OWASP LLM Top 10 Matrix — Do not confuse classic web security with AI risks: OWASP maintains separate guides for traditional web apps, the Top 10 for LLM Applications (LLM01–LLM10, 2025 edition + Aug 2026 update), and the Top 10 for Agentic Applications (ASI01–ASI10).
  3. Annotated Tour: Agent Security Gate & Inspector — Watch how a hardened agent harness handles a live indirect prompt-injection attack inside a public GitHub issue. Even though the LLM attempts to follow the hidden payload, deterministic runtime policies neutralize every step.
  4. Direct vs. Indirect Injection & Exfiltration Anatomy — Direct injection happens when a user types an attack into their own chat box. Indirect injection is far more dangerous: an external attacker plants instructions inside a web page, Jira ticket, PR diff, PDF, or email that your victim agent reads autonomously.
  5. Least-Privilege Tool Scoping & Human-in-the-Loop — Excessive Agency (LLM06) turns minor prompt hiccups into production incidents. Never hand an autonomous loop a master key simply because approving actions felt slow—scope every tool to the narrowest capability the task requires.
  6. OS, Container & MicroVM Sandboxing + Egress — When an agent runs shell commands, tests, or file parsers against untrusted inputs, assume prompt injection will eventually occur—and make the resulting compromise completely boring. Never run autonomous tool loops directly as your host user with ~/.ssh or ~/.aws mounted.
  7. MCP Supply-Chain Safety, Output Sinks & Secrets — Connecting third-party Model Context Protocol (MCP) servers imports external code and hidden tool descriptions straight into the most trusted section of your prompt—while unvalidated model outputs re-open classic RCE, SQLi, and XSS holes.
  8. 5 Real-World Copy-Paste Security Recipes — Drop these five battle-tested patterns straight into your Python/TypeScript agent harness, Docker runner, MCP client config, and chat UI renderer to replace wishful prompting with real engineering boundaries.
  9. Automated Red-Teaming & CI Gates with promptfoo — You never truly know your agent's failure modes until you attack them systematically. Open-source promptfoo generates dynamic multi-turn jailbreaks, indirect injections, cross-tenant BOLA probes, and sink exploits on every pull request.
  10. Defense-in-Depth Synergy: End-to-End Pipeline — Because no single guardrail stops every novel payload, resilient agent engineering stacks orthogonal controls—so an attacker who fools the model still crashes into schema limits, microVM walls, and outbound proxy blocks.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Keep this final page open during architecture reviews and incident triage. Every common agent security symptom maps directly to an architectural gap you can close deterministically.

### Local & On-Device AI Stack

> Running private, zero-per-token LLMs and embeddings on your own hardware—mastering GGUF quantization, Apple Silicon memory math, Ollama, and llama.cpp.

- Web: https://twelve-pages.com/guides/agent-engineering/local-and-on-device-ai
- Markdown: https://twelve-pages.com/guides/agent-engineering/local-and-on-device-ai.md
- PDF: https://twelve-pages.com/guides/agent-engineering/local-and-on-device-ai/Local_and_On_Device_AI_Stack_Complete_How_To_Guide.pdf (3.5 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Ollama • llama.cpp • MLX, Q4_K_M & imatrix Math, Unified RAM & num_ctx, localhost:11434/v1 Swap, Zero-Cost Local Embeddings, Air-Gapped Hybrid Routing
- Core Takeaways:
  - 100% Air-Gapped Privacy: Keep client contracts, unreleased source code, and sensitive notes strictly on loopback silicon—unplug Wi-Fi and keep working.
  - Zero Per-Token Economics: Embed millions of chunks, classify nightly batches, and run background triage agents for $0.00 beyond wall-outlet electricity.
  - One-Line OpenAI Swap: Write against standard /v1/chat/completions and /v1/embeddings routes so switching local vs. frontier cloud is pure config.
- Chapters:
  1. Own the Other Half: The Local AI Mental Model — Local inference is not a replacement for frontier cloud models—it is the complementary second engine sitting right under your desk. Mastering the four layers underneath localhost lets you run private workloads for free and diagnose instantly when a local model feels slow or forgetful.
  2. Runtime & Format Matrix + Hardware Sizing — Most frustration in local AI comes from picking the wrong container format for your chip or pulling a model whose KV cache quietly exceeds usable RAM. Match your runtime and weight size to your metal first.
  3. Annotated Tour: Local Inference & Memory Telemetry — Never guess whether your model is running on the GPU, truncating your prompt, or spilling into slow CPU swap. Here is how to read every critical signal across ollama ps, llama-server logs, and your active Modelfile.
  4. Quantization Demystified: FP16 Down to IQ3_M — A 32-billion-parameter model occupies 64 GB in raw 16-bit floats—impossible on a 32 GB laptop. Quantization compresses those weights down toward 4–5 bits per parameter, shrinking the file to ~19.5 GB while retaining roughly 95–97% of reference capability.
  5. Unified Memory Math & The num_ctx Trap — On Apple Silicon, CPU, GPU, and Neural Engine cores share a single high-bandwidth memory pool without slow PCIe copies—yet that shared pool must simultaneously hold macOS, your IDE, model weights, and a KV cache that grows linearly with every token.
  6. Ollama CLI, Structured Outputs & The SDK Swap — Once ollama serve is running, you manage weights like Docker images from your terminal and call them from Python or TypeScript using the exact same official openai client you already ship in production.
  7. Local Embeddings, Speed Tuning & brain.py RAG — Local embeddings are the single highest-ROI workload in on-device AI: encoder models weigh only 270 MB–1.2 GB, embed thousands of chunks for $0.00, and never break your vector database when a cloud vendor retires an API model.
  8. 5 Real-World Copy-Paste Local Stack Recipes — Drop these five battle-tested configurations straight into your shell or Python service to lock in memory-safe context windows, cloud fallback routing, deterministic schemas, and raw llama-server speed.
  9. Hybrid Local + Cloud Routing & Coding Agents — The sharpest engineers in 2026 rarely run 100% cloud or 100% local. They wire a Hybrid Split: free, instant, private local models handle high-frequency autocomplete, repo indexing, and log triage, while frontier cloud APIs step in only for deep multi-file architecture.
  10. Cross-Tool Synergy: Private Hybrid Agent Pipeline — Watch how local encoders, quantized local chat models, policy gates, and optional cloud escalation combine into a fast, privacy-preserving engineering assistant that handles 80% of daily queries for $0.00.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Keep this page handy whenever a local model crawls, forgets instructions, or mangles JSON. Nearly every local AI failure traces back to one of seven mechanical root causes—each solvable in seconds.

### Jev & System One Decisions

> Replacing fragile LLM JSON parsing with fast, calibrated System One decisions—mastering Choice, Score, and Noul primitives, parallel fan-out, and confidence-gated routing.

- Web: https://twelve-pages.com/guides/agent-engineering/jev-and-system-one-decisions
- Markdown: https://twelve-pages.com/guides/agent-engineering/jev-and-system-one-decisions.md
- PDF: https://twelve-pages.com/guides/agent-engineering/jev-and-system-one-decisions/Jev_and_System_One_Decisions_Complete_How_To_Guide.pdf (2.7 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Choice • Score • Noul, RLCD Calibrated Probabilities, Parallel Speculative Fan-Out, Confidence-Gated Routing, typesafe-sdk & @typesafe-ai/sdk, LLM Guardrails & RAG Reranking
- Core Takeaways:
  - Judgment vs. Decision: Jev supplies calibrated probabilities; your ordinary if statements own every branch, tool call, and mutation.
  - One Call, Many Questions: Evaluate 10+ independent questions in parallel at near-constant latency—$0.042/M input tokens and $0 output tokens.
  - Uncertainty You Can Gate: Trained via RLCD so low-confidence edge cases escalate cleanly to humans or frontier models instead of hallucinating.
- Chapters:
  1. Why JSON.parse() Breaks & The System One Contract — Most production AI bugs live in the glue layer where you prompt a chat model for a paragraph and write brittle regex or schema parsers to extract a boolean or route key. System One models delete that parsing layer entirely.
  2. Four Paths to First Decision & Architecture Matrix — Every client speaks the exact same JSON contract over POST https://api.typesafe.ai/v1/systemone. Start in the browser Playground in 60 seconds, then drop the Python or TypeScript SDK into your server routes.
  3. Annotated Tour: System One Playground & Inspector — Open console.typesafe.ai/playground to test state filtering and question criteria interactively before writing code. Here is how a single parallel request evaluates all three primitives at once.
  4. Mastering the Three Primitives: Choice, Score & Noul — Every judgment in System One maps to one of three shapes. Choose by the mathematical structure of the answer you need—and batch all of them into a single request.
  5. State Craft: Why Input Hygiene Is 80% of Accuracy — Unlike chat sessions where teams dump entire database rows into context “just in case,” Jev accuracy drops sharply when state contains irrelevant noise. Filter ruthlessly in code before calling the API.
  6. Confidence Gating & The Four Core Patterns — Rank with probabilities; gate automation with confidence. Calibration applies across populations, not single calls—so risk-sensitive actions always pair answer values with explicit confidence floors.
  7. Production Blueprint: One-File Policy & Quality Gates — Keep every question definition and numeric threshold inside one dedicated policy file (lib/decisions.ts) so product and security reviews read a single 60-line file instead of hunting across route handlers.
  8. 5 Real-World Copy-Paste System One Recipes — Drop these five patterns into your Python or TypeScript stack to replace dedicated cross-encoders, binary moderation walls, and flaky LLM-judge parsers.
  9. Know the Edges: jev-1.13 Jaggedness & Hard Rules — TypeSafe publishes explicit failure modes (“jaggedness”) for jev-1.13. Respecting what Jev cannot do is what separates rock-solid production pipelines from mysterious accuracy drops.
  10. Cross-Tool Synergy: The System 1 + System 2 Sandwich — Kahneman's Thinking, Fast and Slow becomes a concrete software architecture when you wrap fast, sub-cent System One judgments (Jev) on both sides of slow, creative System Two reasoning (Claude, GPT, Gemini).
  11. Troubleshooting Clinic & Pre-Flight Checklist — Keep this page next to your lib/decisions.ts policy file. Nearly every surprising probability or API error maps to one of seven mechanical fixes below.

### Building Production MCP Servers

> Architect, test, and ship high-reliability Model Context Protocol servers in TypeScript (SDK v2) and Python (FastMCP)—mastering stateless Streamable HTTP factories, Zod v4 & outputSchema, OAuth 2.1, MCP Inspector, and 10-question evals.

- Web: https://twelve-pages.com/guides/agent-engineering/building-production-mcp-servers
- Markdown: https://twelve-pages.com/guides/agent-engineering/building-production-mcp-servers.md
- PDF: https://twelve-pages.com/guides/agent-engineering/building-production-mcp-servers/Building_Production_MCP_Servers_Complete_How_To_Guide.pdf (3.9 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: TypeScript SDK v2, Python FastMCP, Streamable HTTP & stdio, Zod v4 & outputSchema, OAuth 2.1 & Tool Hints, MCP Inspector & Evals
- Core Takeaways:
  - SDK v2 & FastMCP: Build schema-strict tools in TypeScript @modelcontextprotocol/server v2 or Python FastMCP with Pydantic v2 validation.
  - Stateless Factories: Spawn a fresh McpServer per HTTP request while pooling upstream clients at module scope for effortless horizontal scale.
  - Evaluated Reliability: Verify contracts with scripts/smoke.ts, MCP Inspector, and a 10-question multi-hop evaluation harness before shipping.
- Chapters:
  1. Agent-Centric Design vs. Raw REST Wrappers — An MCP server is not a thin proxy over HTTP endpoints—it is an ergonomic user interface for a language model. Great servers pack high-signal data into tight context budgets while keeping destructive actions crystal clear.
  2. SDK v2 Setup, v1-to-v2 Migration & Transports — Always start new TypeScript servers on SDK v2 (@modelcontextprotocol/server) with zod ^4.2.0 and Node >=20.3, or build in Python with FastMCP and Pydantic v2. Never mix v1 and v2 imports inside one repository.
  3. Annotated Tour: MCP Inspector & JSON-RPC Trace — Launch npx @modelcontextprotocol/inspector node dist/index.js to test every schema, behavioral hint, error banner, and live JSON-RPC frame before connecting an agent host.
  4. The Stateless createServer() Factory & Dual Transports — The single most important architectural rule in TypeScript SDK v2 is isolating per-request protocol state inside a cheap createServer() factory while keeping heavy upstream clients pooled at module scope.
  5. Tool Registration Anatomy: Schemas & Hints — Every tool registration defines a machine-verifiable contract: strict Zod v4 input validation, behavioral hints for host approval UIs, cancellation-aware upstream calls, and item-halving pagination under CHARACTER_LIMIT.
  6. Python FastMCP & Pydantic v2 Production Patterns — In Python, mcp.server.fastmcp turns typed Pydantic v2 models and docstrings directly into JSON Schemas. Pair strict ConfigDict settings with a shared httpx.AsyncClient and async lifespan hooks.
  7. Error Channels, OAuth 2.1 Auth & Hardening — Remote MCP servers must separate model-facing recovery hints from client-level JSON-RPC errors, enforce resource-scoped OAuth 2.1 tokens, and treat every upstream payload and path parameter as untrusted.
  8. 5 Real-World Copy-Paste MCP Recipes — Drop these five production primitives directly into your TypeScript v2 or Python FastMCP server to eliminate common protocol bugs, context overflows, and silent startup failures.
  9. Packaging, Distribution & Multi-Host Rollout — Ship one predictable server artifact across local laptops and cloud clusters. Clean entrypoints, minimal Docker images, and portable JSON configs let teams adopt your tools in seconds.
  10. Cross-Tool Synergy & 10-Question Eval Pipeline — Compiling cleanly only proves syntax. True MCP quality is measured by whether a cold LLM—given only your tool schemas and descriptions—can solve realistic, multi-hop research tasks without getting lost.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Diagnose the seven most common MCP production failures in ten seconds, then clear the six-point pre-flight gate before publishing or deploying.

### Browser Agents with Chrome DevTools MCP & Playwright

> Pair live Chrome DevTools MCP diagnostics (accessibility uid snapshots, LCP subpart traces, HttpOnly cookie forensics, and heap leak diffs) with deterministic Playwright E2E regression gates.

- Web: https://twelve-pages.com/guides/agent-engineering/chrome-devtools-and-playwright-agents
- Markdown: https://twelve-pages.com/guides/agent-engineering/chrome-devtools-and-playwright-agents.md
- PDF: https://twelve-pages.com/guides/agent-engineering/chrome-devtools-and-playwright-agents/Chrome_DevTools_and_Playwright_Agents_Complete_How_To_Guide.pdf (3.9 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: chrome-devtools-mcp, Accessibility uid Snapshots, LCP & CWV Traces, Cookie & Auth Forensics, Heap Leak Diffing, Playwright CI Specs
- Core Takeaways:
  - Live DevTools Telemetry: Inspect accessibility uid nodes, authoritative CSS cascades, network headers, and 4-part LCP breakdowns in real time.
  - Zero-Flake E2E Gates: Lock every verified bug fix into resilient Playwright specs with user-facing locators, auto-waiting assertions, and trace bundles.
  - Safe Auth & Security: Diagnose HttpOnly sessions via network headers, run clean-slate GDPR checks in isolatedContext, and respect bot gates.
- Chapters:
  1. Live Telemetry Diagnosis vs. Deterministic Regression Gates — Traditional browser automation asks an agent to guess pixel coordinates from heavy screenshots. Modern browser engineering splits the job in two: Chrome DevTools MCP acts as your agent's live diagnostic microscope, while Playwright locks each verified fix into a repeatable CI regression gate.
  2. Setup, Capability Flags & Tool Selection Matrix — By default, chrome-devtools-mcp launches automatically on the first tool call using a persistent Chrome profile. Unlock extension and memory forensics with opt-in CLI flags, then pair them with headless Playwright in your repo.
  3. Annotated Tour: The Dual-Mode Browser Agent Cockpit — Effective browser agents correlate live DevTools MCP telemetry with repeatable Playwright test verdicts. Below is the unified mental workspace your agent inspects across accessibility trees, CSS cascades, LCP waterfalls, network headers, and CI traces.
  4. Token-Lean Navigation, uid Snapshots & A11y Audits — Disciplined browser agents follow one strict sequence: navigate → wait → snapshot → interact. Because take_snapshot returns the browser's accessibility tree rather than raw HTML, it serves double duty as your fastest interaction map and your semantic screen-reader truth.
  5. Core Web Vitals, LCP Forensics & Diagnostic Prompt Anatomy — Good Largest Contentful Paint (LCP) stays at or below 2.5 seconds (2.5–4.0s needs improvement; >4.0s is poor). Because compressing an image will not fix a slow server or blocked stylesheet, always decompose LCP into its four sequential subparts first.
  6. Auth Cookies, Consent Conformance & Memory Leak Hunting — Two browser bugs fool naive agents every week: trying to read or delete HttpOnly session cookies from client JavaScript, and reading raw multi-megabyte .heapsnapshot JSON files instead of letting Chrome DevTools MCP compute retainer diffs.
  7. Playwright Agent Mastery: Locators, Traces, MV3 & Instant UI — Once DevTools MCP proves what is broken and verifies your patch, encode the behavior in Playwright so it can never silently regress. Follow five strict rules to keep agent-written specs fast, readable, and completely flake-free.
  8. 5 Real-World Copy-Paste Browser Agent Recipes — Drop these five battle-tested workflows directly into your agent instructions or repository test suite to eliminate performance bottlenecks, auth cookie mysteries, consent leaks, detached DOM bloat, and flaky E2E runs.
  9. Security Boundaries, Bot Gates & Safe Browser Operations — Giving an AI agent a real browser exposes it to hostile web content, live user credentials, and anti-abuse gates. Enforce strict engineering boundaries so autonomous debugging never crosses security, compliance, or privacy lines.
  10. Cross-Tool Synergy: From Live Forensics to CI Merge Gate — Separately, DevTools MCP finds bugs once and Playwright catches regressions later. Wired together into one agent workflow, every live telemetry discovery becomes an automated, permanently enforced pull-request test.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Keep this cheat sheet beside your MCP config and CI pipeline. Almost every browser-agent stall, token explosion, or flaky test failure maps directly to one of these seven root causes.

### Sandboxes & Isolated Execution for AI Agents

> Architecting ephemeral microVMs, Firecracker, E2B, Docker, and gVisor environments for safe autonomous code execution, snapshotting, and network egress control.

- Web: https://twelve-pages.com/guides/agent-engineering/sandboxes-and-isolated-execution
- Markdown: https://twelve-pages.com/guides/agent-engineering/sandboxes-and-isolated-execution.md
- PDF: https://twelve-pages.com/guides/agent-engineering/sandboxes-and-isolated-execution/Sandboxes_and_Isolated_Execution_for_AI_Agents_Complete_How_To_Guide.pdf (4.2 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Firecracker microVMs, E2B & Cloud Sandboxes, Docker & gVisor Limits, CoW Snapshot & Resume, Zero-Trust Egress Filtering, cgroups v2 & PTY Streaming
- Core Takeaways:
  - Sub-50ms Cold Starts: Instant KVM microVM instantiation via pre-warmed snapshot pools and stripped minimalist guest Linux kernels.
  - Zero-Trust Containment: Hard hardware virtualization preventing shared kernel escapes, credential exfiltration, fork bombs, and silent disk pollution.
  - Bidirectional PTY Streaming: Real-time interactive stdio streams, ANSI terminal emulation, and deterministic filesystem diff tracking for agent verification.
- Chapters:
  1. The Sandbox Boundary: Host vs. Guest Architecture — Autonomous coding agents must run arbitrary bash scripts, compile dependencies, and test untrusted code without putting host servers, development machines, or cloud credentials at risk.
  2. The Isolation Spectrum: From Containers to MicroVMs — Choosing the right sandbox architecture requires balancing boot speed, syscall fidelity, and blast-radius security. Running untrusted AI code demands virtualization with hardware boundaries.
  3. Annotated Workspace: Sandbox Session Monitor — High-reliability agent platforms provide an interactive dashboard and telemetry console to supervise live microVMs, inspect file diffs, enforce timeouts, and intercept network egress.
  4. Firecracker & KVM: Sub-50ms MicroVM Instantiation — Amazon Firecracker strips away legacy PC peripherals, BIOS emulations, and complex ACPI tables, delivering minimalist virtual machines that boot in under 35 milliseconds with under 5MB memory overhead.
  5. Copy-on-Write Storage & Instant Memory Snapshots — By decoupling the immutable golden rootfs from mutable agent scratch space, microVMs achieve instantaneous state snapshotting, branchable evaluation forks, and zero-risk rollbacks.
  6. Zero-Trust Network Egress & Credential Quarantine — Autonomous agents running untrusted code face indirect prompt injection attacks designed to exfiltrate private codebases, SSH keys, or cloud credentials. Strict egress filtering is mandatory.
  7. Agent-to-Sandbox Runtime Protocol & Streaming stdio — Executing tool commands requires robust IPC: handling interactive user prompts, streaming ANSI color output to LLM context, managing background daemons, and terminating runaway fork bombs.
  8. Five Copy-Paste Recipes for Production Sandboxes — Battle-tested recipes for common agent use cases—from disposable Python data interpreters and autonomous bugfix loops to multi-tenant team eval harnesses.
  9. Enterprise Sandboxes, CI/CD & Cost Economics — Scaling sandbox infrastructure requires choosing between managed cloud providers and self-hosted clusters, tracking OpenTelemetry spans, and optimizing idle warm-pool expenses.
  10. The End-to-End Synergy Pipeline: From Prompt to Verified PR — How modern agent frameworks integrate sandboxes across the development lifecycle—orchestrating code generation, isolated test execution, security scanning, and automated Git pull requests.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Rapid diagnostic solutions for the top seven sandbox failure modes, paired with a mandatory pre-flight readiness checklist for production agent deployments.

### Orca Multi-Agent Workspace & CLI

> Orchestrate parallel AI coding agents across isolated Git worktrees, coordinator-worker task DAGs, inline diff annotations, embedded browser captures, and remote SSH or mobile runtimes.

- Web: https://twelve-pages.com/guides/agent-engineering/orca-multi-agent-workspace-and-cli
- Markdown: https://twelve-pages.com/guides/agent-engineering/orca-multi-agent-workspace-and-cli.md
- PDF: https://twelve-pages.com/guides/agent-engineering/orca-multi-agent-workspace-and-cli/Orca_Multi_Agent_Workspace_and_CLI_Complete_How_To_Guide.pdf (2.3 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Isolated Git Worktrees, Parallel CLI Fleet, Task DAG Orchestration, Inline Diff Annotations, Browser & Computer Use, SSH & Mobile Pairing
- Core Takeaways:
  - Zero-Collision Worktrees: Every agent gets its own real Git worktree and branch, letting Claude Code, Codex, OpenCode, and Gemini CLI edit concurrently without conflicts.
  - Supervised DAGs & Handoffs: Transfer standalone tasks in a single command or run coordinator-worker dependency graphs with durable mailboxes and explicit decision gates.
  - Unified Review & Remote Ops: Annotate agent diffs line by line, pipe Design Mode DOM captures into prompts, drive background desktop apps, and steer builds from mobile.
- Chapters:
  1. The Orca Mental Model: Worktrees, Fleet & Runtime — Traditional editors assume one human typing in one branch at a time. Orca is an open-source Agent Development Environment (ADE) designed as a mission control room for parallel coding agents you already own.
  2. Executable Resolution & Orchestration Mode Matrix — Because Orca runs across macOS, Linux, WSL, and source dev checkouts, choosing the right CLI executable once at session start prevents hitting the wrong runtime or triggering OS screen readers.
  3. Annotated Workspace: The Orca Command Center — Orca unifies worktree lineage, WebGL terminal panes, task mailboxes, line-level diff annotations, and an embedded Chromium preview inside one keyboard-driven desktop window.
  4. Parallel Git Worktrees, Lineage & Full Handoffs — Every Orca worktree pairs a real Git checkout on disk with tracked runtime metadata, ensuring parallel agents never trample each other's branches, caches, or dev servers.
  5. Coordinator Loops, Task DAGs & Decision Gates — When an agent must delegate work to specialized peers and collect verified deliverables back, Orca Orchestration replaces brittle terminal scraping with structured Runs, dependency tasks, and durable mailboxes.
  6. Diff Annotations, Embedded Browser & Computer Use — Reviewing AI code should feel faster than writing it by hand. Orca connects line-by-line code annotations, worktree-scoped browser automation, and background desktop GUI control directly back to your agents.
  7. Terminal Splits, Session Search & Scheduled Automations — Beyond interactive supervision, Orca turns every terminal, port listener, historical transcript, and recurring cron prompt into a scriptable building block.
  8. Five Copy-Paste Recipes for Multi-Agent Workflows — Ready-to-run patterns combining parallel worktrees, cross-model comparisons, UI feedback capture, remote SSH builds, and scheduled automation guards.
  9. Remote SSH Hosts, Mobile Supervision & Safety — Offload heavy agent fleets onto dedicated Linux workstations or cloud VMs with orca serve, monitor progress from iOS or Android, and isolate credentials across accounts.
  10. End-to-End Synergy: Issue Link to Verified Pull Request — See how Orca coordinates issue trackers, multi-vendor coding CLIs, visual browser QA, human review annotations, and automated cleanup into one cohesive shipping loop.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Fast, verified remedies for the seven most common Orca CLI and multi-agent pitfalls, followed by a six-point readiness checklist before launching parallel fleets.

### Agentic Observability & Prompt Caching

> Instrument multi-agent workflows with OpenTelemetry GenAI trace trees, maximize static-first KV cache hit rates, compact historical tool outputs, and route models for predictable token FinOps.

- Web: https://twelve-pages.com/guides/agent-engineering/agentic-observability-and-prompt-caching
- Markdown: https://twelve-pages.com/guides/agent-engineering/agentic-observability-and-prompt-caching.md
- PDF: https://twelve-pages.com/guides/agent-engineering/agentic-observability-and-prompt-caching/Agentic_Observability_and_Prompt_Caching_Complete_How_To_Guide.pdf (2.3 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: OTel gen_ai.* Spans, Cache Breakpoints & TTLs, Tool-Output Compaction, Subagent Trace Trees, Cheap-to-Frontier Routing, Eval-Linked FinOps
- Core Takeaways:
  - Up to 90% Cache Savings: Reuse stable system instructions, tool schemas, and frozen turns at 0.1x read pricing instead of paying full input rates every step.
  - Unified Multi-Agent Traces: Carry W3C traceparent context across subagent handoffs and MCP servers so nested calls appear in one clean waterfall.
  - Eval-Linked Cost Control: Track time to first token, reasoning tokens, and cost per task side by side with Langfuse or Arize AX evaluation scores.
- Chapters:
  1. The Telemetry & Caching Mental Model: Trace First, Cache the Prefix — Because multi-turn agents resend their full conversation history on every step, uncached agent loops create quadratic token bills. Combining OpenTelemetry GenAI spans with prefix caching keeps unit economics predictable and failures transparent.
  2. Provider Prompt Caching & OTel Telemetry Matrix — Every major model provider handles prefix reuse differently. Knowing minimum token floors, write multipliers, and TTL timers lets you avoid silent cache misses and map exact usage fields into OpenTelemetry.
  3. Annotated Workspace: Trace Waterfall & Cache-Hit HUD — Modern tracing dashboards such as Langfuse and Arize AX combine distributed OpenTelemetry timelines with token ledgers and online eval scores so you can diagnose slow turns or cache misses in seconds.
  4. OpenTelemetry GenAI Spans, Metrics & Subagent Propagation — Vendor-neutral gen_ai.* spans let your agents switch between Anthropic, OpenAI, and Gemini without rewriting telemetry pipelines, while W3C trace propagation keeps distributed subagent trees intact.
  5. Static-First Prefix Ordering & Cache Breakpoint Architecture — Provider KV caches match prompts strictly from byte zero forward. One dynamic timestamp or reordered tool schema near the top of your payload invalidates every downstream token on every turn.
  6. Tool-Output Compaction & Dynamic Cheap-to-Frontier Routing — Long-horizon agents quickly accumulate tens of thousands of stale search logs and file dumps. Compaction keeps working memory crisp, while dynamic routing protects margins from verbose reasoning output costs.
  7. Implementing Cache Breakpoints, Compaction & Cost Ledgers — Translate prefix rules into explicit provider payloads and build a ledger-accurate cost calculator that weights cache writes, 0.1x cache reads, reasoning tokens, and loop circuit breakers.
  8. Five Copy-Paste Recipes for Observable, Cached Agents — Ready-to-deploy patterns covering framework telemetry hooks, multi-provider cache breakpoints, explicit context bundles, subagent span stitching, and OpenTelemetry Collector normalization.
  9. PII Redaction in Traces, Budget Alerts & FinOps Rollout — Production observability must protect customer secrets and stop runaway agent loops before they generate surprise invoices. Enforce privacy defaults at the Collector edge and roll out optimizations in measured stages.
  10. End-to-End Synergy: Tracing, Caching, Routing & Evals in Harmony — How deterministic prompt builders, dynamic model routers, provider KV caches, OTel Collectors, and trace-linked evaluation platforms connect into one continuous cost-and-quality flywheel.
  11. Troubleshooting Clinic & Pre-Flight Readiness Checklist — Rapid ten-second fixes for the seven most frequent caching and telemetry issues, followed by a six-point readiness gate before shipping autonomous agents to production.

### Structured Outputs & State Machines

> Eliminate fragile regex loops with CFG/FSM constrained decoding, Pydantic v2 and Zod v4 contracts, streaming partial objects, explicit transition tables, idempotency, and HITL approval gates.

- Web: https://twelve-pages.com/guides/agent-engineering/structured-outputs-and-state-machines
- Markdown: https://twelve-pages.com/guides/agent-engineering/structured-outputs-and-state-machines.md
- PDF: https://twelve-pages.com/guides/agent-engineering/structured-outputs-and-state-machines/Structured_Outputs_and_State_Machines_Complete_How_To_Guide.pdf (2.6 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: CFG & FSM Logit Masking, OpenAI, Claude & Gemini Schemas, Pydantic v2 & Zod v4, Streaming Partial Objects, Explicit Transition Tables, Idempotency & HITL Gates
- Core Takeaways:
  - Zero-Syntax-Error Decoding: Compile JSON Schemas into token grammars that mask illegal characters to negative infinity before sampling.
  - Cognition vs. Control: Confine probabilistic model reasoning inside typed step outputs while deterministic tables govern every transition.
  - Durable Production Loops: Pair bounded semantic repair retries with idempotency ledgers, checkpoints, and human-approval gates.
- Chapters:
  1. The Core Mental Model: Separating Cognition from Control — Early agent prototypes let language models steer execution through free-form chat loops and brittle regex parsing. Production systems flip that design: the model acts as a typed cognitive oracle, while a deterministic state machine owns every transition.
  2. Provider Schema Support & State Engine Decision Matrix — Every major model API and serving engine supports constrained decoding in 2026, yet each enforces distinct schema rules. Pick the right schema surface and orchestration layer before writing code.
  3. Annotated Inspector: Schema & State-Transition HUD — Debuggable agent platforms combine a live grammar bitmask trace with an explicit finite-state inspector so engineers can see why a token passed, why a semantic repair ran, and which guard halted execution.
  4. How CFG & FSM Logit Masking Guarantee Zero Syntax Errors — Prompts cannot enforce formal syntax reliably across thousands of runs. Constrained decoding solves formatting at the token-sampling layer by masking illegal vocabulary choices before a token is ever picked.
  5. Pydantic v2, Zod v4 & Discriminated-Union Contracts — Maintain a single source of truth for schemas, runtime checks, and compiler types. Modern Zod v4 and Pydantic v2 export strict JSON Schemas natively while validating domain math and discriminated-union tags.
  6. Streaming Partial JSON & Bounded Validation-Repair Loops — Waiting for a complete JSON payload makes interactive apps feel frozen. Incremental parsers render partial objects live as tokens arrive, while capped validation-feedback loops self-heal semantic mistakes cleanly.
  7. Explicit Transition Tables, Loop Breakers & Approval Gates — An agent loop is safest when every state, allowed event, guard condition, and exit ceiling lives in an explicit transition table. The language model proposes events; deterministic code decides whether they execute.
  8. Five Copy-Paste Production Recipes — Proven implementation blueprints covering strict extraction, discriminated-union routing, streaming partial interfaces, self-healing validators, and durable human-approved tool execution.
  9. Idempotency, Checkpointing & Dead-Letter Transitions — Structured outputs protect what enters your state machine; idempotency keys, durable checkpoints, and dead-letter queues protect what happens when workers crash mid-flight or upstream APIs time out.
  10. End-to-End Synergy: Typed Ingress to Durable Execution — When Zod v4 or Pydantic v2 contracts drive both provider token masking and your statechart transitions, every layer reinforces the next—turning stochastic text generation into verifiable software engineering.
  11. Troubleshooting Clinic & Production Pre-Flight Checklist — Use this field clinic to diagnose the seven most frequent structured-output and state-machine failures in seconds, followed by six readiness gates every agent must clear before production traffic.

### Voice-First Coding & Capture Workflows

> Turn spoken architectural intent into code and notes with mlx-whisper and Superwhisper, codebase symbol glossaries, voice PR diff triage, and automated Obsidian _inbox/ capture pipelines.

- Web: https://twelve-pages.com/guides/agent-engineering/voice-first-coding-and-capture-workflows
- Markdown: https://twelve-pages.com/guides/agent-engineering/voice-first-coding-and-capture-workflows.md
- PDF: https://twelve-pages.com/guides/agent-engineering/voice-first-coding-and-capture-workflows/Voice_First_Coding_and_Capture_Workflows_Complete_How_To_Guide.pdf (2.3 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: mlx-whisper & Handy, Superwhisper & Wispr Flow, Custom Code Dictionaries, Spoken Spec-to-Plan, Voice PR & Terminal Triage, Obsidian & GitHub Pipelines
- Core Takeaways:
  - 3x Faster Intent Bandwidth: Speak nuanced architecture, edge cases, and acceptance criteria at 160+ words per minute while coding agents handle exact syntax.
  - Zero-Garble Code Vocab: Prime Whisper initial_prompt glossaries, active IDE context, and Superwhisper MCP sync to nail every symbol and CLI flag.
  - Local-First Privacy & Capture: Run offline Apple Silicon models with Silero VAD gating, automatic secret scrubbing, and seamless voice-memo-to-Obsidian triage.
- Chapters:
  1. The Complementarity Rule: Speech for Intent, Agents for Syntax — Effective voice coding does not mean reading curly braces and semicolons aloud. Instead, voice acts as a high-bandwidth channel for architectural intent while coding agents translate that intent into clean, type-checked diffs.
  2. Acoustic Setup, VAD Gating & Dictation Engine Matrix — Transcription accuracy depends just as much on microphone proximity and silence detection as on model size. Choose an engine tier that matches your latency target, privacy boundary, and operating system.
  3. Annotated Workspace: Voice-to-Agent HUD & Vocabulary Panel — Modern voice coding pairs a lightweight acoustic capture HUD with live IDE context awareness and custom replacement dictionaries so spoken prompts land cleanly in your agent terminal.
  4. Spoken Spec-to-Plan Prompting for Coding Agents — Rambling voice prompts force coding agents to guess file boundaries and invariants. Structuring a 30-second spoken recording into five crisp slots turns conversational speech into an unambiguous engineering specification.
  5. Custom Code Vocabularies & Whisper Prompt Priming — Out-of-the-box speech models trained on podcasts routinely mangle programming jargon. Priming the decoder glossary, wiring replacement rules, and letting agents audit mis-transcriptions eliminates manual typo fixes.
  6. Voice-Driven PR Diff Walkthroughs & Terminal Triage — Code review is predominantly a reading and reasoning task. Speaking aloud as you scan a pull request lets you direct agent pre-reviews, classify noisy bot comments, and draft crisp technical replies in seconds.
  7. Voice-Memo-to-Obsidian +Inbox/ & GitHub Pipelines — Your sharpest architectural ideas rarely happen at your desk. An automated capture pipeline turns off-screen voice memos into linked Obsidian vault notes and actionable GitHub issues before you sit back down.
  8. Five Copy-Paste Recipes for Voice Coding & Capture — Practical blueprints you can deploy today—spanning zero-cloud Apple Silicon push-to-talk, agent-driven dictionary syncing, Obsidian inbox sorting, and multi-channel PR triage.
  9. Offline Privacy Zones, Secret Scrubbing & Team Etiquette — Bringing a live microphone into software engineering introduces real privacy, credential-hygiene, and workspace-etiquette stakes. Build hard local boundaries before dictating around proprietary repositories.
  10. End-to-End Voice Synergy: From Walking Thought to Merged PR — Voice workflows shine brightest when capture, transcription, vocabulary normalization, agent planning, and knowledge archiving link into one continuous pipeline across mobile and desktop tools.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Fast, reliable fixes for the seven most common voice-coding bottlenecks, followed by a six-point readiness check before shipping sensitive work by voice.

### AI Document & Web Scraping Pipelines

> Transform messy PDFs, Office suites, and JS-heavy websites into clean, chunked, citation-ready Markdown using Docling, Granite-Docling VLM, Crawl4AI fit_markdown, Firecrawl v2, and SHA-256 deduplication.

- Web: https://twelve-pages.com/guides/agent-engineering/ai-document-and-web-scraping-pipelines
- Markdown: https://twelve-pages.com/guides/agent-engineering/ai-document-and-web-scraping-pipelines.md
- PDF: https://twelve-pages.com/guides/agent-engineering/ai-document-and-web-scraping-pipelines/AI_Document_and_Web_Scraping_Pipelines_Complete_How_To_Guide.pdf (2.8 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: DoclingDocument & TableFormer, Granite-Docling VLM & OCR, Crawl4AI Async & CSS Schemas, fit_markdown Noise Pruning, Firecrawl v2 /extract & Actions, Sanitization & SHA-256 Dedup
- Core Takeaways:
  - Structure-First Parsing: Preserve reading order, merged table headers, formulas, and page provenance instead of flattening layouts into broken plain text.
  - Zero-Bloat Web Markdown: Strip navigation chrome, ads, and footers using PruningContentFilter and declarative schemas before tokens touch your LLM.
  - Hardened Ingestion Hygiene: Quarantine hidden prompt-injection lures, honor robots.txt crawl delays, and skip redundant embeds via SHA-256 hashing.
- Chapters:
  1. The Ingestion Boundary: Raw Files & Live Web to Clean Context — Retrieval systems and autonomous agents rarely fail because the language model cannot reason; they fail because noisy ingestion feeds scrambled tables, broken multi-column reading order, and sprawling navigation bars into the context window.
  2. Setup, Hardware Tiers & Extraction Engine Matrix — No single scraper handles every source well. Match PDFs, Office documents, open web crawls, and protected portals to the right local library or managed API before writing pipeline code.
  3. Annotated Workspace: Ingestion & Chunk Inspector HUD — Reliable data engineering pipelines expose live observability across every stage: source routing, token pruning ratios, prompt-injection drops, SHA-256 deduplication, and exact chunk provenance.
  4. Docling: PDF Layout, TableFormer & VLM Conversion — Developed by IBM Research, Docling replaces brittle text dumpers with deep layout analysis, converting PDFs, Word files, slide decks, and scanned archives into a structured DoclingDocument tree.
  5. Crawl4AI: Async Playwright, Pruning & Schema Extraction — Crawl4AI gives Python engineers direct programmatic control over headless Chromium instances—pairing concurrent crawling with heuristic Markdown noise pruning and deterministic CSS extraction schemas.
  6. Firecrawl v2: Mapping, Structured /extract & Change Tracking — Firecrawl v2 provides managed browser infrastructure, fast sitemap URL discovery, schema-guided JSON extraction, interactive page actions, and persistent change diffs over a clean REST and Python SDK.
  7. HybridChunker, Contextualization & Provenance Metadata — Clean Markdown is only half the ingestion pipeline. Naive character splitters tear apart Markdown tables and strip parent headings; structure-aware chunking preserves semantics and clickable citations.
  8. Five Copy-Paste Production Ingestion Recipes — Battle-tested patterns combining Docling, Crawl4AI, and Firecrawl across common engineering tasks—from local annual report extraction to live webhook-driven monitoring.
  9. Crawl Ethics, Prompt-Injection Quarantine & Deduplication — External websites and third-party PDFs are untrusted inputs. Production pipelines respect domain crawl rules, sanitize invisible adversarial instructions deterministically, and hash normalized text before embedding.
  10. End-to-End Synergy Pipeline: Discovery to Verified RAG — Rather than forcing one engine onto every workload, production teams route web links, interactive portals, and binary attachments to specialized extractors before merging everything into one clean index.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Rapid fixes for the seven most frequent document parsing and web scraping failure modes, paired with a mandatory six-point pre-flight check before launching production ingestion jobs.

## Obsidian & AI Knowledge Systems (6 Handbooks)

Topic Hub: https://twelve-pages.com/topics/obsidian

Publication-grade 12-page visual handbooks for turning Obsidian vaults into AI-native Second Brains—covering Claude Desktop & Antigravity Desktop workflows, multimodal Web Clipper/PDF/voice capture pipelines, native Bases & JSON Canvas, autonomous LLM Wikis, Graphify knowledge graphs, and multi-device vault security.

### Obsidian + Desktop AI Agents

> Operating your Obsidian vault side-by-side with Claude Desktop and Google Antigravity Desktop—mastering Cowork folders, Local REST API MCP, the native Obsidian CLI, vault AGENTS.md rules, and scheduled briefings.

- Web: https://twelve-pages.com/guides/obsidian/obsidian-desktop-ai-agents
- Markdown: https://twelve-pages.com/guides/obsidian/obsidian-desktop-ai-agents.md
- PDF: https://twelve-pages.com/guides/obsidian/obsidian-desktop-ai-agents/Obsidian_and_Desktop_AI_Agents_Complete_How_To_Guide.pdf (3.6 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Claude Desktop & Cowork, Antigravity Vault Projects, Local REST API MCP, Native Obsidian CLI, AGENTS.md & GEMINI.md, Scheduled Briefings
- Core Takeaways:
  - One Local Markdown Vault: Plain UTF-8 .md files on disk let Obsidian, Claude Desktop, and Antigravity Desktop collaborate live with zero cloud lock-in.
  - Surgical Live Patching: Append action items under target headings or update YAML frontmatter via MCP and the official CLI without rewriting long notes.
  - Automated Daily Rituals: Wake up to ready-made daily briefings combining Google Calendar agendas, Drive docs, and unfinished tasks on a weekday schedule.
- Chapters:
  1. Why Plain-Text Markdown Is the Ultimate Agent Workspace — Proprietary cloud note apps lock your thinking inside opaque database blocks and rate-limited APIs. An Obsidian vault is simply a local folder of plain .md files, YAML properties, and [[Wikilinks]]—giving desktop AI agents instant, native read/write fluency right beside you.
  2. Setup, 4 Vault Connection Modes & Decision Matrix — There are four distinct bridges between desktop AI agents and an Obsidian vault. Setting up all four takes under five minutes and lets you match every task to the fastest, safest transport.
  3. Annotated Tour: Dual-Desktop Agent + Obsidian Studio — Arranging Obsidian alongside Antigravity Desktop or Claude Desktop turns your screen into a live cockpit: you steer context on the left while watching structured notes, properties, and backlinks materialize on the right.
  4. Claude Desktop: Cowork Folders & Surgical MCP Patching — Claude Desktop shines when wired with two complementary vault tools: direct folder access for sweeping research synthesis, and mcp-obsidian over port 27124 for surgical single-heading and frontmatter edits.
  5. Antigravity Desktop: Vault Projects, @ Mentions & Skills — Opening your vault as a first-class Project in Google Antigravity Desktop turns a folder of notes into a programmable knowledge workspace with persistent rules, progressive-disclosure skills, and multimodal Chat Canvas drops.
  6. Vault Taxonomy, AGENTS.md Laws & Prompt Anatomy — AI agents thrive on predictable structure. A numbered six-folder taxonomy paired with a crisp AGENTS.md contract eliminates duplicate notes, malformed YAML frontmatter, and broken [[Wikilinks]].
  7. Native Obsidian CLI & Scheduled Daily/Weekly Rituals — Once registered via Settings → General → Command line interface → Register CLI, the official obsidian binary lets terminal scripts and Antigravity Scheduled Tasks drive the live Obsidian app directly.
  8. 5 Real-World Copy-Paste Vault Prompts & Recipes — Drop these five prompts straight into Antigravity Chat Canvas, Scheduled Tasks, or Claude Desktop. Each recipe obeys AGENTS.md YAML laws, protects existing prose, and produces verifiable [[Wikilinks]].
  9. Protecting .obsidian/ Configs & 10-Second Rollback Safety — Giving desktop AI agents write access to years of personal notes requires defense in depth. Three lightweight guardrails guarantee that an over-eager bulk edit can always be undone in under ten seconds.
  10. Cross-Tool Synergy: The Closed-Loop Second Brain — When mobile capture, Google Workspace signals, Antigravity scheduled routines, Claude Desktop deep synthesis, and Obsidian’s visual graph feed one another, your vault compounds in value every single week.
  11. Troubleshooting Clinic & 6-Point Pre-Flight Checklist — Nearly every hiccup between Obsidian, Claude Desktop, and Antigravity Desktop traces back to one of seven local configuration snags—each solvable in ten seconds.

### Obsidian Bases & JSON Canvas with AI

> Turning flat Markdown notes into live relational databases and spatial visual boards—having Claude Desktop and Antigravity generate native .base views, YAML schemas, and .canvas architecture maps.

- Web: https://twelve-pages.com/guides/obsidian/obsidian-bases-and-json-canvas-agents
- Markdown: https://twelve-pages.com/guides/obsidian/obsidian-bases-and-json-canvas-agents.md
- PDF: https://twelve-pages.com/guides/obsidian/obsidian-bases-and-json-canvas-agents/Obsidian_Bases_and_JSON_Canvas_with_AI_Complete_How_To_Guide.pdf (3.5 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Native .base Databases, Open JSON Canvas (.canvas), YAML Property Schemas, Formulas & Dynamic Views, Anti-Overlap Grid Math, Zero Third-Party Plugins
- Core Takeaways:
  - Relational .base Views: Query thousands of vault notes into fast, two-way editable Tables and Gallery Cards powered by clean YAML filters and formulas.
  - Spatial .canvas Maps: Have AI agents calculate non-overlapping 2D grids, group boundaries, and labeled arrows directly in open JSON Canvas 1.0 files.
  - 100% Plain-Text Native: Every note, database query, and whiteboard lives on your local disk as inspectable UTF-8 files with zero cloud or plugin lock-in.
- Chapters:
  1. The Native Tri-Format Stack: .md + .base + .canvas — Plain Markdown notes excel at linear prose, yet stumble when you need a sortable project tracker or a big-picture system diagram. Obsidian solves both natively—without proprietary cloud databases or fragile community plugins—using two plain-text companion formats that AI agents read and write fluently.
  2. Core Plugin Setup & Format Decision Matrix — Everything in this handbook runs on 100% official, built-in Obsidian features—meaning zero community plugin security audits, instant startup on macOS/Windows/Linux/iOS/Android, and guaranteed long-term format stability.
  3. Annotated Tour: Split-Pane .base & .canvas Studio — Opening a relational .base view on the left and a spatial .canvas board on the right turns Obsidian into an interactive command center where tabular metadata and architectural topology stay linked in real time.
  4. Designing Agent-Safe YAML Property Schemas — A .base database is only as sharp as the YAML frontmatter underneath it. Without an explicit schema contract, AI agents drift across synonyms—writing dueDate on Monday and due_date on Tuesday—silently splitting one column into sparse fragments.
  5. Authoring Native .base Files & Formulas With AI — Every Obsidian .base file is a declarative YAML document with four top-level blocks: global filters, calculated formulas, column properties labels, and a views array defining Table and Cards tabs.
  6. Mastering Open JSON Canvas (.canvas) & Grid Math — Published under an open specification at jsoncanvas.org, every .canvas file is a standard JSON object with two arrays: nodes[] (ordered back-to-front by z-index) and edges[]. Deterministic grid math turns messy guesses into crisp blueprints.
  7. Bi-Directional Workflows: Notes ↔ Bases ↔ Canvas — Because all three formats live as plain text in your workspace, information flows effortlessly in both directions: synthesize scattered notes upward into dashboards, or sketch rough boxes on a canvas and let an AI agent scaffold your vault downward.
  8. 5 Real-World Copy-Paste .base & .canvas Recipes — Drop any of these five battle-tested prompts directly into Claude Desktop (with Filesystem MCP) or Antigravity Desktop to build complete, zero-plugin relational and spatial systems inside your vault in under sixty seconds.
  9. Validation Scripts & Layout Polish in Antigravity — Professional agent workflows never trust raw LLM JSON blindly. Adding a tiny 25-line Python check inside Antigravity Desktop catches broken file paths, duplicate IDs, float coordinates, and overlapping cards in milliseconds before you even switch windows to Obsidian.
  10. Cross-Tool Synergy Pipeline: Raw Inputs to Visual Vault — Native .base views and .canvas boards shine brightest as the visual presentation layer at the end of an automated AI research and engineering pipeline—turning messy transcripts, repositories, and PDFs into a living operating system.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Nearly every broken .base column or unreadable .canvas board traces back to one of seven syntax mismatches. Keep this diagnostic table handy for ten-second fixes.

### Autonomous LLM Wiki & Research Vault

> Building a Karpathy-style self-maintaining knowledge base in Obsidian where Claude Desktop and Antigravity compile raw PDFs, transcripts, and web clips into interlinked evergreen concept notes.

- Web: https://twelve-pages.com/guides/obsidian/autonomous-llm-wiki-vault
- Markdown: https://twelve-pages.com/guides/obsidian/autonomous-llm-wiki-vault.md
- PDF: https://twelve-pages.com/guides/obsidian/autonomous-llm-wiki-vault/Autonomous_LLM_Wiki_and_Research_Vault_Complete_How_To_Guide.pdf (3.4 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Karpathy LLM Wiki Pattern, _raw/ Immutable Sources, Atomic Evergreen Notes, Maps of Content (MOCs), Source Provenance, Scheduled Wiki Lint
- Core Takeaways:
  - Compile Once, Compound Forever: Stop re-chunking raw PDFs on every prompt; let desktop AI agents distill new sources directly into living encyclopedia pages.
  - 100% Cited Provenance: Every synthesized claim links back to an untouched primary file in 00-raw/ with exact section anchors and confidence tags.
  - Self-Healing Wikilinks: Scheduled weekly lint passes mend broken links, merge synonym stubs, and surface contradictions across years of reading.
- Chapters:
  1. Compiled Knowledge vs. Stateless RAG — Why having desktop AI agents maintain an interlinked Markdown wiki beats re-chunking raw PDFs on every question—turning passive reading folders into compounding institutional memory.
  2. Vault Blueprint & Knowledge Architecture Matrix — An autonomous Obsidian wiki needs zero plugins or external databases to start—only a clean numbered folder hierarchy and a constitution file (AGENTS.md) that defines how agents read, compile, and log changes.
  3. Annotated Tour: Obsidian Autonomous Wiki Workspace — Because every agent-compiled note is standard Markdown with YAML properties and [[Wikilinks]], Obsidian turns your vault into an interactive research cockpit with zero proprietary lock-in.
  4. Operation 1: The Ingest & Multi-Page Compile Loop — Dropping a file into 00-raw/ is not “saving a bookmark”—it triggers a five-step compilation pass where one new document ripples across your entire knowledge graph.
  5. Evergreen Note Anatomy, Schema Laws & Compiler Prompt — Left unguided, LLMs write shallow bullet lists full of synonym files and vague “See Also” links. Your AGENTS.md schema turns the model into a disciplined encyclopedia editor.
  6. Operation 2: Index-First Querying & Filing Answers Back — Once your knowledge is pre-compiled into clean concept notes and indexed in index.md, answering complex multi-hop research questions requires zero vector database infrastructure—and every great answer makes the vault smarter.
  7. Operation 3: Scheduled “Wiki Lint” & Gardening — Even disciplined compilation accumulates rough edges over dozens of ingests. A weekly automated Wiki Lint pass keeps your Obsidian graph coherent, pruned, and epistemically honest while you rest.
  8. 5 Real-World Domain LLM Wiki Recipes — The three-layer Obsidian compiler adapts to any synthesis-heavy discipline simply by tuning the entity types and provenance rules inside AGENTS.md. Copy any domain setup below to launch a specialized vault in minutes.
  9. Provenance Gates, Anti-Hallucination & Co-Authorship — A self-maintaining wiki is only valuable if you can trust every sentence inside it—and if your own hard-won intuition is never flattened or overwritten by an eager compiler pass.
  10. Cross-Tool Research Synergy Pipeline — Your Obsidian LLM Wiki becomes ten times more powerful when positioned as the permanent hub between upstream discovery tools and downstream writing, slides, and engineering specs.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Most autonomous wiki hiccups stem from missing guardrails in AGENTS.md rather than model capability. Use these 10-second fixes to keep your vault sharp across hundreds of compile cycles.

### AI Agents + Graphify + Obsidian

> Building persistent, queryable knowledge graphs from codebases and notes that you explore visually in Obsidian and expose to AI agents via MCP.

- Web: https://twelve-pages.com/guides/obsidian/graphify-and-obsidian-knowledge-graphs
- Markdown: https://twelve-pages.com/guides/obsidian/graphify-and-obsidian-knowledge-graphs.md
- PDF: https://twelve-pages.com/guides/obsidian/graphify-and-obsidian-knowledge-graphs/AI_Agents_Graphify_and_Obsidian_Complete_How_To_Guide.pdf (3.6 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: AST + Multimodal Extraction, EXTRACTED / INFERRED Tags, GRAPH_REPORT.md & Leiden Clusters, Quarantine Vault Pattern, graphify & graph-query-mcp, Two-Way Obsidian MCP Loop
- Core Takeaways:
  - Structure Beats Blind Grep: Stop burning context windows on linear file scans; trace multi-hop call paths, God Nodes, and subsystem clusters in under 50ms.
  - One Map for Humans & Agents: Every build exports graph.json for instant MCP tool calls alongside a linked obsidian/ vault you can walk by hand.
  - Epistemic Honesty Built In: Every edge carries an explicit EXTRACTED, INFERRED, or AMBIGUOUS tag so agents never confuse guesses with facts.
- Chapters:
  1. Why Grep & Vector Chunks Miss Architectural Structure — Without a structural map, an AI coding agent treats every architectural question like a blind scavenger hunt: grep tells it where a symbol appears, and chunked vector search finds paragraphs that sound similar—neither knows how five modules and two design docs actually connect.
  2. Installation, Extraction Modes & Decision Matrix — Graphify runs locally on Python 3.10+ (NetworkX + tree-sitter + graspologic) without external servers or Docker containers, and installs as a native skill across Claude Code, Cursor, Codex, Antigravity, Gemini CLI, Copilot CLI, OpenCode, and Aider.
  3. Annotated Tour: Obsidian + Graphify Knowledge Vault — Every build generates graphify-out/obsidian/—one Markdown note per node, YAML frontmatter, [[wikilink]] edges, and a spatial Canvas. Here is how human notes, quarantined graph snapshots, Leiden cluster colors, and God Nodes coexist safely.
  4. Building Your First Graph & Reading GRAPH_REPORT.md — Whether you point Graphify at a polyglot repository or Andrej Karpathy's raw/ drop-folder of research papers, tweets, and screenshots, one command distills scattered files into six persistent artifacts inside graphify-out/.
  5. Obsidian Setup & Safe Vault Merge Patterns — Because graphify-out/obsidian/ is regenerated as a point-in-time snapshot whenever code or notes change, choosing your vault integration pattern upfront prevents accidental overwrites while making large graphs effortless to browse.
  6. Three Levels of AI Agent Integration — A knowledge graph saves zero tokens if your coding agent forgets it exists and falls back to recursive grep. Wire your agent across three progressive levels—from interactive slash queries up to sub-50ms in-memory MCP traversal.
  7. Two-Way Obsidian Read/Write & Automated Freshness — Querying graph.json gives your agent structural X-ray vision; adding a direct Obsidian bridge closes the loop—letting agents file synthesis notes with [[wikilinks]] while Git hooks keep your graph honest on every commit.
  8. 5 Real-World Copy-Paste Graphify + Obsidian Recipes — Drop these five ready-to-run prompts, shell scripts, and JSON configs straight into Claude Code, Cursor, Antigravity, or your repository hooks to turn structural graph queries into an effortless daily reflex.
  9. Token Economics, Vault Hygiene & Multi-Repo Scale — Knowing exactly how Graphify spends and saves tokens—and governing what enters Git versus local caches—lets you scale from a single weekend project up to federated microservice fleets and shared Architecture Decision Records (ADRs).
  10. Cross-Tool Synergy: Structural + Semantic Memory Pipeline — Graphify does not replace specs or content search—it completes the engineering memory stack. Watch how Obsidian visual review, MCP topology traversal, and targeted file/RAG lookup combine on a cross-cutting feature.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Keep this final page beside your terminal and Obsidian workspace. Every common Graphify + Obsidian snag—from tangled hairball graphs to overwritten notes and MCP connection hiccups—has a fast 10-second fix.

### Obsidian Vault Security, Privacy & Sync

> Protecting private journals, API secrets, and multi-device sync when AI agents touch your vault—mastering privacy zones, sandboxes, prompt-injection defenses, and conflict-free Obsidian Sync + Git.

- Web: https://twelve-pages.com/guides/obsidian/vault-security-privacy-and-sync
- Markdown: https://twelve-pages.com/guides/obsidian/vault-security-privacy-and-sync.md
- PDF: https://twelve-pages.com/guides/obsidian/vault-security-privacy-and-sync/Obsidian_Vault_Security_Privacy_and_Sync_Complete_How_To_Guide.pdf (2.9 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Private Journal Isolation, Scoped MCP Directories, Web Clipper Quarantine, Obsidian Sync + Git, Local Air-Gapped Ollama, 10-Second Disaster Recovery
- Core Takeaways:
  - Zero Private Leaks: Physically exclude journals, medical notes, and plugin API keys from cloud MCP mounts and Git remotes by design.
  - Injection-Safe Clipping: Quarantine and sanitize saved web articles and external PDFs before any tool-wielding desktop agent reads them.
  - Conflict-Free Multi-Device: Combine end-to-end encrypted Obsidian Sync, mobile quick-capture, and local Git checkpoints with zero file collisions.
- Chapters:
  1. Why Personal Vaults Need Stronger Boundaries Than Code — A software repository expects every file to be read by compilers, coworkers, and cloud coding agents. A personal Obsidian vault is fundamentally different: it mixes intimate journals, medical and tax records, unvetted articles clipped from the open web, plugin API keys, and active work research inside one plain-text folder tree.
  2. Threat Model & Multi-Device Sync Decision Matrix — Connecting autonomous AI tools and mobile sync engines to plain Markdown files introduces four concrete, repeatable failure modes. Understanding how each failure happens lets you neutralize all four in under fifteen minutes.
  3. Annotated Tour: Vault Security & Sync Control Plane — A hardened Obsidian setup coordinates three control surfaces side by side: scoped directory arguments in Claude Desktop, workspace file-access and review policies in Antigravity, and sync/snapshot exclusions inside Obsidian Settings.
  4. Hard Isolation for Private Journals & Plugin Secrets — Before granting any desktop agent filesystem or REST access, decide how strictly you want to separate deeply personal notes from everyday project work—and lock down the hidden JSON files where Obsidian plugins store raw API keys.
  5. Defending Against Web Clipper & PDF Prompt Injection — Obsidian Web Clipper is a superpower for building a research library—and the number-one Trojan horse for desktop AI agents. Every clipped webpage, GitHub issue, or external PDF is untrusted third-party text written by strangers on the internet.
  6. Running Obsidian Sync + Git + Mobile Without Conflicts — Most vault corruption blames AI agents when the true culprit is two sync engines fighting over internal metadata—or macOS silently replacing local Markdown files with hollow cloud placeholders behind an agent's back.
  7. Air-Gapped Local AI Routing for Sensitive Personal Notes — Keeping 00-Private/ off cloud servers does not mean giving up AI synthesis on your personal life. Modern Apple Silicon Macs run 12B–32B open-weight models locally at 30–60 tokens/second—letting you reflect on decade-long journals, medical labs, or household finances with zero bytes leaving your machine.
  8. 5 Copy-Paste Security, Sync & Governance Recipes — Drop these five configurations and helper scripts straight into your setup to enforce folder boundaries, stop Git secret leaks, scrub untrusted web clips, and wrap bulk agent runs in instant rollback tags.
  9. Auditing Bulk Agent Edits & 10-Second Disaster Recovery — Once an AI agent can normalize YAML tags, rename backlinks, or reorganize 150 project notes in five seconds, your safety depends on a fast, rehearsed recovery stack. Build three concentric safety nets so no bad prompt ever costs more than ten seconds.
  10. Cross-Tool Synergy: Capture to AI Synthesis to Sync — Here is how every piece in this guide fits together into one calm daily workflow—from mobile phone capture and Web Clipper intake through split cloud/local AI processing, diff verification, and encrypted multi-device sync.
  11. Troubleshooting Clinic & 6-Point Pre-Flight Check — Keep this reference page handy whenever sync conflicts appear, MCP servers miss files, or an automated refactor needs a rapid fix.

### Obsidian Multimodal Capture & Pipelines

> Turn web articles, academic PDFs, voice memos, and whiteboard photos into structured vault notes—mastering Obsidian Web Clipper templates, Interpreter {{"..."}} prompts, Knap filters, PDF++ citations, and quarantine-safe _inbox/ routing.

- Web: https://twelve-pages.com/guides/obsidian/obsidian-capture-and-multimodal-pipelines
- Markdown: https://twelve-pages.com/guides/obsidian/obsidian-capture-and-multimodal-pipelines.md
- PDF: https://twelve-pages.com/guides/obsidian/obsidian-capture-and-multimodal-pipelines/Obsidian_Capture_and_Multimodal_Pipelines_Complete_How_To_Guide.pdf (3.5 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Web Clipper Templates, Interpreter AI Prompts, Knap Filter Pipes, PDF++ Deep Citations, Voice & Vision OCR, Quarantine _inbox/ Gate
- Core Takeaways:
  - Universal Capture: Ingest articles, papers, spoken meetings, and photos with deterministic templates and zero manual copy-pasting.
  - Zero-Friction Distillation: Pair Knap filter pipes, local Ollama or cloud Interpreter prompts, and PDF++ anchors for instant structure.
  - Safe _inbox/ Quarantine: Isolate untrusted clips with untrusted_clip: true before any agent promotes insights into your evergreen wiki.
- Chapters:
  1. Quick Navigation & The 3-Stage Capture Model — Great knowledge vaults fail when capture feels like homework. Separate raw intake from permanent synthesis so every messy web page, PDF, or voice note lands safely in under five seconds.
  2. Setup & Capture Modality Decision Matrix — Install one browser extension, pick an Interpreter AI backend, and keep lightweight local CLI extractors ready so every file type flows into clean Markdown without proprietary lock-in.
  3. Web Clipper, Interpreter Cockpit & _inbox/ Preview — Every capture runs inside one predictable split workflow: triggers match the page, selectors grab clean text, Knap filters shape values, Interpreter fills AI prompt variables, and Obsidian receives typed YAML.
  4. Web Clipper Mastery: Variables, Selectors, Knap Filters & AI — Combine built-in page metadata, precision CSS or Schema.org extractors, and deterministic Knap filter pipes before handing clean text to Interpreter.
  5. Auto-Triggers & Color-Coded Capture Template Anatomy — Stop picking templates by hand. Bind URL regexes and Schema.org types to specialized templates so every capture automatically carries typed YAML and safe defaults.
  6. Academic PDFs, Scanned Tables & Slide Decks — Match the extractor to the document: parse digital text and tables deterministically with Python and PDF++ anchors, and route scanned layouts or math-heavy slides to multimodal vision OCR.
  7. Voice Memos, Meeting Audio & Whiteboard Snapshots — Capture ideas while walking or straight off a conference room whiteboard. Convert raw audio and JPEG snapshots into speaker-attributed notes, Mermaid flowcharts, and native Obsidian .canvas boards.
  8. 5 Real-World Copy-Paste Capture Recipes — Drop these tested templates and shell commands straight into Web Clipper or your local capture scripts. Every recipe enforces _inbox/ staging and clean YAML metadata.
  9. Mobile Capture, URI Automation & Quarantine Security — Extend one-tap capture to your phone with obsidian:// URIs and defend your AI agents against indirect prompt injection hidden inside clipped web pages and PDFs.
  10. End-to-End Cross-Tool Knowledge Pipeline — Capture is only half the story. Connect your multimodal _inbox/ into Claude Desktop or Antigravity compilers to feed an autonomous LLM Wiki, live Obsidian Bases, and a Graphify knowledge graph.
  11. Troubleshooting Clinic & 6-Point Pre-Flight Checklist — Fix the seven most common capture glitches in ten seconds flat, then run the pre-flight checklist before trusting a new template or automated pipeline.

## AI Music, Cinema & Presentation Studios (4 Handbooks)

Topic Hub: https://twelve-pages.com/topics/creative-media

Publication-grade 12-page visual handbooks for generative music, studio voice/avatar localization, interactive 3D world-building & AI cinema, and rapid visual pitch decks—covering Suno, ElevenLabs, Lyria 3.5, HeyGen, Project Genie, Runway, Kling, and Gamma.

### AI Music Production & Soundtracks

> Compose songs, brand beds, and looping SFX using Suno v6 meta-tags, Personas, and 12-stem WAV/MIDI exports alongside ElevenLabs Music, Google Lyria 3.5, and 2026 commercial clearance rules.

- Web: https://twelve-pages.com/guides/creative-media/ai-music-production-and-soundtracks
- Markdown: https://twelve-pages.com/guides/creative-media/ai-music-production-and-soundtracks.md
- PDF: https://twelve-pages.com/guides/creative-media/ai-music-production-and-soundtracks/AI_Music_Production_and_Soundtracks_Complete_How_To_Guide.pdf (2.5 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Suno v6 & Studio Meta-Tags, Personas & Replace Section, ElevenLabs Music & SFX Loops, Google Lyria 3.5 & SynthID, 12-Stem WAV & MIDI Export, 2026 Label & Client Clearance
- Core Takeaways:
  - Structured Song Craft: Direct verses, drops, and locked vocal Personas in Suno v6 using bracketed meta-tags and bar-accurate section replacement.
  - Cleared Scoring & Foley: Compose millisecond-timed brand beds and click-free ambient loops with ElevenLabs Music and Google Lyria 3.5.
  - Pro DAW Finishing: Split 12 WAV stems, extract tempo-mapped MIDI, swap in studio VSTs, and master to release loudness in Logic Pro or Ableton Live.
- Chapters:
  1. Three Engines, One Modern Studio Mental Model — Rather than forcing a single generator to handle vocals, dialogue underscore, sound effects, and final mixing, modern producers route each job to a specialized engine and bring every piece home inside a desktop DAW.
  2. SDK Setup, Commercial Rights & Audio Engine Matrix — Great soundtracks fail client audits when they come from the wrong plan tier or lack clean stem files. Install the official SDKs below and match every creative task to the right engine before pressing generate.
  3. Lyric Meta-Tag & Stem Mixer Studio: 7 Key Controls — Treat AI generation like a multitrack recording session rather than a vending machine. These seven studio controls bridge prompt authoring, timeline surgical edits, and multi-stem DAW export.
  4. Suno v6: Meta-Tags, Personas & Surgical Timeline Edits — Suno's v6 family (v6 flagship, v6-wild ideation, and fast v6-mini) rewards clear architectural direction. Pair Custom Mode meta-tags with Personas and Suno Studio's timeline tools to shape radio-ready arrangements.
  5. ElevenLabs Music & SFX: Cleared Scores & Seamless Loops — When client projects demand clean chain-of-title clearance, exact millisecond timings for video cuts, or continuous ambient soundscapes that never click at the loop boundary, ElevenLabs Music (music_v2_5) and SFX v2/v3 shine.
  6. Google Lyria 3.5: CLI Soundtracks, GenAI SDK & RealTime — Google's lyria-3.5 unifies full-length 44.1 kHz stereo music generation inside the same Gemini API and gemini-api CLI used for text and video—bringing scriptable soundtracks, multimodal image cues, and SynthID into any workflow.
  7. 12-Stem Extraction, Tempo-Mapped MIDI & DAW Mastering — Cloud generations sound exciting on laptop speakers yet often carry synth fizz, uneven low end, or subtle tempo drift. Export stems and MIDI into Logic Pro or Ableton Live 12.3+ to transform drafts into release-grade masters.
  8. 5 Real-World Copy-Paste Production Recipes — Put these five field-tested patterns straight into Suno Custom Mode, Python audio pipelines, or terminal soundtrack scripts—each verified against 2026 API signatures and licensing best practices.
  9. 2026 Licensing Reality: Settlements, Attribution & Clearance — Landmark 2025–2026 label settlements transformed AI audio from a legal gray zone into tiered licensing agreements. Protect clients and releases by matching plan rights, provenance tags, and human authorship before publishing.
  10. End-to-End Pipeline: Prompt Blueprint to Mastered Soundtrack — Combine all three engines with your desktop DAW into a seamless four-stage production house—moving from rapid scriptable ideation and vocal hooks to dialogue-safe beds, clean stem splits, and broadcast-ready masters.
  11. Troubleshooting Clinic (Top 7 Fixes) & Pre-Flight Checklist — Bookmark this final page before bouncing a soundtrack or shipping client stems. Almost every AI music snag comes down to one of these seven fast fixes.

### AI Voices, Multilingual Dubbing & Avatars

> Produce studio voice clones, W3C PLS phoneme lexicons, multi-speaker Gemini TTS dialogues, 175-language HeyGen lip-sync dubbing, and real-time WebRTC LiveAvatars with C2PA provenance.

- Web: https://twelve-pages.com/guides/creative-media/ai-voices-dubbing-and-avatars
- Markdown: https://twelve-pages.com/guides/creative-media/ai-voices-dubbing-and-avatars.md
- PDF: https://twelve-pages.com/guides/creative-media/ai-voices-dubbing-and-avatars/AI_Voices_Multilingual_Dubbing_and_Avatars_Complete_How_To_Guide.pdf (3.0 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: ElevenLabs PVC & Voice Design v3, IPA / PLS Pronunciation Lexicons, HeyGen Avatar IV & Digital Twin, 175+ Lang Lip-Sync Dubbing, LiveAvatar WebRTC Streaming, C2PA Watermarks & Consent
- Core Takeaways:
  - Studio Voice Synthesis: Train hyper-realistic Professional Voice Clones, direct emotion with Eleven v3 Audio Tags, and lock brand terms via PLS phoneme rules.
  - 175+ Language Video Dubbing: Translate talking-head footage with HeyGen Video Translate while preserving vocal identity and re-animating natural lip motion.
  - Real-Time Interactive Twins: Stream sub-second LiveAvatar WebRTC presenters and multi-speaker gemini-3.8-flash-tts dialogues backed by C2PA guardrails.
- Chapters:
  1. The 3-Layer AI Voice, Dubbing & Avatar Stack — Early text-to-speech tools forced teams to choose between robotic voices and stiff talking heads. Modern production workflows unify three distinct layers: Voice & Lexicon Control (ElevenLabs and Gemini TTS), Visual Lip-Sync & Digital Twins (HeyGen), and Consent & Provenance.
  2. Studio Capture Standards, Tiers & Platform Matrix — AI voice and avatar models replicate every acoustic and lighting flaw in your source files. Follow these exact engineering baselines before uploading a single training minute, then match your project to the right tier.
  3. Studio Timeline & Lip-Sync Dubbing Deck: UI Tour — Whether you are polishing a multi-chapter ElevenLabs Studio project or proofing a 175-language HeyGen Video Translate cut, every high-output session revolves around these 7 numbered controls.
  4. Voice Cloning, Voice Design v3 & W3C .pls Lexicons — Use Voice Design v3 to invent original brand voices from a text prompt, train a dedicated Professional Voice Clone (PVC) from studio recordings, and enforce bulletproof pronunciation with W3C .pls XML dictionaries.
  5. Multi-Speaker Studios, Audio Tags & gemini-3.8-flash-tts — Move from isolated single-sentence clips to cohesive multi-chapter audiobooks, two-host podcasts, and automated developer dialogues—balancing expressive Eleven v3 direction with fast Gemini CLI scripting.
  6. Digital Twins, Avatar IV & 175-Language Video Translate — Transform one continuous studio recording—or even a single portrait photo—into localized talking-head video across 175+ languages and dialects, complete with natural micro-expressions and pixel-accurate mouth movement.
  7. Interactive Streaming Presenters With LiveAvatar WebRTC — Go beyond static MP4 files with HeyGen LiveAvatar—streaming real-time, two-way conversational digital presenters over WebRTC in sub-second latency for interactive onboarding, virtual tutors, and support desks.
  8. 5 Real-World Production Recipes You Can Ship Today — Each tested recipe pairs the ideal model, configuration flags, and pacing rule for common studio, localization, and developer workflows.
  9. Consent Verification, C2PA Watermarks & Deepfake Guardrails — Responsible synthetic media protects real speakers, builds audience trust, and satisfies regulatory disclosure mandates such as EU AI Act Article 50. Both ElevenLabs and HeyGen enforce strict multi-layer provenance controls.
  10. Cross-Tool Synergy: Gemini TTS + ElevenLabs + HeyGen — Each platform excels at a specific link in the creative chain. Combine fast Gemini TTS script prototyping, ElevenLabs phoneme-locked voice mastery, and HeyGen visual localization into one repeatable global pipeline.
  11. Troubleshooting Clinic & Pre-Flight Production Sheet — Diagnose the seven most frequent voice cloning, pronunciation, lip-sync, and streaming failures in seconds—then run the 6-point checklist before releasing global campaigns.

### Interactive Worlds & AI Cinema

> Generate navigable 3D sets in Google Project Genie, direct camera paths and Act-One facial performances in Runway Gen-4.5, lock characters with Kling Elements, and finish in 4K at 24fps.

- Web: https://twelve-pages.com/guides/creative-media/interactive-worlds-and-ai-cinema
- Markdown: https://twelve-pages.com/guides/creative-media/interactive-worlds-and-ai-cinema.md
- PDF: https://twelve-pages.com/guides/creative-media/interactive-worlds-and-ai-cinema/Interactive_Worlds_and_AI_Cinema_Complete_How_To_Guide.pdf (2.5 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Project Genie 3D Worlds, Runway Gen-4.5 & Act-One, Multi-Motion & Camera Paths, Kling Elements & Keyframes, 5 Copy-Paste Cinema Recipes, 4K Upscale & IP Hygiene
- Core Takeaways:
  - Playable World Sketching: Turn prompts, sketches, or Street View pins into navigable 720p/24fps 3D worlds inside Google Project Genie.
  - Director-Level Control: Command camera trajectories, Multi-Motion Brush masks, Act-One acting, and Kling Elements identity locks.
  - Studio-Ready Finishing: Conform mixed clips at 24fps in DaVinci Resolve, upscale cleanly to 4K, and preserve SynthID + C2PA provenance.
- Chapters:
  1. Inside This Guide: Playable Worlds vs. AI Cinema — Modern visual AI splits into two distinct superpowers: real-time playable world models (Google Project Genie) that let you walk inside a living set, and deterministic cinema engines (Runway & Kling) that render locked shots for an editing timeline.
  2. Access Tiers, Credits & Engine Decision Matrix — Every platform prices compute differently. Knowing per-second credit rates before pressing Generate lets you explore freely in cheap draft modes and save premium credits for locked final takes.
  3. Annotated Workspace UI: World & Shot Director HUD — Although Project Genie, Runway, and Kling organize menus differently, every production workflow centers on the same seven spatial controls. Learn this unified cockpit map to direct across all three engines.
  4. Playable 3D Worlds in Project Genie (Genie 3) — Powered by Google DeepMind's Genie 3 spatiotemporal world model, Project Genie generates navigable 3D spaces that react dynamically to your controls at 720p / 24fps with roughly one minute of spatial object memory.
  5. Runway Gen-4.5 Director Controls & Act-One — When your scene requires physical weight—fabric billowing in wind, water splashing against glass, or an actor delivering subtle heartbreak—pair Runway Gen-4.5 with Gen-4 References and Act-One / Act-Two.
  6. Multi-Motion Brush & Precision Camera Paths — Text prompts alone often swirl static walls or freeze hair that should blow in the breeze. Combining Multi-Motion Brush masks with explicit camera path trajectories separates environmental motion from camera movement.
  7. Kling Elements, Keyframes & 4K NLE Finishing — Kling AI 3.0 Omni shines when characters sprint, fight, dance, or transform smoothly between two exact still frames. Pair Kling's consistency tools with DaVinci Resolve or Premiere Pro to finish a broadcast-grade cut.
  8. 5 Real-World Copy-Paste Cinema & World Recipes — Stop reinventing settings for every new scene. Copy these five battle-tested recipes directly into Project Genie, Runway, Kling, and your finishing terminal.
  9. Team Pre-Viz, IP Hygiene & Frame Provenance — Shipping AI-assisted films for clients, festivals, or studios requires clean rights hygiene, reproducible pre-viz packets, and verifiable provenance credentials under 2026 disclosure standards.
  10. The Cross-Tool World-to-Cinema Synergy Pipeline — No single engine dominates every film task. Use this five-stage handoff pipeline to pair Project Genie's navigable worlds with Kling's action physics, Runway's acting polish, and studio 4K finishing.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Keep this final page next to your keyboard while directing. Every recurring world-drift, mask-bleed, lip-sync, or keyframe-warp snag has an immediate 10-second fix.

### AI Pitch Decks & Visual Storytelling

> Turn rough briefs into investor-grade stories using Gamma fluid cards, Studio Mode, Theme Builder brand locks, Spotlight viewer analytics, API/MCP automation, and PowerPoint or Google Slides round-trips.

- Web: https://twelve-pages.com/guides/creative-media/ai-pitch-decks-and-visual-storytelling
- Markdown: https://twelve-pages.com/guides/creative-media/ai-pitch-decks-and-visual-storytelling.md
- PDF: https://twelve-pages.com/guides/creative-media/ai-pitch-decks-and-visual-storytelling/AI_Pitch_Decks_and_Visual_Storytelling_Complete_How_To_Guide.pdf (3.0 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Fluid Cards & Studio Mode, Theme Builder Brand Lock, Smart Layouts & Diagrams, Spotlight & Viewer Analytics, Gamma API & MCP Automation, PPTX & Gemini in Google Slides
- Core Takeaways:
  - Story First, Geometry Never: Turn raw briefs or Google Docs into structured 10-card pitch arcs in under 60 seconds using fluid cards that expand without text-box collisions.
  - One-Click Brand Gravity: Import a master PowerPoint deck or upload custom fonts and logos into Theme Builder so every team presentation stays cleanly on-brand.
  - Ship Web-Native or Slides: Deliver live talks with Spotlight focus and per-card viewer analytics, or export editable decks into PowerPoint and Gemini-powered Google Slides.
- Chapters:
  1. Escaping Text-Box Tetris With Fluid Card Storytelling — Traditional slide software forces you to fight rigid 16:9 rectangles before you have even clarified your argument—nudging text boxes by two pixels every time an executive adds one bullet. Modern AI storytelling separates narrative structure from visual layout and brand theme, letting you lock the story first and transform its visual geometry in seconds.
  2. Plans, AI Credits, Setup & Presentation Tool Matrix — Gamma pairs a seat subscription with AI Credits rather than strict deck caps—manual editing costs zero credits, while generation, Gamma Agent edits, and AI image renders draw from your monthly balance.
  3. Annotated Tour: Inside the Gamma Card & Theme Studio — Every Gamma deck puts four high-leverage controls around one distraction-free card canvas—letting you drag narrative beats, enforce locked themes, reflow Smart Layouts, and steer the Gamma Agent without hunting through nested menus.
  4. Doc-to-Deck Structuring: Turning Raw Notes Into Clean Cards — The biggest mistake new users make is dumping a four-page memo into a generic AI prompt box and hoping for magic. Controlling card boundaries and choosing the right text-interpretation mode eliminates overcrowded slides on the first generation.
  5. Theme Brand Lock & The 5-Part Narrative Prompt Formula — Locking your visual identity inside Theme Builder and pairing it with a five-part narrative prompt stops AI decks from looking like generic templates—ensuring investor credibility from the very first draft.
  6. Narrative Arcs, Smart Layouts & Visual Storyboards — Audiences decide within three minutes whether a presentation respects their time. Selecting a proven narrative arc first—then alternating Smart Layouts and visual Studio scenes—turns slides into an effortless visual story.
  7. PowerPoint Export, Google Slides & Gemini Co-Pilot — When enterprise procurement teams, board directors, or Workspace collaborators need native slide decks instead of web links, a structured export-and-polish pipeline preserves editable shapes, tables, and speaker notes without manual rebuilds.
  8. 5 Real-World Copy-Paste Pitch & Deck Recipes — Paste any recipe below directly into Gamma’s prompt composer, Gamma Agent sidebar, or Gemini in Google Slides—substituting only your verified metrics—to build structured presentations in under two minutes.
  9. Delivery, Viewer Analytics, Permissions & Gamma API — A great pitch continues working after you hit Send. Combining live Spotlight focus during calls, per-card viewer analytics on async shares, strict brand permissions, and the Gamma Public API turns decks into measurable growth assets.
  10. Cross-Tool Synergy: From Raw Brief to Closed Deal — High-velocity teams combine upstream writing tools, Gamma’s rapid structural design engine, and downstream delivery or Google Workspace co-editing—turning one verified source brief into investor decks, QBRs, and board packages without duplicating work.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Consult this diagnostic table whenever an exported PowerPoint shifts alignment, credits burn too quickly, custom fonts fall back, or analytics go blank—then run the 6-point pre-flight check before sending any high-stakes deck.

## AI Search Visibility, Agentic Web & Workflows (3 Handbooks)

Topic Hub: https://twelve-pages.com/topics/visibility-and-workflows

Publication-grade 12-page visual handbooks for Generative Engine Optimization (GEO), AI search citations, agent-ready websites with is-agentic, llms.txt & WebMCP, and bot-free meeting capture pipelines with Granola.

### GEO & AI Search Visibility

> Win inline citations across ChatGPT Search, Perplexity, Google AI Overviews, Claude, and Gemini using Answer-First prose capsules, entity corroboration, JSON-LD schema, SSR parity, and Share-of-Voice KPIs.

- Web: https://twelve-pages.com/guides/visibility-and-workflows/geo-and-ai-search-visibility
- Markdown: https://twelve-pages.com/guides/visibility-and-workflows/geo-and-ai-search-visibility.md
- PDF: https://twelve-pages.com/guides/visibility-and-workflows/geo-and-ai-search-visibility/Generative_Engine_Optimization_and_AI_Visibility_Complete_How_To_Guide.pdf (3.1 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: RAG Citation Pipelines, Answer-First Prose, Entity & Off-Site Graphs, JSON-LD & SSR Parity, Bot Crawl Governance, AI Share of Voice KPIs
- Core Takeaways:
  - Earn Inline Citations: Lead every section with 40–60 word Answer-First capsules packed with verifiable metrics, primary citations, and expert quotes.
  - Corroborate Your Entity: Unify Organization JSON-LD with Wikidata, GitHub, Reddit, and G2 directories so engines resolve your brand with zero ambiguity.
  - Pass Every Bot Pass: Serve clean Server-Side Rendered HTML and separate training bots from live search bots across robots.txt and edge firewalls.
- Chapters:
  1. From Blue Links to Synthesized Citations: The GEO Shift — Traditional SEO competes for ten blue links on a results page. Generative Engine Optimization (GEO) competes to become one of the three to six trusted passages synthesized directly inside an AI answer—where ChatGPT Search, Perplexity, Google AI Overviews, Claude, and Gemini decide which brands buyers hear about before anyone clicks a link.
  2. AI Search Engines, Crawler Roles & Citation Matrix — Not every AI bot does the same job. Blocking model training crawlers protects your archive without hurting live citations—unless you accidentally block real-time search bots or ship client-side JavaScript that crawlers cannot execute.
  3. Annotated Tour: Inside a GEO Citation & SOV Audit Studio — Whether you use a dedicated visibility tracker or your own audit pipeline, every high-performing GEO workspace connects seven core telemetry panels—linking multi-engine Share of Voice directly to crawlability, Answer-First prose scores, and entity corroboration.
  4. Answer-First Content Architecture & Citation Signals — Human writers love slow, suspenseful introductions. RAG retrievers hate them. When an answer engine splits your page into chunks and scores each passage against a buyer’s sub-query, burying the core answer below 300 words of story causes your entire page to lose the citation.
  5. The 5-Part Citation Capsule Formula & Chunking Rules — Vector databases and search rerankers split pages into 200–500 token chunks anchored by headings. When a passage enters the LLM context window alone without surrounding paragraphs, it must stand completely on its own.
  6. Entity Graphs & Multi-Source Off-Site Corroboration — Generative engines avoid trusting isolated vendor claims on your own website. Before recommending your product on high-intent buyer queries, LLMs resolve “things, not strings”—cross-checking external knowledge graphs, code repositories, and real user discussions.
  7. JSON-LD Schema & Server-Side HTML Readability — Many teams deploy gorgeous React or Vue apps that look crisp in Chrome yet return empty <div id="root"></div> shells to AI crawlers. Delivering Server-Side Rendered (SSR) HTML embedded with explicit JSON-LD guarantees machine comprehension on the first byte.
  8. 5 Real-World Copy-Paste GEO Recipes — Drop these five proven templates straight into your CMS layouts, Schema.org builders, Google Analytics 4 configuration, and weekly prompt-benchmark workflows without vague placeholders.
  9. Bot Crawl Governance & AI Search Attribution KPIs — Precision governance lets you welcome real-time search and citation crawlers while enforcing deliberate boundaries on model training—paired with analytics built for a zero-click, multi-engine buyer journey.
  10. Cross-Tool Synergy: From Prompt Gaps to Verified Pipeline — Sustainable AI Search Visibility operates as a closed feedback loop connecting buyer question intelligence, SSR-rendered Answer-First pages, off-site entity corroboration, CDN crawler telemetry, and CRM pipeline attribution.
  11. Troubleshooting Clinic & GEO Pre-Flight Checklist — Use this diagnostic matrix whenever strong Google-ranking pages vanish from ChatGPT or Perplexity, analytics miss obvious AI mentions, or crawlers misquote product tiers—then verify every launch against the 6-point checklist below.

### Agent-Ready Websites & WebMCP

> Audit sites 0-100 with is-agentic, publish /llms.txt maps and Accept: text/markdown content negotiation, expose browser-native WebMCP tools, and enforce human-in-the-loop safety gates.

- Web: https://twelve-pages.com/guides/visibility-and-workflows/agent-ready-websites-and-webmcp
- Markdown: https://twelve-pages.com/guides/visibility-and-workflows/agent-ready-websites-and-webmcp.md
- PDF: https://twelve-pages.com/guides/visibility-and-workflows/agent-ready-websites-and-webmcp/Agent_Ready_Websites_is_agentic_and_WebMCP_Complete_How_To_Guide.pdf (2.4 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: is-agentic Audits, llms.txt & llms-full.txt, Accept: text/markdown, Browser WebMCP Tools, RFC 9457 Errors, Human Checkout Gates
- Core Takeaways:
  - 0–100 Readiness Audits: Evaluate Essential, Recommended, and Bonus checks via npx is-agentic, the public REST API, or MCP.
  - Zero-Bloat Markdown: Publish /llms.txt maps and Accept: text/markdown negotiation to cut HTML token waste by over 80%.
  - Native Browser WebMCP: Turn HTML forms and frontend functions into typed client-side tools guarded by explicit human confirmation.
- Chapters:
  1. The Dual-Stack Web: Human Interfaces Meet Agent Protocols — Every modern website now serves two very different visitors: people browsing rich visual layouts, and AI agents that need clean Markdown, structured error contracts, and typed browser tools instead of brittle screen scraping.
  2. Setup, is-agentic Audit Tiers & Protocol Matrix — You can measure any public website in seconds with zero API keys or signups, then choose the right mix of Markdown endpoints and WebMCP tools for your architecture.
  3. Annotated Workspace: Is-Agentic Report & WebMCP Inspector — Diagnosing agent readiness means reading both sides of the stack at once: server-side audit evidence from is-agentic and live tool registrations inside the browser’s modelContext inspector.
  4. Auditing & Fixing Sites with is-agentic CLI, API & MCP — Every check in is-agentic is grounded in live HTTP, HTML, and protocol evidence. Pick the interface that matches your environment—command line, REST API, or native MCP tool calls.
  5. Zero-Bloat Discovery: /llms.txt & Accept: text/markdown — Raw HTML pages wrap a few paragraphs of useful knowledge inside megabytes of navigation menus, React hydration bundles, and cookie banners. Clean Markdown files and HTTP content negotiation eliminate that waste.
  6. Browser WebMCP: Turning Pages into Native Agent Tools — Developed in the W3C Web Machine Learning Community Group and available behind chrome://flags/#enable-webmcp-testing in Chrome 146+, WebMCP lets websites publish structured tools directly inside the user’s browser session.
  7. Machine-Readable Errors: RFC 9457 & Agent Recovery — Returning a 40KB styled HTML error page for a rate limit or missing route forces an LLM to burn tokens guessing what went wrong. RFC 9457 application/problem+json turns failures into deterministic instructions.
  8. Five Copy-Paste Recipes for Agent-Ready Websites — Drop these battle-tested templates into documentation sites, SaaS applications, and storefronts to raise your is-agentic score and unlock reliable agent interactions.
  9. Security Boundaries, Rate Limits & Human Confirmation Gates — Because browser WebMCP tools run directly inside an authenticated user’s session with live cookies, high-stakes actions like purchases or account deletions must never execute silently.
  10. Cross-Tool Synergy: From Source Docs to Verified Browser Actions — When static discovery files, edge Markdown negotiation, automated is-agentic audits, and browser WebMCP tools work in concert, agents spend fewer tokens reading and never break on brittle UI selectors.
  11. Troubleshooting Clinic & 6-Point Pre-Flight Checklist — Fast, evidence-backed fixes for the seven most common agentic web integration pitfalls, paired with a pre-flight readiness checklist before you ship to production.

### Bot-Free Meeting Notes & Action Pipelines

> Capture meetings silently without call bots in Granola—merging rough human bullets with local transcripts, custom templates, Ask Granola folder Q&A, Recipes, and Slack, Linear, MCP, and Obsidian _inbox/ sync.

- Web: https://twelve-pages.com/guides/visibility-and-workflows/granola-bot-free-meetings-and-pipelines
- Markdown: https://twelve-pages.com/guides/visibility-and-workflows/granola-bot-free-meetings-and-pipelines.md
- PDF: https://twelve-pages.com/guides/visibility-and-workflows/granola-bot-free-meetings-and-pipelines/Bot_Free_Meeting_Notes_and_Action_Pipelines_Complete_How_To_Guide.pdf (3.1 MB)
- Version: v1.0 | Updated: 2026-11 | Pages: 12
- Tags: Bot-Free Local Audio, Human + AI Hybrid Notes, Custom Meeting Templates, Ask Granola Folder Q&A, Slash Recipes & Remote MCP, Slack, Linear & Obsidian Sync
- Core Takeaways:
  - Zero Awkward Call Bots: Records microphone and system audio locally on macOS, Windows, and iOS across Zoom, Google Meet, Teams, and Slack Huddles—then discards raw audio.
  - Anchored in Your Bullets: Jot tiny rough bullets during conversation; Granola weaves verified transcript context around your priorities instead of drowning decisions in fluff.
  - Automated Action Pipelines: Query whole folders with Ask Granola, trigger slash Recipes, or route structured Markdown via Zapier, Webhooks, MCP, and Obsidian _inbox/.
- Chapters:
  1. Why Hybrid Human-First Notes Beat Passive Call Bots — Traditional meeting bots announce themselves in the participant roster, make external guests guard their words, and email generic summaries where casual banter gets as much weight as pivotal product decisions. Granola works like an intelligent notepad sitting quietly beside your call: it captures device audio locally, keeps your rough bullets as the structural anchor, and merges them with verbatim transcript evidence.
  2. OS Audio Capture, Plan Tiers & Call-Bot Matrix — Because Granola captures audio locally rather than dialing a cloud bot into your meeting room, reliable setup depends on granting two OS permissions cleanly and choosing the tier that unlocks your retention and integration needs.
  3. Annotated Tour: Inside Granola’s Hybrid Notepad — Granola feels like a minimalist, distraction-free notepad parked beside Zoom, Google Meet, Teams, or Slack. Underneath that clean surface sit seven coordinated controls bridging live shorthand, verbatim citations, templates, and post-call automation.
  4. Rough-Bullet Anchoring: Steering AI Without Losing Focus — When people try to transcribe every word themselves, they stop listening; when they let AI summarize a blank notepad, they get bland boilerplate. Granola’s sweet spot is lightweight anchoring—typing tiny memory hooks that guide post-call synthesis.
  5. Custom Templates & the 5-Part Recipe Formula — Power users separate Templates from Recipes: Templates define the clean structural skeleton of your Enhanced Note itself, while Recipes are reusable / slash prompts that turn finished notes into tickets, follow-up emails, or digests.
  6. Ask Granola: Querying Folders & Connecting via MCP — A single meeting note helps you remember Tuesday; thirty structured calls inside a typed folder queried together turn scattered conversations into product strategy, hiring alignment, and agent-ready context.
  7. Automated Pipelines: Slack, Linear, CRM & Obsidian — Once a call wraps and you click Enhance, moving a note into a typed folder—or letting a webhook event fire—can route clean summaries, backlog tickets, CRM updates, and local Markdown files automatically across your entire workspace.
  8. 5 Real-World Copy-Paste Templates & Recipes — Paste these directly into Granola’s custom Template editor, save them as reusable / Slash Recipes, or run them inside a folder’s Ask Granola chat bar right after wrapping up your call.
  9. Consent Guardrails, Audio Retention & Team Privacy — Bot-free capture removes the social friction of an extra participant tile, which shifts legal and ethical transparency squarely onto you and your workspace admins. Configure consent notices and folder boundaries right on day one.
  10. Cross-Tool Synergy: From Live Call to Shipped Work — Granola shines brightest as the calm, bot-free capture layer at the front of your workflow stack—feeding structured knowledge simultaneously into team chat, issue trackers, CRM pipelines, AI coding assistants, and local personal vaults.
  11. Troubleshooting Clinic & Pre-Flight Checklist — Consult this clinic whenever macOS drops system audio, Bluetooth headphones fragment a transcript, Slack Huddles fail to trigger, or older notes lock behind Basic limits—followed by our 6-point pre-flight checklist.
