Agents and Workflows — study note

This is Domain 1 of the Claude Certified Developer – Foundations exam: approximately 14.7% of scored items, according to the guide. The domain has three skills: agent architecture, agent construction with Claude, and agent patterns and frameworks. This note summarizes what each topic teaches and the Anthropic pages behind it.

Architecture: who decides the next step

Anthropic calls both kinds of system “agentic”, and separates them by who holds control.

• Start simple. Find the simplest solution, and add complexity only when it demonstrably improves outcomes. Often, a single model call with retrieval and in-context examples is enough.
• Autonomy has a cost. Agents mean higher costs and the potential for compounding errors. Add stopping conditions, such as a maximum number of iterations, and test extensively in sandboxed environments.
• Keep the agent grounded. It should judge progress from ground truth in the environment at each step, such as tool results or code execution. It can pause for human feedback at checkpoints or when it hits a blocker.
• Subagents keep context clean. A subagent does a side task in its own context window, with its own tools and permissions, and returns only a summary.
  • Claude delegates from the subagent’s description, so write a clear one. A phrase such as “use proactively” encourages delegation.
  • If the tools field is omitted, a subagent inherits every available tool.
  • An optional memory field gives a subagent a persistent directory that survives across conversations.
  • Subagents work within a single session. For many independent parallel sessions, the subagents page points to background agents.

Construction: surfaces, the loop, hosting, hooks

The Agent SDK in practice.

• It loads skills, commands and memory from .claude/, the same as Claude Code.
• It authenticates with API keys. Third parties may not offer claude.ai login without Anthropic’s approval.
• From another language, run the CLI as a subprocess with -p and JSON output.

The loop. Call the API. While stop_reason is "tool_use", run every requested tool and send all the results back in one user message, each tool_result carrying the matching tool_use_id. Return a failing tool’s error with is_error: true instead of crashing. Claude can then retry with corrected input, ask for clarification, or explain the limitation.

Limits.

• In the Agent SDK, each full cycle is one turn.
• Cap turns, and set a budget: the agent-loop page calls a budget a good default for production agents. A capped run ends with an error_max_turns or error_max_budget_usd result subtype.
• Read-only tools can run concurrently. Custom tools default to sequential until you set readOnlyHint.

Hosting an SDK agent. It is a long-lived process tied to local state, and one session maps to one subprocess. On-disk state does not survive a restart, scale-down or move to another node. Persist transcripts with a SessionStore adapter; give memory files and working-directory artifacts their own storage.

Managed Agents (beta) is stateful by design: history, sandbox state and outputs are kept server-side. You keep control of that data: you can delete sessions, and separately delete any files you uploaded, at any time through the API. Because it is stateful, the overview currently notes it is not eligible for Zero Data Retention or HIPAA BAA coverage; check current eligibility before using it for regulated data.

Hooks.

• Hooks are callbacks that run your code on agent events.
• A matcher limits which tools a hook runs for. A hook without a matcher runs for every event of its type.
• A PreToolUse callback can return allow, deny, ask or defer; ask shows the call to the user for approval. It can also modify the input or add context.
• Async hook outputs let the agent continue without waiting, but they can’t block, modify or inject context, so use them only for side effects such as logging.
• When hooks disagree, the most restrictive result applies, so a single deny blocks the call.

Patterns and frameworks

• The tool-use contract. Claude emits a structured request. Your code, or Anthropic’s servers for server tools, runs it, and the result flows back. Claude sees only the schema and the result. If you are parsing a decision out of prose with a regex, make it a tool call.
• Memory. The memory tool is client-side. Claude reads and writes files under /memories, and your application maps that prefix onto storage it controls. Restrict every operation to /memories.

Routing can also cut cost, by sending easy questions to smaller models. Parallel sectioning suits guardrails: one call screens a query while another answers it.

Frameworks. Anthropic’s article notes that much of the tooling landscape described in the post has changed since December 2024; its advice is about how to work, not which tool to pick.

• Frameworks make it easy to start by simplifying model calls, tool parsing and chaining.
• They can also hide the underlying prompts and responses, and make it tempting to add complexity.
• Start with the API directly, and if you adopt a framework, understand the code underneath.

Sources

• Building effective agents — https://www.anthropic.com/engineering/building-effective-agents
• Create custom subagents — https://code.claude.com/docs/en/sub-agents
• Agent SDK overview — https://code.claude.com/docs/en/agent-sdk/overview
• Claude Managed Agents overview — https://platform.claude.com/docs/en/managed-agents/overview
• Build a tool-using agent — https://platform.claude.com/docs/en/agents-and-tools/tool-use/build-a-tool-using-agent
• How the agent loop works — https://code.claude.com/docs/en/agent-sdk/agent-loop
• Hosting the Agent SDK — https://code.claude.com/docs/en/agent-sdk/hosting
• Intercept and control agent behavior with hooks — https://code.claude.com/docs/en/agent-sdk/hooks
• How tool use works — https://platform.claude.com/docs/en/agents-and-tools/tool-use/how-tool-use-works
• Memory tool — https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool