Anthropic's Building Effective Agents walks the patterns that ship in production and closes with three principles. Maintain simplicity in the design. Show the agent's planning steps. Carefully craft the agent-computer interface through tool documentation and testing.
The third is the one most worth pulling on. Better tool descriptions and better tests are sound advice, and Anthropic gives both. The question we keep asking is whether there is a structural move underneath. What if the descriptions the model reads were the descriptions everyone reads? What if there were no separate tool surface to invest in? But first let's see how some of the patterns identified in the article map in Dafthunk.
Workflow or Agent
Anthropic groups these systems under the term agentic systems and draws a line through the middle. A workflow follows fixed steps you set in advance. An agent picks its own next step at runtime.
Two nodes do the work in Dafthunk. A regular node calls a model once and returns the answer. An agentic node runs the model in a loop, picks a tool, reads the result, and chooses what to do next. You decide where the workflow ends and the agent begins.
Use a workflow when the steps are known. Use an agent when they are not. A support reply that runs the same four tools in the same order every time is a workflow. A research task that may need three lookups, one fetch, and one summary, in an order the model picks at runtime, is an agent.
You do not have to choose at the start. A chain becomes a router when you add a fork. A router becomes an agent when one of its nodes turns agentic. An agent goes fully autonomous when you remove the surrounding graph. Let's walk through a few of the patterns Anthropic identifies and see how they map to Dafthunk's building blocks.
The Augmented LLM
The base unit. A model with tools, retrieval, and memory. The node accepts optional inputs on top of the system prompt and the user message, including a tool list and a schema for the output.
The AI Calculator template is a simple starting point. One model, one tool. The tool is a calculator node that does not know it is being used as a tool. The same node can drop into a chain that has nothing to do with AI.
Prompt Chaining
The simplest workflow pattern. Break a task into a fixed sequence of model calls with code between them.
The Outline and Write template illustrates this pattern. The first model writes a short outline. The second writes the article from it.
Routing
Routing reads an input, classifies it, and sends it to a specialist branch. The classifier is often a small model, sometimes a rule or a regex.
The canvas has two kinds of fork-and-join.
- A conditional fork splits a path in two on a boolean.
- A switch fork splits a path into N branches on a string selector, with a
defaultfor anything that does not match. - A matching join merges the branches back, taking whichever side ran.
The thing that bites is the classifier. A small model will route a vague input confidently to the wrong branch. The fix is to use a schema to emit a structured object with a category and a confidence, and route only when the confidence clears a threshold. The schema usually lives on the classifier node.
Parallelization
Two flavors. Sectioning runs independent subtasks at the same time. Voting runs the same task many times for confidence.
Sectioning is automatic. The runtime sees branches that do not depend on each other and runs them together. You do not mark anything as parallel. You draw the shape, and the shape is the parallelism.
The Parallel Article Card template fans one article out to three nodes: a summarizer, a keyword extractor, and a title generator. They start at once.
Agents
The far end of the range. An agent plans, acts, observes, and repeats for as long as the task takes. Anthropic's guidance is sound. Invest in the tools. Set a step budget. Run in a sandbox.
The agentic node does all three. The toolset is a typed list from the catalog. The step budget is a number on the node. The loop stops when it runs out and reports why. The sandbox is the workflow's organization. An agent reaches only the secrets, integrations, datasets, and databases that the organization owns.
The Wiki Research Agent template is three nodes: the question, the agent, the answer. Three tools live inside the agent: a Wikipedia search, a current-time tool, a date-difference tool.
Two Registries
The patterns are building blocks, not boxes. Place an agent inside a routing branch. Wrap a chain in a fork-join. None of this is novel. What feels novel is how cheap it becomes once the node and tool registries draw from the same catalog.
In Dafthunk the tools are just a subset of the nodes: the ones that can be called from an agentic node. Since nodes have several inputs, settings let the user define presets. The agent fills in the blanks at runtime using the descriptions and schemas on the node.
To see the patterns in action, browse the nodes reference. The core concepts page describes how triggers, executions, and resources fit together. Dafthunk is open source on GitHub. Issues and pull requests welcome.