---
schema_version: 1
revision: "22ce5d34dbcb5a78"
id: "foundations-glossary"
title: "Agent foundations glossary"
---

# Agent foundations glossary

> Original source pages and recordings require authorized access. The full article text here is public.

Vocabulary for describing agent work, with explanations and operational consequences.

## AFK goal loops

John gives an example goal where an agent creates a timestamp, checks other panes every 10 minutes to make sure they are completing their goals, picks the best answer if a pane is blocked by a question, and continues until four hours after the original timestamp. He describes this as an AFK approach where he can set it and walk away.

**Why it matters:** Periodic check-ins can keep multiple running sessions moving, but John also says the upfront planning for parallel work is still something to be actively involved in.

[Apply this concept](/topics/foundations-manager-worker-orchestration/)

## Agent-first tooling

John frames modern dev tools around whether they are open source and agent-first: tools with CLIs, APIs, or other surfaces agents can interact with and control. His point is that you no longer need to personally memorize every flag or shortcut when the agent can inspect the interface and use it.

**Why it matters:** Agent-first tools let your instructions turn into real tool actions: opening panes, running commands, checking status, or operating a CLI. Tools without programmable surfaces put more mechanical work back on the human.

[Apply this concept](/topics/foundations-manager-worker-orchestration/)

## Agent-managed folders

Use local folders like `.notes/` and `.goals/` inside each project as places where agents can write Markdown plans, notes, and goals. John describes these as agent-managed files and as a way to write plans into files you can resume from later.

**Why it matters:** This keeps agent working context close to the codebase while clearly separating it from the source files you intend to commit.

[Apply this concept](/topics/foundations-visible-agent-memory/)

## Agent-readable code structure

When asked about file and function line limits, John rejects arbitrary size rules. The guideline he gives is to prefer state machines, named switch cases, and English-labeled conditions over dense conditional structures.

**Why it matters:** Agents can read, verify, and reason about code more reliably when the control flow exposes human-readable state names.

[Apply this concept](/topics/foundations-narrow-daemons-and-agent-graphs/)

## Background daemons

The “human” daemon runs behind the main session. At each hook, it updates an HTML page from the conversation so far, tracks tool calls, customizes the page for the current work, and gives John a summary when it is done. Right now that dashboard is ephemeral and written to a temp directory, but John says it could be persisted.

**Why it matters:** A daemon is useful when a narrow support task should keep running without interrupting the main session.

[Apply this concept](/topics/foundations-narrow-daemons-and-agent-graphs/)

## ChatGPT Pro Extended context window

John says his $200-plan browser session exposes ChatGPT 5.5 Pro / Pro Extended with much longer context than before: he contrasts older ~50,000-token sessions with newer sessions that can take around a million tokens and often return in 10–15 minutes.

**Why it matters:** The exact limits may change, but the taught idea is to notice that different surfaces have different context limits and to route work accordingly.

[Apply this concept](/topics/foundations-oracle-context-routing/)

## CMUX as a primary orchestrator

John demonstrates a main CMUX session opening specialized Codex panes for quality control, performance, research, and notes. The main pane becomes the coordinator, while each child pane has a narrow role and can work independently.

**Why it matters:** This keeps context cleaner and makes delegation visible. It gives you a practical way to monitor several agent tracks without dumping every task into one large prompt thread.

[Apply this concept](/topics/foundations-multimodal-design-and-model-routing/)

## CMUX state for context-aware shortcuts

John describes a CMUX inspect-style command that exposes the multiplexer state as an object, including the focused pane and that pane’s current working directory. He uses that context with a Karabiner shortcut to open tools over the terminal he is already focused on.

**Why it matters:** It turns the terminal layout into an automation surface: a shortcut can open an editor, run Git commands, start debugging, or trigger other tools in the project you are currently looking at.

[Apply this concept](/topics/foundations-perspective-qa-and-testing/)

## Code as the Source of Truth

Project memory can be useful, but it drifts as the code changes. John’s main point is that trying to update memory on every commit can turn into a parallel maintenance problem, so the safest default is to make the agent look at the current code when implementation details matter.

**Why it matters:** It keeps agents from confidently acting on outdated assumptions and keeps the workflow tied to what actually exists in the repo.

[Apply this concept](/topics/foundations-source-truth-and-design/)

## Codex-to-browser quota offloading

John explains that dense, high-context questions can be sent to ChatGPT Pro Extended in the browser instead of spending Codex's interactive token and rate-limit budget. He describes this as useful for complicated questions where you want a large amount of packed context.

**Why it matters:** Large repo-reading prompts can burn through Codex limits quickly. Routing the heavyweight analysis to the browser keeps Codex available for the parts of the workflow that need an agent to continue acting.

[Apply this concept](/topics/foundations-oracle-context-routing/)

## Compaction and conversation forking

Compaction is the move of shrinking a long conversation down to the pieces that still matter. John framed it as useful when you fork a conversation and want the new branch to focus on one topic, like a specific test file, instead of carrying unrelated history forward. The practical benefits he called out were fewer tokens, faster runs, lower budget/quota pressure, and a clearer sense of what the agent is working on.

**Why it matters:** Long conversations can carry a lot of irrelevant context. Forking plus focused compaction gives the next session a cleaner starting point.

[Apply this concept](/topics/foundations-hooks-and-context-hygiene/)

## Context pruning for low-latency daemons

The codex-daemons demo shows an advanced experiment in stripping agent startup context. John redirects the Codex home directory, symlinks the needed auth file, disables memories, MCP servers, web search, and Agents.md/project rules, and runs hyper-specific daemon commands on Codex Spark Low by default. He also shows SDK thread warm-up so the first prompt can skip several seconds of startup work.

**Why it matters:** For repetitive, well-scoped CLI-style tasks, less context can mean faster responses, lower quota pressure, and fewer distractions.

[Apply this concept](/topics/foundations-deterministic-verification-and-boundaries/)

## Context triad: intent, implementation, output

For difficult debugging, John teaches bundling the expected behavior, the relevant code, and the observed runtime evidence. The evidence can include logs, console output, screenshots, traces, performance profiles, QA-script artifacts, and other files produced while the app is actually running.

**Why it matters:** Models reason better when they can compare what should have happened, how the code attempted it, and what actually happened during execution.

[Apply this concept](/topics/foundations-context-triad-and-overnight-work/)

## Cross-pane context reading

John demonstrates that CMUX can read the contents of other tabs or panes by echoing text in one tab and asking another what that tab said. He explains that agents can check other panes, workspaces, recent commands, Git actions, and signs that something needs attention.

**Why it matters:** This is what makes multiple panes more than just visual clutter. A main or sibling agent can inspect what is happening elsewhere and summarize it for you.

[Apply this concept](/topics/foundations-manager-worker-orchestration/)

## Custom grammar triggers

A custom grammar trigger is a small token like #human, #toolsmith, #memory, or #search that a User Prompt hook can detect before the agent proceeds. John likes this because it keeps Codex vanilla by default and only loads the specific system, plugin, skill, or context bundle when he explicitly asks for it.

**Why it matters:** This gives you a clean way to personalize sessions without polluting every conversation with skills or context the task does not need.

[Apply this concept](/topics/foundations-hooks-and-context-hygiene/)

## Design.md from Generated Inspiration

John demonstrated starting design work from an inspiration board made of generated images, not scraped sites. He selected visual directions, copied them into an AI prompt, asked Codex to create a hoodie company landing page, and showed the generated design.md with references, style DNA, colors, typography, layout, composition, shape, and motion.

**Why it matters:** It turns vague taste into a concrete design artifact that the agent can use to generate UI that follows a direction instead of producing a generic layout.

[Apply this concept](/topics/foundations-source-truth-and-design/)

## Diff-Driven Review

John reduces an agent run to a simple equation: prompt plus agent, harness, and skills equals diff. The diff is the concrete artifact worth reviewing, testing against, and handing to a fresh session for critique.

**Why it matters:** It gives you a clean review loop. A second agent can inspect the goal and diff without inheriting the first agent’s assumptions.

[Apply this concept](/topics/foundations-contracts-state-machines-and-code/)

## Discardable QA files

A QA file is a temporary assignment document for an agent: a numbered list of things to try, paths to walk, buttons to find, and a perspective to act from. John treats these as created in the moment, not as permanent test infrastructure.

**Why it matters:** They let you test the current shape of a fast-changing product without locking every changing UI decision into a brittle long-term test suite.

[Apply this concept](/topics/foundations-perspective-qa-and-testing/)

## Disposable Code, Durable Ideas

John explicitly says not to get too attached to a specific workflow or generated code artifact. A plugin, hook, or implementation can be generated quickly and thrown away later.

**Why it matters:** The idea, boundary, state machine, module structure, and product intent matter more than the exact code the current agent happened to write.

[Apply this concept](/topics/foundations-contracts-state-machines-and-code/)

## Global gitignore partitioning

Instead of adding `.notes/` and `.goals/` to every repository's `.gitignore`, John suggests globally ignoring those directories on your machine. That lets the same local agent-memory folders exist across projects without being checked into repos.

**Why it matters:** It creates a machine-level boundary between private local agent scratch work and shared source control.

[Apply this concept](/topics/foundations-visible-agent-memory/)

## Image generation as design reference

For UI work, John recommends generating sheets of visual variations before committing to a direction. For example, he describes taking a screenshot of a component and asking for many variations, then picking the favorite as the design direction.

**Why it matters:** Images collapse ambiguity. They let non-designers express taste through selection, which is often easier than inventing exact CSS, spacing, motion, and layout language from scratch.

[Apply this concept](/topics/foundations-multimodal-design-and-model-routing/)

## Large-Context Snapshots as a Possible Escape Hatch

John briefly floated million-token context windows as a possible way to take useful snapshots of codebases, but he explicitly framed it as something he had not really tried yet. In this lesson, it is a possible direction, not a proven replacement for memory.

**Why it matters:** The useful idea is that current code text is more trustworthy than detached summaries, but this section does not teach a full large-context snapshot workflow.

[Apply this concept](/topics/foundations-source-truth-and-design/)

## Lightweight Markdown Memory

John still sees value in basic memory when it stays simple: Markdown files, simple RAG, and human-readable notes. The danger starts when memory becomes a second system that has to be kept in sync with a fast-moving codebase.

**Why it matters:** Good memory reduces repeated explanation; bad memory becomes stale documentation that misleads both humans and agents.

[Apply this concept](/topics/foundations-source-truth-and-design/)

## Live Markdown side panes

A Markdown file can become a live visual progress view if the agent updates it while working and the client auto-refreshes the rendered pane. John demonstrates this with a simple `test.md` file in CMUX and describes using Markdown as a checklist, progress view, summary, or conversation-history display.

**Why it matters:** It lets you step away from the noisy agent transcript and return to a cleaner status view of what changed or what is happening.

[Apply this concept](/topics/foundations-visible-agent-memory/)

## Living Guardrails

Files like agents.md or claude.md should stay fairly minimal and evolve with the project. John suggests reviewing recent commits, learning from mistakes, and iterating on the agent instructions over time.

**Why it matters:** Mistakes become useful artifacts when they update the project’s guardrails. The file should capture real project knowledge, not a giant upfront rulebook.

[Apply this concept](/topics/foundations-contracts-state-machines-and-code/)

## Log-based deterministic gates

John's default answer to verification is to write logs or other artifacts to files. Depending on the project, those artifacts might show that a file was created, an API call happened, an object had the expected shape, timestamps were recorded, or multiple sessions produced comparable outputs. A main agent can wait for worker sessions to finish, inspect the logs and text output, and compare them against the criteria.

**Why it matters:** Agents are useful reviewers, but artifacts are the evidence. Logs make fix-verify loops inspectable instead of trust-based.

[Apply this concept](/topics/foundations-deterministic-verification-and-boundaries/)

## Low-reasoning iteration

John says low reasoning is underutilized, but it needs a different style of prompting. You should expect it to fail while you dial it in, because it will not deeply think through ambiguous work on its own. It works better when the job is narrow and the prompt accounts for the specific tool, CLI, API, or failure modes involved.

**Why it matters:** Small, focused low-reasoning runs can be useful for high-frequency automation when the prompt and tool scope are explicit.

[Apply this concept](/topics/foundations-narrow-daemons-and-agent-graphs/)

## Manager-worker topology

John describes treating himself as the CEO, one pane as the Manager, and other panes as workers. He tries to talk mainly to the Manager, which can open panes and send workers to investigate, research, or do other tasks.

**Why it matters:** A manager pane keeps the human interaction surface smaller while still letting several agents or terminal sessions do work in parallel.

[Apply this concept](/topics/foundations-manager-worker-orchestration/)

## MCP versus CLI boundaries

John warns that it can get weird to build a skill just to call an MCP wrapper when the skill could have called a CLI directly. His broader rule is to define boundaries around what needs tests, what needs flexibility, where memory belongs, and which agents should have access to which tools.

**Why it matters:** Clear boundaries make agent systems easier to reason about. If a workflow is deterministic and testable, a direct CLI or script may be simpler than an unnecessary MCP layer; use agent reasoning where judgment, interpretation, or flexible planning actually adds value.

[Apply this concept](/topics/foundations-multimodal-design-and-model-routing/)

## MCP/browser automation bridge

After the context is packed, the workflow makes an MCP call that reaches over to a browser on John's Mac mini, opens the ChatGPT session, inserts the prompt, and submits it.

**Why it matters:** The MCP step is the bridge that lets the current agent trigger the outside browser workflow instead of requiring John to manually paste the packed prompt.

[Apply this concept](/topics/foundations-oracle-context-routing/)

## Model choice by task shape

John frames Codex as his default coding worker, especially when goal-following and token efficiency matter. Claude can be useful as a conversational manager or design helper, while Flash-style models are best for quick, tightly scoped tasks and weaker for long chains that require self-correction.

**Why it matters:** Good model choice is a cost and reliability decision, not a brand preference. Matching the model to the task reduces wasted tokens and lowers the odds of an agent spiraling while trying to fix its own mistake.

