{
  "schemaVersion": "1",
  "revision": "22ce5d34dbcb5a78",
  "id": "foundations-narrow-daemons-and-agent-graphs",
  "slug": "narrow-daemons-and-agent-graphs",
  "title": "Build narrow daemons and inspectable agent graphs",
  "summary": "Run focused background daemons that update a human-readable HTML dashboard; Use low-reasoning iteration with a deliberately small-context strategy; Coordinate SDK multi-agent graphs with a multimodal verification loop.",
  "category": "Execution",
  "tags": [
    "daemons",
    "SDK",
    "low reasoning"
  ],
  "sources": [
    {
      "label": "Agent foundations: Build narrow daemons and inspectable agent graphs (authorized access required)",
      "url": "https://codex-workshop-followup.pages.dev/lesson-09.html"
    }
  ],
  "sourceUnits": [
    "oracle/lessons.json#09/objectives",
    "oracle/09-references.json#recap",
    "oracle/09-references.json#concepts/0",
    "oracle/09-references.json#concepts/1",
    "oracle/09-references.json#concepts/2",
    "oracle/09-references.json#concepts/3",
    "oracle/09-references.json#concepts/4",
    "oracle/09-references.json#concepts/5",
    "oracle/09-references.json#concepts/6",
    "oracle/09-references.json#references",
    "oracle/09-references.json#recommendations",
    "oracle/09-interactive.json#intro",
    "oracle/09-interactive.json#checklist",
    "oracle/09-interactive.json#challenges",
    "oracle/09-interactive.json#quiz",
    "oracle/09-interactive.json#reflect",
    "oracle/09-references.json#goDeeper",
    "materials/exercises.md#Chunk-09",
    "materials/qa-index.md#Q042",
    "materials/qa-index.md#Q043",
    "materials/qa-index.md#Q044",
    "materials/qa-index.md#Q045",
    "materials/qa-index.md#Q046",
    "materials/qa-index.md#Q047",
    "materials/qa-index.md#Q048",
    "materials/keyframes.md#Chunk-09",
    "lesson-09.html#resource-packet",
    "lesson-09.html#clip-map",
    "lesson-09.html#recording"
  ],
  "collection": "foundations",
  "categoryId": "execution",
  "wordCount": 3126,
  "url": "/topics/foundations-narrow-daemons-and-agent-graphs/",
  "markdownUrl": "/markdown/foundations-narrow-daemons-and-agent-graphs.md?raw=1&v=22ce5d34dbcb5a78",
  "jsonUrl": "/api/v1/documents/foundations-narrow-daemons-and-agent-graphs.json",
  "headings": [
    {
      "id": "working-outcomes",
      "text": "Working outcomes",
      "level": 2
    },
    {
      "id": "concepts-and-consequences",
      "text": "Concepts and consequences",
      "level": 2
    },
    {
      "id": "background-daemons",
      "text": "Background daemons",
      "level": 3
    },
    {
      "id": "low-reasoning-iteration",
      "text": "Low-reasoning iteration",
      "level": 3
    },
    {
      "id": "small-context-and-specialized-tool-context",
      "text": "Small context and specialized tool context",
      "level": 3
    },
    {
      "id": "self-improving-daemons",
      "text": "Self-improving daemons",
      "level": 3
    },
    {
      "id": "sdk-agent-graphs",
      "text": "SDK agent graphs",
      "level": 3
    },
    {
      "id": "multimodal-verification-loops",
      "text": "Multimodal verification loops",
      "level": 3
    },
    {
      "id": "agent-readable-code-structure",
      "text": "Agent-readable code structure",
      "level": 3
    },
    {
      "id": "reference-tools-and-resources",
      "text": "Reference tools and resources",
      "level": 2
    },
    {
      "id": "johnlindquist-codex-daemons",
      "text": "johnlindquist/codex-daemons",
      "level": 3
    },
    {
      "id": "openai-codex-sdk",
      "text": "@openai/codex-sdk",
      "level": 3
    },
    {
      "id": "bun",
      "text": "Bun",
      "level": 3
    },
    {
      "id": "prompt-quest-comic-demo",
      "text": "Prompt Quest comic demo",
      "level": 3
    },
    {
      "id": "recommendations-and-best-practices",
      "text": "Recommendations and best practices",
      "level": 2
    },
    {
      "id": "practice-and-acceptance-criteria",
      "text": "Practice and acceptance criteria",
      "level": 2
    },
    {
      "id": "checklist",
      "text": "Checklist",
      "level": 3
    },
    {
      "id": "warm-html-dashboard-daemon",
      "text": "Warm HTML Dashboard Daemon",
      "level": 3
    },
    {
      "id": "low-reasoning-cli-specialist",
      "text": "Low-Reasoning CLI Specialist",
      "level": 3
    },
    {
      "id": "self-improving-narrow-tool-daemon",
      "text": "Self-Improving Narrow Tool Daemon",
      "level": 3
    },
    {
      "id": "sdk-agent-graph-with-analysis",
      "text": "SDK Agent Graph With Analysis",
      "level": 3
    },
    {
      "id": "multimodal-continuity-check",
      "text": "Multimodal Continuity Check",
      "level": 3
    },
    {
      "id": "questions-to-test-understanding",
      "text": "Questions to test understanding",
      "level": 2
    },
    {
      "id": "when-is-a-background-daemon-the-right-tool-in-this-lesson-s-workflow",
      "text": "When is a background daemon the right tool in this lesson's workflow?",
      "level": 3
    },
    {
      "id": "what-did-john-say-low-reasoning-needs-in-order-to-be-useful",
      "text": "What did John say low reasoning needs in order to be useful?",
      "level": 3
    },
    {
      "id": "when-did-john-say-you-should-reach-for-the-sdk",
      "text": "When did John say you should reach for the SDK?",
      "level": 3
    },
    {
      "id": "where-did-john-say-self-improving-daemon-patterns-fit-best",
      "text": "Where did John say self-improving daemon patterns fit best?",
      "level": 3
    },
    {
      "id": "what-should-happen-after-several-parallel-agents-produce-research-or-plans",
      "text": "What should happen after several parallel agents produce research or plans?",
      "level": 3
    },
    {
      "id": "what-is-the-point-of-the-multimodal-verification-loop-john-describes",
      "text": "What is the point of the multimodal verification loop John describes?",
      "level": 3
    },
    {
      "id": "reflection-prompts",
      "text": "Reflection prompts",
      "level": 2
    },
    {
      "id": "further-applications",
      "text": "Further applications",
      "level": 2
    },
    {
      "id": "applied-exercises",
      "text": "Applied exercises",
      "level": 2
    },
    {
      "id": "exercise-1-build-a-self-aware-shebang-script",
      "text": "Exercise 1: Build a Self-Aware Shebang Script",
      "level": 3
    },
    {
      "id": "exercise-2-mathematical-layout-verification",
      "text": "Exercise 2: Mathematical Layout Verification",
      "level": 3
    },
    {
      "id": "questions-and-answers",
      "text": "Questions and answers",
      "level": 2
    },
    {
      "id": "i-have-heard-a-few-people-say-that-low-reasoning-is-under-utilized-and-i-never-understood-that-till-now",
      "text": "I have heard a few people say that low reasoning is under utilized and I never understood that till now.",
      "level": 3
    },
    {
      "id": "do-you-ever-get-rate-limited-or-failures-when-running-things-in-parallel-with-that-tool",
      "text": "Do you ever get rate limited? Or failures? When running things in parallel with that tool?",
      "level": 3
    },
    {
      "id": "are-these-human-dashboards-ephemeral-or-persisted",
      "text": "Are these human dashboards ephemeral or persisted?",
      "level": 3
    },
    {
      "id": "do-you-have-any-good-resources-where-you-look-for-skills-plugins-clis-before-creating-your-own",
      "text": "Do you have any good resources where you look for skills, plugins, clis, before creating your own?",
      "level": 3
    },
    {
      "id": "on-self-improvement-thoughts-on-karpathy-auto-research-as-a-general-pattern",
      "text": "On self-improvement, thoughts on karpathy auto-research as a general pattern?",
      "level": 3
    },
    {
      "id": "isn-t-goal-kind-of-an-implementation-of-autoresearch",
      "text": "Isn’t /goal kind of an implementation of autoresearch?",
      "level": 3
    },
    {
      "id": "do-you-subscribe-to-the-thought-that-modules-should-be-under-500-lines-function-should-be-under-50-lines-classes-should-be-under-200-lines-or-anything-like-that",
      "text": "Do you subscribe to the thought that modules should be under 500 lines, function should be under 50 lines, classes should be under 200 lines or anything like that?",
      "level": 3
    },
    {
      "id": "operational-playbooks",
      "text": "Operational playbooks",
      "level": 2
    },
    {
      "id": "recording-references",
      "text": "Recording references",
      "level": 2
    },
    {
      "id": "visual-reference-index",
      "text": "Visual reference index",
      "level": 3
    }
  ],
  "markdown": "# Build narrow daemons and inspectable agent graphs\n\n> Original source pages and recordings require authorized access. The full article text here is public.\n\nThe focus is focused Codex daemons: small background helpers that can update a human-facing dashboard, keep their own threads and settings warm through the SDK, and work best when their scope and context stay small. John then extends the pattern to self-improving agents for narrow CLIs/APIs, SDK-built agent graphs with analysis steps, and verification loops for UI layout and generated images.\n\n## Working outcomes\n\n- Run focused background daemons that update a human-readable HTML dashboard\n- Use low-reasoning iteration with a deliberately small-context strategy\n- Coordinate SDK multi-agent graphs with a multimodal verification loop\n\n## Concepts and consequences\n\n### Background daemons\n\nThe “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.\n\n**Why it matters:** A daemon is useful when a narrow support task should keep running without interrupting the main session.\n\n### Low-reasoning iteration\n\nJohn 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.\n\n**Why it matters:** Small, focused low-reasoning runs can be useful for high-frequency automation when the prompt and tool scope are explicit.\n\n### Small context and specialized tool context\n\nJohn 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.\n\n**Why it matters:** Narrow context lowers usage and keeps the model focused on the job it was built to do.\n\n### Self-improving daemons\n\nJohn 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.\n\n**Why it matters:** For narrow tools, repeated failures can become better operating instructions for future runs.\n\n### SDK agent graphs\n\nJohn 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.\n\n**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.\n\n### Multimodal verification loops\n\nJohn 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.\n\n**Why it matters:** Generated artifacts should be inspected against concrete constraints instead of trusted after one prompt.\n\n### Agent-readable code structure\n\nWhen 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.\n\n**Why it matters:** Agents can read, verify, and reason about code more reliably when the control flow exposes human-readable state names.\n\n## Reference tools and resources\n\n### johnlindquist/codex-daemons\n\nThe repo John shows for background daemon setup and single-purpose Codex daemon scripts.\n\n**Use when:** Use it when you want to inspect or adapt the daemon pattern John discusses: clone the repo, install with Bun, and expose the executables on your path.\n\n[Reference](https://github.com/johnlindquist/codex-daemons)\n\n### @openai/codex-sdk\n\nThe SDK John says to reach for when building custom agents with managed threads, managed settings, warm daemon behavior, or structured agent graphs.\n\n**Use when:** Use it when a workflow needs explicit sequencing, branching, parallel roles, or handoffs between agents.\n\n[Reference](https://www.npmjs.com/package/@openai/codex-sdk)\n\n### Bun\n\nThe runtime John identifies as a prerequisite for the daemon shebang files and setup flow.\n\n**Use when:** Use it to install and run the daemon scripts shown in the repo setup instructions.\n\n[Reference](https://bun.sh)\n\n### Prompt Quest comic demo\n\nJohn’s comic example used to explain image continuity and multimodal verification loops.\n\n**Use when:** Use it as inspiration for workflows that generate an artifact, inspect it, compare it to references, and continue only when the checks pass.\n\n[Reference](https://www.dev.build/comics/prompt-quest/0?page=5)\n\n## Recommendations and best practices\n\n- Build daemons around narrow jobs, not vague all-purpose assistants. A dashboard updater, CLI specialist, or platform-specific helper is easier to prompt and trust than one giant agent.\n- Use low reasoning only with explicit prompting and narrow scope. Expect iteration while you dial in the prompt, because the model will not reliably infer the full workflow on its own.\n- Keep daemon context small. John’s target in this section is under about 10,000 tokens, with only the context and tools the daemon actually needs.\n- Reach for the SDK when you need managed threads, managed settings, warm background behavior, or a workflow where agents hand work to other agents.\n- Apply self-improvement first to narrow CLIs, tools, or APIs with clear failure modes. Large projects can branch too many ways for simple self-improvement to stay clean.\n- Do not spawn many agents unless you also design the analysis or synthesis step. Parallel work without review leaves the human with a pile of artifacts.\n- Use verification loops for generated artifacts. For UI, ask for concrete layout numbers; for images, feed the generated result back in and compare counts, continuity, and constraints.\n- For code that agents will read, prefer state machines, named cases, and English-readable conditions over arbitrary line-count rules.\n\n## Practice and acceptance criteria\n\nPractice designing focused Codex daemons and SDK agent workflows that stay narrow, warm, observable, and verified.\n\n### Checklist\n\n1. Pick one narrow daemon job you actually need, such as updating an HTML dashboard, summarizing turns, wrapping a specific CLI, or tracking tool calls.\n2. Write the daemon prompt so the job, tool scope, expected behavior, and likely failure modes are explicit.\n3. Use SDK-style managed threads and settings only when the workflow needs warm background behavior, agent handoffs, branching, or role-specific agents.\n4. Keep the daemon's context small, aiming under about 10,000 tokens and avoiding unrelated tool or plugin context.\n5. For a human-facing daemon, record the latest summary, conversation state, and tool calls in an HTML dashboard.\n6. For a self-improving daemon, start with a narrow CLI, tool, or API where failures are specific enough to improve prompts or tool-call guidance.\n7. For multi-agent workflows, include an analysis or synthesis step after parallel workers before implementation continues.\n8. For generated images or UI, add a verification pass that checks concrete details such as counts, continuity, padding, margins, or spacing.\n9. For code that agents will inspect, prefer named states, switch cases, and English-readable conditions over deeply nested conditionals.\n\n### Warm HTML Dashboard Daemon\n\n**Difficulty:** Easy\n\nBuild a tiny background daemon that watches a local session log and updates an HTML dashboard with the latest summary, conversation state, and tool calls.\n\n**Done when:** After three separate interactions, the HTML dashboard updates without you manually editing it and without interrupting your main Codex session.\n\n### Low-Reasoning CLI Specialist\n\n**Difficulty:** Medium\n\nCreate a focused wrapper for one CLI or tool you use often, such as Wrangler, Neon, the Vercel CLI, or another specific API-backed tool. Give it a narrow job, explicit instructions, and guidance for the common failure modes you expect.\n\n**Done when:** It completes five small scripted tasks and handles one intentionally bad input by explaining what failed instead of wandering into unrelated work.\n\n### Self-Improving Narrow Tool Daemon\n\n**Difficulty:** Medium\n\nPrototype a daemon for a narrow CLI or API that reads the latest transcript or log at the end of a turn and proposes one improvement to its own prompt or source instructions.\n\n**Done when:** After two repeated failures, it identifies the repeated pattern and produces a concise prompt/source improvement that you can inspect.\n\n### SDK Agent Graph With Analysis\n\n**Difficulty:** Hard\n\nDesign a small SDK-style workflow where one agent starts the task, several focused workers run in parallel, and an analysis agent compares their outputs before anything is implemented.\n\n**Done when:** The final result clearly shows which worker outputs were accepted, which were rejected or merged, and what the analysis step chose to pass forward.\n\n### Multimodal Continuity Check\n\n**Difficulty:** Hard\n\nCreate a small generation-and-verification loop for an image or UI artifact. Generate the artifact, inspect it, return concrete counts or layout values, and compare those values against the required constraints.\n\n**Done when:** The workflow catches at least one mismatch, such as a missing visual element, wrong count, or inconsistent spacing, before accepting the final artifact.\n\n## Questions to test understanding\n\n### When is a background daemon the right tool in this lesson's workflow?\n\n- **A.** When a narrow support task should run behind the main session\n- **B.** When one giant agent should own every tool and decision\n- **C.** When you want to maximize context for every prompt\n- **D.** When you want to avoid defining the daemon's job\n\n**Answer: A.** John’s “human” daemon runs in the background, updates an HTML dashboard at hooks, tracks tool calls, and summarizes the session without taking over the main work.\n\n### What did John say low reasoning needs in order to be useful?\n\n- **A.** A vague goal and freedom to infer the whole workflow\n- **B.** Every plugin and every possible context file\n- **C.** More explicit prompting, narrow scope, and iteration through failures\n- **D.** Only tasks that require deep strategic judgment\n\n**Answer: C.** John says low reasoning is underutilized, but it needs a lot of prompt detail and you should expect failures while you dial it in.\n\n### When did John say you should reach for the SDK?\n\n- **A.** For every normal one-off Codex question\n- **B.** When building custom agents with managed threads, settings, warm behavior, or agent graphs\n- **C.** Only when you want to avoid writing workflow logic\n- **D.** Only for image generation\n\n**Answer: B.** John frames the SDK as the tool for custom agents, managed threads/settings, warm background daemons, and structured workflows with handoffs or branches.\n\n### Where did John say self-improving daemon patterns fit best?\n\n- **A.** Specific CLIs, tools, or APIs with clear tasks and predictable failure modes\n- **B.** Large projects with many possible directions\n- **C.** Unscoped brainstorming chats\n- **D.** Any workflow where the agent should ignore its previous failures\n\n**Answer: A.** John says self-improvement is difficult in large projects but more plausible when the agent works against a narrow tool whose failures can be accounted for in prompts and tool calls.\n\n### What should happen after several parallel agents produce research or plans?\n\n- **A.** The human should manually sift through every artifact without help\n- **B.** An analysis or synthesis step should compare the outputs and choose or combine the best ones\n- **C.** Every worker should implement its own separate result\n- **D.** The workflow should always stop before implementation\n\n**Answer: B.** John describes workflows where parallel research agents feed into an analysis step that checks the plans and decides what should move forward.\n\n### What is the point of the multimodal verification loop John describes?\n\n- **A.** To trust the first generated image without checking it\n- **B.** To make image generation unrelated to previous frames\n- **C.** To feed the generated image back in, count or compare details, and verify continuity\n- **D.** To replace all UI checks with arbitrary line-count rules\n\n**Answer: C.** John explains that Codex can generate an image and then inspect that image against previous frames or reference images, checking concrete details such as counts and continuity.\n\n## Reflection prompts\n\n- Where in your current workflow are you using a large general agent when a small daemon with a narrow job would be cheaper and easier to trust?\n- Which tools, plugins, or context could be removed from one agent profile so it stays focused on its actual job?\n- Where would an analysis or synthesis step reduce artifact-sifting in a workflow that uses multiple agents?\n- What generated artifact in your workflow should be verified with concrete counts, layout values, or continuity checks before you trust it?\n- Where would named states or English-readable switch cases make your code easier for an agent to inspect than nested conditionals or arbitrary line-count rules?\n\n## Further applications\n\n1. Inspect one daemon file in the codex-daemons repo and identify what makes it narrow: its trigger, its context, its settings, and its output.\n2. Build a tiny daemon that updates an HTML dashboard from a local session log with the latest summary and tool-call state.\n3. Sketch one SDK workflow with a first agent, several parallel worker agents, an analysis step, and a final implementation step.\n4. Try a small multimodal verification loop: generate an image, ask a vision-capable pass to count or compare required elements, then regenerate only if the check fails.\n5. Refactor a small conditional-heavy module into named states or switch cases so an agent can read the control flow in clearer English.\n\n## Applied exercises\n\n### Exercise 1: Build a Self-Aware Shebang Script\n\n**Objective:**  Create a local executable file using BUN that reads its own file block on failure and alters its own instruction prompt.\n\n**Requirements:** Write a basic shell-executable script utilizing a #!/usr/bin/env bun shebang line.Integrate a small hook that passes the current execution log file straight to a low-reasoning LLM completion endpoint.Instruct the script to rewrite its internal system prompt string if a failure signature is detected.\n\n### Exercise 2: Mathematical Layout Verification\n\n**Objective:**  Build a QA assertion script that verifies a component UI layout against strict structural bounds rather than visual guesswork.\n\n**Requirements:** Design a mock UI rendering block outputting Tailwind CSS utility classes.Write an agent extraction prompt requiring Codex to parse the raw markup and isolate all padding, margin, and alignment variables into a structured JSON payload.Create an assertion step evaluating if the extracted values strictly conform to a standardized geometric spacing layout scale.\n\n## Questions and answers\n\n### I have heard a few people say that low reasoning is under utilized and I never understood that till now.\n\nLow reasoning requires a different approach. You have to expect it to fail a bunch initially before you get it exactly where you want it. It isn’t going to independently think through complex problems, so you must write precise prompts and account for explicit tool failures ahead of time. However, it uses very small footprints compared to huge model passes, keeping interactions well under 10,000 tokens of context. \n\n### Do you ever get rate limited? Or failures? When running things in parallel with that tool?\n\nNo, I haven't been rate-limited with this approach at all. The context usage is exceptionally small compared to normal prompt loops run inside major general-purpose sessions—it's barely a drop in the bucket. \n\nThis is an observation about John’s small-context setup, not a guarantee that parallel work cannot hit rate limits.\n\n### Are these human dashboards ephemeral or persisted?\n\nRight now they write to a local temp directory, making them ephemeral. However, you can cleanly persist them. The instructions are included inside the repository: you just clone the repo, run bun install, and execute unlink to place the executables directly onto your global path system. \n\nCommand caveat: the Q&A wording says `unlink`, but the concrete daemon setup instructions use `bun link` to add executables to PATH. Follow the command reference rather than interpreting `unlink` as installation.\n\n### Do you have any good resources where you look for skills, plugins, clis, before creating your own?\n\nJohn highlights two primary on-screen resources for the AI workspace context: skills.sh and the Codex Awesome Plugins ecosystem repository. \n\n### On self-improvement, thoughts on karpathy auto-research as a general pattern?\n\nI haven't implemented it directly yet, but it is firmly on my list. We can definitely construct tailored background daemons around this pattern to execute autonomous research loops for active projects. It fits neatly into the concept of agents reading their own source to iterate past failures. \n\n### Isn’t /goal kind of an implementation of autoresearch?\n\nThey are closely aligned. The beauty of the /goal implementation in GPT-5.5 is its clean interface—putting it behind a keyword slash command works incredibly well. I am working on adding a tracking plugin to my /goal usage that saves metrics on tool calls, execution effort, and compaction events so that subsequent agent passes can look back at historic execution paths. \n\n### Do you subscribe to the thought that modules should be under 500 lines, function should be under 50 lines, classes should be under 200 lines or anything like that?\n\nNo, I don't follow or subscribe to arbitrary line count rules. The single most important code style structure for agent workflows is to avoid deep conditional chains and use explicit state machines or named switch statements instead. When you choose clear English naming keys inside your code structures over complex syntax trees, the reading agents can interpret the underlying execution paths far more effectively. \n\n## Operational playbooks\n\n- [Isolated Codex daemon profile](/topics/foundations-daemon-profile-playbook/)\n\n- [Codex Daemon Profile Field Guide](/topics/foundations-daemon-profiles-field-guide/)\n\n## Recording references\n\n- [Recording](https://codex-workshop-followup.pages.dev/video/lessons/lesson-09.mp4)\n\n[Timestamped source page](https://codex-workshop-followup.pages.dev/lesson-09.html)\n\n### Visual reference index\n\n- [03:58:04](https://codex-workshop-followup.pages.dev/lesson-09.html#clip-09-1): Terminal workspace around the background daemon discussion; dashboard output is not clearly visible in this still.\n- [04:00:44](https://codex-workshop-followup.pages.dev/lesson-09.html#clip-09-2): Screen view of John typing the pro browser automate OpenX.com... command parameters inside the shell prompt.\n- [04:01:40](https://codex-workshop-followup.pages.dev/lesson-09.html#clip-09-3): Display of the daemon project repository instructions containing setup steps for bun install and path unlinking.\n- [04:02:35](https://codex-workshop-followup.pages.dev/lesson-09.html#clip-09-4): Code layout showing a self-improving shebang daemon file reading its own source script context.\n- [04:04:54](https://codex-workshop-followup.pages.dev/lesson-09.html): Code/repository view during the community registry discussion; skills.sh/plugin-list claims should remain transcript evidence unless a closer browser still is selected.\n- [04:13:00](https://codex-workshop-followup.pages.dev/lesson-09.html): Dark editor/workspace view during SDK-vs-UI workflow discussion; graph-chain specifics are transcript evidence here.\n- [04:17:30](https://codex-workshop-followup.pages.dev/lesson-09.html): n8n-style workflow graph page visible during layout/automation discussion.\n- [04:19:12](https://codex-workshop-followup.pages.dev/lesson-09.html): Browser display of the comic layout via dev.build showing character image coherence validation passes."
}
