Context Course

0. Welcome to the Context Course

1. Skills: Portable Knowledge for Code Agents

2. MCP: The Model Context Protocol

3. Plugins: Bundling Tools for Distribution

4. Subagents: Orchestrating Multi-Agent Workflows

5. Hooks: Observing and Guarding the Agent Lifecycle

Unit 5: Hooks Hook Events and the Agent Lifecycle Quiz 1: Hook Fundamentals Hands-On: Agent Activity Dashboard with Gradio Quiz 2: Hooks in Practice

6. Bonus: Nano Harness — Build Your Own Agent

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Quiz 2: Hooks in Practice

Test your ability to wire hooks into real workflows.

Question 1: How should the dashboard server be structured?

The Gradio app and the FastAPI receiver must run as two separate processes on two separate ports Mounting Gradio on a FastAPI app with `gr.mount_gradio_app` lets one server serve both the `/event` endpoint and the Gradio UI You can only receive hook events from Claude Code — Codex, OpenCode, and Pi cannot post JSON Hook events should be written to a file rather than served over HTTP

Question 2: How does the Gradio dashboard refresh?

The dashboard polls with `gr.Timer(1.0)` because browsers can't receive server-pushed events from Python Polling with `gr.Timer` re-runs the refresh function every N seconds, which re-reads the shared `events` buffer and re-renders the table and chart The `gr.Timer` must be nested inside `gr.Row` or it won't fire The timer is mandatory — Gradio dashboards can't update any other way

Question 3: How do hook-based guardrails block dangerous actions?

To block a dangerous Bash command in Claude Code, the hook returns HTTP 500 A command hook that exits 2 and prints a reason on stderr is the documented way to block a tool call in Claude Code and Codex In OpenCode, you block a tool by editing the user's prompt Guardrails should live in the model's system prompt rather than in hooks

Question 4: What makes shell-command hooks safe?

Piping `curl --max-time 2` inside a Codex command hook is pointless; the agent never waits for hooks Shell command hooks can become a shell-injection risk if you interpolate JSON payloads into the command string — piping via `jq -c` and `curl --data-binary @-` is safer There's no need to worry about hook payloads containing secrets, since the agent's sandbox already redacts them You must commit `.claude/settings.local.json` to share hooks with teammates

Question 5: Why can one dashboard support multiple agents?

The same dashboard works for Claude Code, Codex, OpenCode, and Pi because the server normalizes four different payload shapes into one consistent record The dashboard only works for one platform at a time; you must redeploy it when switching agents OpenCode events are incompatible with the same receiver because OpenCode plugins can't make HTTP calls You have to run a separate dashboard per platform, then merge the logs afterwards

Summary

If you got 4-5 correct, you can wire hooks into a real observability and guardrail flow. If not, review the hands-on example, especially the payload normalization and blocking patterns.

Key Takeaways

One FastAPI + Gradio process is enough for a lightweight live dashboard
Hook handlers should fail fast, sanitize payloads, and avoid shell-injection patterns
A shared receiver works across Claude Code, Codex, OpenCode, and Pi once you normalize the event shape

What’s Next

You’ve finished Unit 5: Hooks. You now have five end-to-end surfaces for shaping how a code agent works: skills, MCP servers, plugins, subagents, and hooks. The bonus unit goes one level deeper and builds an agent from scratch, so you understand what every one of those surfaces is plugging into.

Update on GitHub

←Hands-On: Agent Activity Dashboard with Gradio Introduction to Nano Harness→

Quiz 2: Hooks in Practice Question 1: How should the dashboard server be structured?Question 2: How does the Gradio dashboard refresh?Question 3: How do hook-based guardrails block dangerous actions?Question 4: What makes shell-command hooks safe?Question 5: Why can one dashboard support multiple agents?Summary Key Takeaways What’s Next