[Apply this concept](/topics/foundations-multimodal-design-and-model-routing/)

## Multimodal verification loops

John explains a comic-generation workflow where Codex generates an image, then reads the generated image back in and compares it to previous images. The verification pass can check continuity details such as whether a character has legs or whether counts match across frames. He also discusses asking UI work to return mathematical payloads for padding, margins, spacing, and layout.

**Why it matters:** Generated artifacts should be inspected against concrete constraints instead of trusted after one prompt.

[Apply this concept](/topics/foundations-narrow-daemons-and-agent-graphs/)

## Natural language terminal orchestration

John demonstrates asking CMUX to open a new pane to the right, then asking it to open five more panes, run different safe commands in them, and space everything evenly. The agent uses the CMUX CLI surface to translate natural language into layout and terminal actions.

**Why it matters:** This makes the terminal workspace programmable. You can describe the workspace you need instead of manually arranging panes and remembering multiplexer commands.

[Apply this concept](/topics/foundations-manager-worker-orchestration/)

## Natural-language contract boundaries

John frames modules, tools, and CLIs as boundaries that agents can own. A master orchestrator can hold broader project context and spin up focused agents, while each worker gets a narrow task, limited tools, and a clear English instruction payload. He compares this to API contracts, except the handoff can be natural language sent to an agent.

**Why it matters:** Narrow agents are faster, easier to inspect, cheaper to run, and less likely to get distracted by unrelated context.

[Apply this concept](/topics/foundations-deterministic-verification-and-boundaries/)

## Natural-Language Contracts

A natural-language contract is a plain-English description of what a tool, app, or agent is supposed to do. John frames this as an "agent first" mindset: define the work in language so the underlying tool can change without destroying the workflow.

**Why it matters:** It keeps you from overfitting to today’s specific tool, harness, plugin, or workflow. The portable asset is the intent.

[Apply this concept](/topics/foundations-contracts-state-machines-and-code/)

## Natural-language loose coupling

For team workflows and tools, John recommends staying flexible: capture meetings and workflow complaints, iterate on how the team works, and prefer open-source, agent-first tools whose main contract is natural language. He uses the ability to abandon a tool easily as the point.

**Why it matters:** Tools are changing quickly, so teams should avoid investing too heavily in brittle workflows tied to one vendor or interface.

[Apply this concept](/topics/foundations-context-triad-and-overnight-work/)

## Numbered option planning

Ask the agent for a numbered list where each item has options such as A, B, and C, and have the agent explain which option it thinks is best. You can then review the document and respond with precise targets like `5B` or `27D`.

**Why it matters:** It turns a large plan into an editable map, so you can steer the agent precisely without rewriting or quoting long sections.

[Apply this concept](/topics/foundations-visible-agent-memory/)

## Oracle browser handoff

Oracle lets a current Codex session ask a browser session to do the heavy analysis: it packs things up, sends them to the browser, waits for the browser model to work, and then brings the result back into the coding session.

**Why it matters:** This creates a handoff between a local agent workflow and a logged-in browser model without manually copying a massive prompt every time.

[Apply this concept](/topics/foundations-oracle-context-routing/)

## Overnight emulated crons

Because Codex does not have a built-in cron in this workflow, John describes writing a goal that creates a timestamp, repeats a task every 10 minutes, and continues until a fixed duration or target time such as 9 AM.

**Why it matters:** This gives Codex a bounded long-running loop without pretending it is a real scheduler.

[Apply this concept](/topics/foundations-context-triad-and-overnight-work/)

## PackX context bundling

In the demo, John's Oracle PackX skill uses a pack tool to gather files related to a query. The run shown packs 45 files and reports roughly 585,000 tokens before sending the bundle to Oracle.

**Why it matters:** PackX is the part of the workflow that turns scattered repo files into one large model-readable payload for the browser analysis pass.

[Apply this concept](/topics/foundations-oracle-context-routing/)

## PackX for file collation

John shows PackX, a tool he built to collate a bunch of files into a single file. He explains that it supports file globs, patterns, and options, and that he typically lets the agent learn and use the CLI flags instead of using the tool manually.

**Why it matters:** It is an example of agent-first thinking: give the agent a useful CLI tool and let it handle the exact flags and patterns needed for the current context.

[Apply this concept](/topics/foundations-manager-worker-orchestration/)

## Perspective-based prompting

Instead of asking one generic agent to research or test your app, assign it a lens: expert, new user, grandma, power user, or another real audience. That lens changes what the agent notices and which assumptions it challenges.

**Why it matters:** It helps you escape creator bias and shape the output around the actual demographics or user types your application needs to support.

[Apply this concept](/topics/foundations-perspective-qa-and-testing/)

