Building Agents and Workflows

A team is building an agent that manages a customer's calendar. The agent can create, move, and delete events by calling tools. During testing, the agent frequently double-books slots because it decides which action to take next without ever incorporating the results of its previous tool calls. What is the most important design change to make this agent work reliably?

A product team wants to build a feature that investigates customer complaints. Each complaint requires an unpredictable number of steps: reading the ticket, searching internal knowledge bases, querying order histories, and sometimes escalating to check shipping partner APIs — but the exact sequence and which tools are needed vary widely from case to case and cannot be known in advance. The team asks whether to implement this as a fixed workflow or as an agent. Which approach best fits this task, and why?

You are building an agent that manages calendar events. Early testing shows the agent frequently picks the wrong action because you exposed 14 narrowly-scoped tools (e.g., create_morning_event, create_afternoon_event, create_recurring_event, create_all_day_event, and similar variants). The model often confuses which tool applies. Following best practices for giving agents tools, what is the most effective change to improve reliability?

Your team is deploying an autonomous agent that manages cloud infrastructure by calling tools to provision, modify, and delete resources. During internal testing the agent occasionally deletes production databases when a user's request is ambiguous. The team wants the agent to remain capable of independent multi-step action but reduce the risk of catastrophic, irreversible operations. Which change best addresses this while preserving the agent's autonomy?

A logistics company is building a system to reroute shipments during weather disruptions. Each disruption is different: the number of affected shipments, the alternate carriers available, and the sequence of checks needed vary widely and cannot be predicted in advance. The engineering team wants the system to figure out its own sequence of steps at runtime, calling tools to check carrier availability, inventory, and costs as needed until it produces a viable rerouting plan. Which implementation approach best fits these requirements?

You are building an agent that books meeting rooms by calling a scheduling tool. Currently, when a requested room is unavailable, the tool returns only 'false'. The agent frequently loops, re-requesting the same unavailable room, wasting tokens and time. Without changing the underlying booking logic, what is the most effective way to improve the agent's reliability?

A team is building a coding assistant agent. They give it a file-search tool, a code-linter tool, and a git-commit tool. The lead asks the team to categorize each tool by whether it primarily lets the agent take actions that change the external environment or primarily gives the agent information to reason with. Which categorization is correct?

Your team is building an internal assistant to handle IT support requests. Some requests are simple and always follow the same steps (e.g., 'reset my password' → verify identity → trigger reset → confirm). Others are open-ended troubleshooting problems where the resolution path is unknown up front and may require querying logs, checking system status, and deciding which tool to call next based on what earlier calls return. Which design best fits these two categories of requests?

A team is building an automated system to resolve customer refund requests. Some requests are simple (one lookup, apply refund), while others require an unpredictable number of steps: checking order history, verifying return shipments, escalating to fraud checks, or requesting more information from the customer. The team cannot predetermine how many steps or which order they will occur for any given request. Which implementation approach best fits this situation?

A support team deploys an agent that can call several tools (knowledge base search, ticket lookup, refund API) to resolve customer issues autonomously. During testing, a few conversations spiral: the agent repeatedly calls tools, racks up high token costs, and occasionally never returns a final answer. The team wants to keep the agent capable but reliable and bounded. Which change most directly addresses this problem?

A developer tools team is building a feature that generates SQL queries from natural-language requests. They have a validator that can run each generated query against a test schema and return specific errors (syntax problems, missing columns, wrong joins). The team wants the system to iteratively improve its output until the query passes validation, since a single generation attempt often contains fixable mistakes. Which agent pattern best fits this need?

A localization team is building a system that translates marketing copy. Their success criterion is that translations must preserve brand tone and idiomatic naturalness, which a single pass often gets subtly wrong. They want one model call to produce a translation, then a second call to critique it against tone/naturalness rubrics and suggest fixes, looping until the critique passes or a max of three rounds. Which agent/workflow pattern best matches this design?

A team is building a system that researches and writes competitive analysis reports. Each report requires investigating a variable number of competitors that are not known in advance — some requests involve two competitors, others involve a dozen. For each competitor, the system must gather data from multiple sources, then combine everything into a single synthesized report. The team wants a design where a central component decides how many subtasks to spawn at runtime based on the incoming request, delegates each investigation, and merges the results. Which agent/workflow pattern best fits this need?

A team is building a feature that generates a compliance report. Every report always requires exactly the same three sections: a financial summary, a legal risk analysis, and an operational overview. Each section is independent and can be produced from the same source document at the same time. The developers want the fastest possible turnaround. Which agentic pattern best fits this task?

A trust-and-safety team needs to review each user-submitted post against five independent policy checks: hate speech, spam, self-harm, personal data exposure, and copyright violation. Each check is a separate, non-dependent evaluation, and the team wants to minimize total latency per post. Which workflow pattern best fits this requirement?

Your team is building a system that flags whether user-submitted code contains a security vulnerability before it is auto-merged. A single model pass sometimes misses subtle issues, and false negatives are costly. You want to improve reliability without building a fully model-directed agent. Which parallelization approach best fits this need?

A fraud-review team wants a Claude-based system to flag suspicious wire transfers. Because false negatives are costly, they want to run the SAME analysis prompt against each transfer three separate times and only escalate a transfer for human review if at least two of the three runs flag it. Which parallelization approach does this design describe?

A marketing team needs to process incoming press releases through a fixed, well-understood pipeline: first extract key facts, then draft a social media post from those facts, then translate the post into three target languages. Each step's output feeds directly into the next, the sequence never changes, and the team wants the most predictable and debuggable implementation. Which approach best fits this task?

A customer support team processes thousands of incoming queries daily. Most are simple FAQ-style questions (password resets, hours of operation), while a small fraction are complex technical issues requiring detailed reasoning. The team wants to minimize cost and latency without sacrificing quality on hard cases. Which pattern best fits this situation?

A customer support team receives a wide mix of incoming messages: simple password resets, billing disputes, and complex technical troubleshooting. Each category needs a very different prompt, tone, and level of reasoning. The team wants each message handled by the most appropriate specialized prompt without paying for heavy reasoning on trivial requests. Which workflow pattern best fits this need?