The New Tool Belt: Artifacts, Tasks & Typed Outputs

What You’ll Learn

Module 5 has covered the big architectural shifts of the Fable 5 era — models, effort, workflows, memory, deferred tools, scheduled autonomy. This final session covers everything else: the collection of user-facing tools that quietly changed what a Claude Code session produces.

By the end, you’ll understand:

• Artifacts — publishing hosted web pages instead of terminal text
• The Task system — the evolution of TodoWrite into tracked, dependent tasks
• AskUserQuestion with previews, and how plan mode sequences its questions
• ReportFindings — code review output as typed data, not prose
• The LSP tool, ShareOnboardingGuide, and main-agent worktrees
• Named, continuable subagents and background-by-default execution

The Problem

In Session 2 you learned the original tool system: Read, Write, Edit, Bash, Grep. Every one of those tools helps the agent act on the world. But the agent’s output — the thing you consume — was always the same: text in a terminal.

That ceiling shows up everywhere:

• A code review produces a wall of prose you must parse by eye.
• A progress list (TodoWrite, Session 3) lives and dies inside one conversation.
• A comparison of design options arrives as paragraphs, not side-by-side choices.
• A report worth sharing with teammates has to be copy-pasted out of a terminal.

The Fable 5-era harness answers with a simple idea: give the agent output channels that are richer than text — hosted pages, typed findings, structured questions, tracked tasks — so the host UI, not your eyes, does the parsing.

How It Works

Artifacts: When a Web Page Beats Terminal Text

Claude Code can publish an HTML or Markdown file as a hosted web page on claude.ai. The page is default-private; the user can choose to share it. This is the channel for dashboards, reports, and visual explanations — anything where a rendered page beats monospace text.

Three properties define how artifacts behave:

1. Self-contained only. A strict Content Security Policy blocks all external requests — CDN scripts, external stylesheets, fonts, fetch calls. Everything must be inlined; assets embed as data: URIs.
2. Stable URLs. Redeploying the same file path updates the same URL. Artifacts published in other sessions can be updated by URL. Your team bookmarks one link; you keep improving what’s behind it.
3. Responsive and theme-aware. Pages must adapt to viewport size and render in both light and dark themes.

The Task System: TodoWrite Grows Up

Session 3’s TodoWrite was a planning scratchpad — useful, but ephemeral and flat. The Fable 5 era replaces it with a real task system:

TaskCreate ──► visible task list
TaskUpdate ──► states: pending / in_progress / completed
TaskList   ──► what's open, what's blocked
TaskGet    ──► inspect one task
TaskStop / TaskOutput ──► control & read background work

Two upgrades matter most:

• Dependencies. Tasks can depend on other tasks, so the list encodes ordering, not just intent.
• Background work is tracked as tasks. Agents, workflows, and background Bash commands all appear in the task list, with notifications on completion. The task list is no longer the agent’s private plan — it is the session’s operational view.

AskUserQuestion: Options with Previews

Instead of asking open questions in prose, the agent can pose a structured question with 2–4 options, optionally multi-select. The standout feature is previews: each option can carry an ASCII mockup or code snippet, rendered side-by-side, so you compare concrete alternatives rather than descriptions of them.

This is Session 22’s human-in-the-loop principle, given a native UI: the decision comes to you as a choice, not a paragraph.

Plan Mode, Sequenced

Plan mode still uses EnterPlanMode / ExitPlanMode, but the flow is deliberate: clarifying questions happen before the plan is finalized, and the user sees the plan only at ExitPlanMode approval. You answer questions first, then judge one coherent plan.

ReportFindings: Review Output as Data

Code review findings are reported as a typed list, not prose. Each finding carries:

Field	Purpose
file, line	Where the defect anchors
summary	One-sentence statement of the defect
failure scenario	Concrete inputs/state → wrong output
verdict	CONFIRMED or PLAUSIBLE
category	The type of finding (correctness, efficiency, …)

Because findings are data, the host UI renders them natively. Review output stopped being something you read and became something the interface presents.

The LSP Tool

Language-server queries — definitions, references, diagnostics — are available in-harness. Where the old toolbelt navigated code with Grep and inference, the agent can now ask the language server directly.

ShareOnboardingGuide

The harness can generate an ONBOARDING.md for your project and upload it as a share link teammates can open directly in Claude Code. Onboarding knowledge stops being a wiki page nobody reads and becomes a live entry point into the tool itself.

Worktrees for the Main Agent

Session 12 covered worktree isolation for subagents. The Fable 5 era extends it to the main agent: EnterWorktree / ExitWorktree give the primary session an isolated copy of the repo. Subagents and workflow agents get the same via isolation: 'worktree'.

Subagents: Background by Default, Named and Continuable

The Agent tool itself changed shape (see Session 4 for the original model):