## Plan-first goal grounding

John says he often has the agent create a full plan document first, then reads it and dictates or types feedback about specific sections. He may use GrillMe only when he is still uncertain after seeing the plan.

**Why it matters:** Reacting to a concrete plan can be faster than answering a long sequence of upfront questions.

[Apply this concept](/topics/foundations-visible-agent-memory/)

## Plan, implement, verify loop

John shows the broader pattern he uses: create a list of QA stories or goals, use Oracle to create a plan for each one, then implement it and verify it.

**Why it matters:** The value is not just a one-off giant prompt; it is turning high-context planning into a repeatable loop that feeds back into actual code work.

[Apply this concept](/topics/foundations-oracle-context-routing/)

## QA artifacts as live application evidence

John describes logs as a representation of the live app running and recommends shaping QA scripts and project-specific dev tools so they deliberately write useful artifacts. Those artifacts can then be bundled with code using PackX or another bundler for analysis by a stronger model.

**Why it matters:** A model that sees real artifacts from a user flow can diagnose behavior instead of guessing from source files alone.

[Apply this concept](/topics/foundations-context-triad-and-overnight-work/)

## SDK agent graphs

John says the SDK is the right tool when you need custom agents with managed threads, managed settings, warm background behavior, and structured workflows. He describes workflows where one agent hands work to another, branches into parallel research agents, then uses an analysis step to choose or synthesize the best plans before implementation.

**Why it matters:** The SDK is useful when the workflow has explicit roles, sequencing, branching, fan-out, or fan-in that should be locked into code instead of improvised in one chat.

[Apply this concept](/topics/foundations-narrow-daemons-and-agent-graphs/)

## Self-improvement error loops

When a plugin or hook fails, John copies the failed session text and asks the agent to explain why the plugin failed in that scenario and how to account for it next time. The point is not just to fix one run, but to use the exact fail case to harden the tool or workflow.

**Why it matters:** Tooling compounds when each failure leaves behind a stronger hook, workflow, or guardrail.

[Apply this concept](/topics/foundations-deterministic-verification-and-boundaries/)

## Self-improving daemons

John shows the self-improve idea: when each turn ends, the daemon reads the transcript, looks for ways it can improve, finds its own file, and updates its own prompts or source. He says this is much more plausible for specific CLIs, tools, or APIs with clear tasks and predictable failure modes than for large projects that can branch in many directions.

**Why it matters:** For narrow tools, repeated failures can become better operating instructions for future runs.

[Apply this concept](/topics/foundations-narrow-daemons-and-agent-graphs/)

## Short /goal files and Oracle-generated plans

John shows that many of his goal prompts are plain and short, such as asking for a specific layout fix. For complex work, he often asks Oracle to research the problem and generate a more detailed goal file, then drops that file into his `.goals` directory for Codex to run through research, implementation, and verification.

**Why it matters:** Simple tasks do not need massive prompts, while complex tasks benefit from a stronger planning pass before Codex executes the work.

[Apply this concept](/topics/foundations-context-triad-and-overnight-work/)

## Skills versus plugins

John contrasts skills with plugins as a difference between context-based guidance and deterministic control. Skills put descriptions into the model's context so the agent can infer when and how to use them. Plugins can hook into events and enforce behavior, including starting or stopping things, allowing or disallowing actions, or calling specific tools.

**Why it matters:** For workflows you want to enforce, John recommends reaching for a plugin with hooks instead of trying to make skill instructions clearer and clearer.

[Apply this concept](/topics/foundations-hooks-and-context-hygiene/)

## Small context and specialized tool context

John repeatedly frames these daemon runs as small compared with normal Codex/GPT sessions, mentioning a target of staying under about 10,000 tokens of context. He also uses the Vercel plugin story to show that giving a weaker model the right tools and focused context can outperform a stronger model without that context.

**Why it matters:** Narrow context lowers usage and keeps the model focused on the job it was built to do.

[Apply this concept](/topics/foundations-narrow-daemons-and-agent-graphs/)

## Specialized agents and Codex daemons

John connects Planner, Builder, Researcher, and Validator-style responsibilities to specialized agents. His Codex daemon point in this section is high level: create custom, reusable agents for a specific project need, give them the relevant requirements, and reuse them instead of making one agent handle everything.

**Why it matters:** Custom systems that understand your project can support workflows that generic shared skills may not cover.

[Apply this concept](/topics/foundations-context-triad-and-overnight-work/)

## State Machines and Modular Boundaries

When a codebase can grow by tens of thousands of lines overnight, John says the safety comes from structure: isolated modules and business logic that is navigable through state machines.

**Why it matters:** These boundaries let humans and agents digest, regenerate, refactor, or replace implementation details without losing the shape of the product.

[Apply this concept](/topics/foundations-contracts-state-machines-and-code/)

## Terminal text extraction as context

John shows a CMUX shortcut, Cmd-Opt-Shift-J in his setup, that takes the current terminal session and opens it as plain selectable text in an editor-like pane. Instead of fighting terminal scrollback, colors, and selection behavior, he copies the exact failure state and uses it as agent context.

**Why it matters:** The fastest debugging loop starts with the real failure, not a vague summary of what you think happened.

[Apply this concept](/topics/foundations-deterministic-verification-and-boundaries/)

## The 5 Monkeys technique

The goal is to have agents use the app in non-obvious ways: find buttons, click around, try shortcuts, press back after reaching a page, and look for modes or state that stay open unexpectedly.

**Why it matters:** This catches UX and state issues that a normal verification prompt may miss because the model tends to follow the same visible patterns the developer already expects.

[Apply this concept](/topics/foundations-perspective-qa-and-testing/)

## The big three hooks

John breaks the agent loop into three core events: User Prompt, Tool Use, and Stop. User Prompt fires when you type something and submit it, Tool Use fires when a tool runs, and Stop fires when the conversation would normally end and wait for you. These are the main places where a hook can do something with the session.

**Why it matters:** Once you understand these three events, plugins stop feeling mysterious. They become small programs attached to predictable moments in the agent lifecycle.

[Apply this concept](/topics/foundations-hooks-and-context-hygiene/)

## The Ralph Loop

The Ralph Loop is John's shorthand for a Stop-hook-driven loop. When the agent tries to stop, the hook can tell the harness not to stop yet, look back at what the user originally asked for, and keep working until a condition is met. John described this as the basic idea behind goal-style sessions.

**Why it matters:** This matters when you want an agent to keep working on a goal instead of handing control back after one assistant turn.

[Apply this concept](/topics/foundations-hooks-and-context-hygiene/)

## Throwaway Route Variants

Instead of building a heavy Storybook setup for every experiment, John often asks agents to generate multiple temporary routes or page copies using the same components with different styles. He compares them in the app with simple navigation, picks the best direction, and deletes the rest.

**Why it matters:** It supports fast visual exploration without creating another maintenance surface that has to be kept up to date.

[Apply this concept](/topics/foundations-source-truth-and-design/)

## Unread notification jumping

John shows that CMUX can surface notifications from sessions and that Cmd+Shift+U jumps to unread activity. He uses it to jump to a pane where a session had stopped.

**Why it matters:** When many sessions are running, jumping to the pane that needs attention is faster than manually scanning every pane.

[Apply this concept](/topics/foundations-manager-worker-orchestration/)

## Vault and resumed conversations

John demonstrates the CMUX right sidebar with Files, Find, and Vault. In the Vault, he can look through past conversations and resume one in a new tab, though he notes the feature is still in development and search is not great yet.

**Why it matters:** Resuming old context is useful when you lose or want to continue a previous conversation without manually reconstructing what happened.

[Apply this concept](/topics/foundations-manager-worker-orchestration/)

## Video prompting for high-context intent

John describes uploading video to Gemini by hand and also using scripts that upload to Google's backend to extract code snippets, key parts, timestamps, and screenshots. Video can preserve the flow of a demo or code walkthrough better than a written description because the model sees the sequence of states.

**Why it matters:** When the task depends on timing, UI state, or code changing over time, video can carry intent that text misses. The practical caveat he names is that scripted backend use can involve cost and auth-token setup.

[Apply this concept](/topics/foundations-multimodal-design-and-model-routing/)

## Video-as-Requirements

John recommends recording yourself or users actually using the app while speaking intent out loud. The recording captures clicks, typing, layout changes, responsive behavior, and what the person wanted from the app.

**Why it matters:** It captures human interaction that is hard to fully express in written specs. A video-capable model can help turn that usage into requirements, goals, and QA stories.

[Apply this concept](/topics/foundations-contracts-state-machines-and-code/)

## Video-driven intent extraction

John records a rough screen interaction, narrates UI changes aloud, and drops the video into Gemini to turn it into AI instructions for implementation.

**Why it matters:** It lowers the cost of explaining visual changes when pointing, circling, and talking are faster than writing a polished written spec.

[Apply this concept](/topics/foundations-perspective-qa-and-testing/)

## Related vocabulary