• Background by default. Launched agents run in the background; the parent is notified on completion. run_in_background: false forces a synchronous run.
• Named and continuable. An agent can be given a name, and the parent can continue it later — context intact — via SendMessage, mailbox-style, instead of starting fresh. Delegation stops being fire-and-forget.
• The final message returns to the caller only. The user never sees a subagent’s output directly; the parent must relay what matters.

Delegation guidance follows: send multi-file reading and searching to agents, keep conclusions (not file dumps) in the main context, and do single-fact lookups yourself when you already know the file.

Reaching Outward

Two one-liners complete the belt: PushNotification can notify the user’s devices, and RemoteTrigger can trigger and interact with remote sessions. The harness can reach beyond the terminal it runs in.

Hands-On Example

Let’s put the belt together conceptually: publish a code review as a shareable artifact.

Step 1: Review runs
        Subagents (background, tracked as tasks)
        examine the diff
              │
Step 2: Findings return typed
        ReportFindings: file, line, summary,
        failure scenario, verdict, category
              │
Step 3: Build the page
        One self-contained HTML file:
        inline CSS, findings table, verdict
        badges — no external requests (CSP)
              │
Step 4: Publish
        Artifact tool → hosted, default-private
        URL on claude.ai
              │
Step 5: Iterate
        Fix issues, redeploy the SAME file
        path → same URL updates in place

The walkthrough in practice:

1. Ask for the review. The agents launch in the background, appear as tracked tasks, and notify on completion.
2. Findings arrive as data. Each has a file, line, failure scenario, and a CONFIRMED/PLAUSIBLE verdict — so the report page can group confirmed correctness bugs above plausible efficiency notes without any text parsing.
3. The page must be self-contained. No CDN chart library, no external font. Styles are inlined; any image embeds as a data: URI. It must render in both light and dark themes.
4. Publish and share. Private by default; you review it, then share the link.
5. Redeploy after fixes. Next week’s re-review writes to the same file path — the team’s bookmarked URL shows the updated report.

One terminal session produced a durable, shareable deliverable — without leaving Claude Code.

What Changed

Pre-Fable 5 Era	Fable 5 Era
Reports as terminal prose	Hosted, shareable Artifacts
TodoWrite scratchpad, per-conversation	Task system with states, dependencies, notifications
Open-ended questions in text	AskUserQuestion: 2–4 options with previews
Review findings as paragraphs	ReportFindings: typed, UI-rendered data
Code navigation via Grep	LSP queries: definitions, references, diagnostics
Fire-and-forget subagents	Named, continuable agents via SendMessage
Worktrees for subagents only	EnterWorktree for the main agent too
Output ends at the terminal	PushNotification, RemoteTrigger, share links

Key Insight

The tool belt’s theme is that output became structured. The original tools let the model act on the world; the new tools let the harness present the work. A finding with a file, line, and verdict can be rendered and sorted. A task with a state and dependencies can be monitored. A question with previews can be answered with a click. An HTML file with a stable URL can be shared and updated.

Every tool in this session replaces “text the human must parse” with “data the interface can render” — and that, more than any single feature, is what makes Fable 5-era sessions feel less like a chat log and more like a working environment.

Module 5 Conclusion

You have completed Module 5: The Fable 5 Era — eight sessions on how Claude Code changed in the Claude 5 generation:

• Session 25: The Claude 5 Family & Model Strategy — Fable 5, the Mythos-class tier, and mixing model tiers per task.
• Session 26: Effort Levels & Ultracode — the quality/cost dial, and xhigh + orchestration as an opt-in.
• Session 27: The Workflow Tool — control flow in code, judgment in models.
• Session 28: Orchestration Quality Patterns — adversarial verify, judge panels, loop-until-dry.
• Session 29: Persistent Memory — one fact per file, MEMORY.md as index.
• Session 30: Deferred Tools & ToolSearch — tool schemas as pay-per-use context.
• Session 31: Scheduled Autonomy — loops, wakeups, cron, cache-aware pacing.
• Session 32 (this one) — the expanded tool belt.

Recall the five principles from Session 24. The Fable 5 era reinforces every one:

1. The agent loop is the foundation. Workflows don’t replace the loop — they script its delegation deterministically, while each subagent still runs the same loop inside.
2. Context is the most precious resource. Deferred tools, ToolSearch, summarization instead of hard compaction, memory indexes that load pointers instead of content — the whole era is context economics.
3. Permissions are the safety net. Permission modes are now settable per spawned subagent, and Bash runs sandboxed by default — the safety net got finer-grained as autonomy grew.
4. Markdown is the extension language. Skills, agents, memories, onboarding guides — still Markdown files with frontmatter. Drop a file, gain a capability (or a memory).
5. Production requires production discipline. Tasks with states and notifications, typed findings, resumable workflows, hard budget ceilings — the discipline is now built into the harness itself.

The course ends here, but the platform won’t. For ongoing coverage of new models and features as they land, follow the articles section — that’s where the news lives; these tutorials are where the architecture lives.

Build something.