- **Workflow Optimization** — [Route large codebase questions through Oracle](/topics/foundations-oracle-context-routing/).
- **Resource Management** — [Route large codebase questions through Oracle](/topics/foundations-oracle-context-routing/).
- **Architecture** — [Route large codebase questions through Oracle](/topics/foundations-oracle-context-routing/).
- **Agent-First Software Design** — [Coordinate agents with a manager and worker panes](/topics/foundations-manager-worker-orchestration/).
- **The Manager-Worker Topology** — [Coordinate agents with a manager and worker panes](/topics/foundations-manager-worker-orchestration/).
- **Natural Language Layout Control** — [Coordinate agents with a manager and worker panes](/topics/foundations-manager-worker-orchestration/).
- **Cross-Pane Terminal Context Reading** — [Coordinate agents with a manager and worker panes](/topics/foundations-manager-worker-orchestration/).
- **AFK Automation Loops** — [Coordinate agents with a manager and worker panes](/topics/foundations-manager-worker-orchestration/).
- **Agent-Managed Folders** — [Keep agent memory visible and grounded](/topics/foundations-visible-agent-memory/).
- **Global Gitignore Partitioning** — [Keep agent memory visible and grounded](/topics/foundations-visible-agent-memory/).
- **Targeted Matrix Refinement** — [Keep agent memory visible and grounded](/topics/foundations-visible-agent-memory/).
- **Token Optimization** — [Keep agent memory visible and grounded](/topics/foundations-visible-agent-memory/).
- **Agent First Extensibility Paradigm** — [Keep agent memory visible and grounded](/topics/foundations-visible-agent-memory/).
- **Live Check-Back Tracking Files** — [Keep agent memory visible and grounded](/topics/foundations-visible-agent-memory/).
- **Native Harness Memory Systems** — [Keep agent memory visible and grounded](/topics/foundations-visible-agent-memory/).
- **Basic Memory vs. Stale Memory** — [Trust current source and capture design decisions](/topics/foundations-source-truth-and-design/).
- **Source-of-Truth Code** — [Trust current source and capture design decisions](/topics/foundations-source-truth-and-design/).
- **Million-Token Snapshot Contexts** — [Trust current source and capture design decisions](/topics/foundations-source-truth-and-design/).
- **YOLO Bypassing (Sandbox Approvals)** — [Trust current source and capture design decisions](/topics/foundations-source-truth-and-design/). Contextual term only: approval bypassing is not a requirement or recommendation for the design/variant workflows.
- **Design.md File Standard** — [Trust current source and capture design decisions](/topics/foundations-source-truth-and-design/).
- **Multi-Route Structural Variants** — [Trust current source and capture design decisions](/topics/foundations-source-truth-and-design/).
- **Perspective-Based Prompting** — [Explore software through perspectives and runtime QA](/topics/foundations-perspective-qa-and-testing/).
- **Discardable QA Files** — [Explore software through perspectives and runtime QA](/topics/foundations-perspective-qa-and-testing/).
- **The 5 Monkeys Technique** — [Explore software through perspectives and runtime QA](/topics/foundations-perspective-qa-and-testing/).
- **Contextual Multiplexer Inspection via JSON** — [Explore software through perspectives and runtime QA](/topics/foundations-perspective-qa-and-testing/).
- **Video-Driven Intent Extraction** — [Explore software through perspectives and runtime QA](/topics/foundations-perspective-qa-and-testing/).
- **Single-Threaded Main Prototyping** — [Explore software through perspectives and runtime QA](/topics/foundations-perspective-qa-and-testing/).
- **System-Monitoring Safeguards** — [Explore software through perspectives and runtime QA](/topics/foundations-perspective-qa-and-testing/).
- **Agent-Assisted Profiling** — [Explore software through perspectives and runtime QA](/topics/foundations-perspective-qa-and-testing/).
- **CMUX Primary Orchestrator Pattern** — [Use images, video, and task-shaped model routing](/topics/foundations-multimodal-design-and-model-routing/).
- **Token Efficiency** — [Use images, video, and task-shaped model routing](/topics/foundations-multimodal-design-and-model-routing/).
- **Flash Models** — [Use images, video, and task-shaped model routing](/topics/foundations-multimodal-design-and-model-routing/).
- **Image Generation as Design Reference** — [Use images, video, and task-shaped model routing](/topics/foundations-multimodal-design-and-model-routing/).
- **Video Prompting** — [Use images, video, and task-shaped model routing](/topics/foundations-multimodal-design-and-model-routing/).
- **Physical Pomodoro Anchor** — [Use images, video, and task-shaped model routing](/topics/foundations-multimodal-design-and-model-routing/).
- **Image-to-Design Hand-off** — [Use images, video, and task-shaped model routing](/topics/foundations-multimodal-design-and-model-routing/).
- **MCP vs. CLI Boundary Dilemma** — [Use images, video, and task-shaped model routing](/topics/foundations-multimodal-design-and-model-routing/).
- **Compaction** — [Control agent lifecycle with hooks and context hygiene](/topics/foundations-hooks-and-context-hygiene/).
- **Conversation Forking** — [Control agent lifecycle with hooks and context hygiene](/topics/foundations-hooks-and-context-hygiene/).
- **User Prompt Hook** — [Control agent lifecycle with hooks and context hygiene](/topics/foundations-hooks-and-context-hygiene/).
- **Tool Use Hook** — [Control agent lifecycle with hooks and context hygiene](/topics/foundations-hooks-and-context-hygiene/).
- **Stop Hook** — [Control agent lifecycle with hooks and context hygiene](/topics/foundations-hooks-and-context-hygiene/).
- **Ralph Loop** — [Control agent lifecycle with hooks and context hygiene](/topics/foundations-hooks-and-context-hygiene/).
- **Skills vs Plugins** — [Control agent lifecycle with hooks and context hygiene](/topics/foundations-hooks-and-context-hygiene/).
- **Custom Grammar Interceptors** — [Control agent lifecycle with hooks and context hygiene](/topics/foundations-hooks-and-context-hygiene/).
- **CMUX Text Mode Pane Extraction** — [Verify fixes with deterministic evidence and narrow boundaries](/topics/foundations-deterministic-verification-and-boundaries/).
- **Self-Improvement Error Loop** — [Verify fixes with deterministic evidence and narrow boundaries](/topics/foundations-deterministic-verification-and-boundaries/).
- **Log-Based Deterministic Gates** — [Verify fixes with deterministic evidence and narrow boundaries](/topics/foundations-deterministic-verification-and-boundaries/).
- **Natural Language Contract Boundaries** — [Verify fixes with deterministic evidence and narrow boundaries](/topics/foundations-deterministic-verification-and-boundaries/).
- **Context Pruning** — [Verify fixes with deterministic evidence and narrow boundaries](/topics/foundations-deterministic-verification-and-boundaries/).
- **Thread Warm-Up Low-Latency Pattern** — [Verify fixes with deterministic evidence and narrow boundaries](/topics/foundations-deterministic-verification-and-boundaries/).
- **Background Daemons** — [Build narrow daemons and inspectable agent graphs](/topics/foundations-narrow-daemons-and-agent-graphs/).
- **Self-Aware Code Scripts** — [Build narrow daemons and inspectable agent graphs](/topics/foundations-narrow-daemons-and-agent-graphs/).
- **Low Reasoning Iteration** — [Build narrow daemons and inspectable agent graphs](/topics/foundations-narrow-daemons-and-agent-graphs/).
- **Context Ceiling Strategy** — [Build narrow daemons and inspectable agent graphs](/topics/foundations-narrow-daemons-and-agent-graphs/).
- **Multi-Agent Swarms** — [Build narrow daemons and inspectable agent graphs](/topics/foundations-narrow-daemons-and-agent-graphs/).
- **Bespoke Platform Constraints** — [Build narrow daemons and inspectable agent graphs](/topics/foundations-narrow-daemons-and-agent-graphs/).
- **Multimodal Quality Assurance Loop** — [Build narrow daemons and inspectable agent graphs](/topics/foundations-narrow-daemons-and-agent-graphs/).
- **Semantic Syntax Engineering** — [Build narrow daemons and inspectable agent graphs](/topics/foundations-narrow-daemons-and-agent-graphs/).
- **Context Triad** — [Combine intent, implementation, and output for autonomous work](/topics/foundations-context-triad-and-overnight-work/).
- **Agent Archetypes** — [Combine intent, implementation, and output for autonomous work](/topics/foundations-context-triad-and-overnight-work/).
- **Codex Demons** — [Combine intent, implementation, and output for autonomous work](/topics/foundations-context-triad-and-overnight-work/).
- **Overnight Emulated Crons** — [Combine intent, implementation, and output for autonomous work](/topics/foundations-context-triad-and-overnight-work/).
- **Natural Language Loose Coupling** — [Combine intent, implementation, and output for autonomous work](/topics/foundations-context-triad-and-overnight-work/).
- **Natural-Language Contracts** — [Preserve contracts and state machines while code changes](/topics/foundations-contracts-state-machines-and-code/).
- **Video-as-Requirements** — [Preserve contracts and state machines while code changes](/topics/foundations-contracts-state-machines-and-code/).
- **Code as a Throwaway Artifact** — [Preserve contracts and state machines while code changes](/topics/foundations-contracts-state-machines-and-code/).
- **Complexity Management Strategy (State Machine + Module)** — [Preserve contracts and state machines while code changes](/topics/foundations-contracts-state-machines-and-code/).
- **Living Guardrails (agents.md)** — [Preserve contracts and state machines while code changes](/topics/foundations-contracts-state-machines-and-code/).
- **The Bifurcated Engineer** — [Preserve contracts and state machines while code changes](/topics/foundations-contracts-state-machines-and-code/).

## Original references

- [Agent terminology (authorized access required)](https://codex-workshop-followup.pages.dev/glossary.html)
