The team is debating whether to integrate with the Claude API directly or through a third-party abstraction layer that supports multiple LLM providers. The team has identified that all current and projected use cases run on Claude, no internal customer has requested LLM portability, and the team's product roadmap does not mention multi-provider support over the next two years. The third-party abstraction would add roughly 15 percent overhead in code complexity and introduce one additional dependency.
Which integration approach would you recommend?

• A. The third-party abstraction layer, on the grounds that multi-provider support is valuable for any application as a matter of long-term flexibility across vendors.
• B. Both integration paths in parallel, where the application uses each path on different runs to compare which performs better in production over time.
• C. Direct integration with Claude through its SDK, because no multi-provider need exists and abstraction would add complexity that does not pay off.
• D. A custom multi-provider abstraction layer the team builds in-house so that the team controls every part of the abstraction the application uses for its API calls.

You are designing an agent that processes vendor invoices. The work involves a small number of well- understood steps, but occasionally an invoice arrives in an unexpected format that requires the system to decide between rerouting, requesting clarification, or flagging for human review.
The most appropriate architecture for this system is...

• A. A single large prompt that processes every incoming invoice, both standard and unexpected, in one model call.
• B. A manager agent that delegates each step of standard invoice processing to a dedicated subagent, with a separate subagent handling each unexpected format.
• C. A fully autonomous agent that handles every invoice from start to finish across all formats.
• D. A workflow for the standard path with an agent invoked at the decision point for unexpected formats.

Your agent is processing tasks that take 30 to 60 minutes to complete. Each task has well-defined intermediate checkpoints, and the team wants the agent to be able to resume from the most recent checkpoint if a process is interrupted.
How would you implement this resumability?

• A. Increase the agent's timeout to several hours so that interruptions become rare enough to ignore in practice.
• B. Apply a checkpointing pattern that persists the agent's intermediate state and reloads that state when resuming an interrupted task.
• C. Restart the task from the beginning whenever a process is interrupted.
• D. Run two copies of the agent in parallel for every task and use whichever one finishes first as the source of truth.

Your team is preparing a new Claude application for production, and the product team has asked for a cost projection. The team needs to estimate the cost based on expected request volume, average input length, and average output length. How would you build the projection?

• A. Build a cost model that combines expected request volume and average input tokens, treating output tokens as a small enough share of cost to leave out of the projection.
• B. Build a cost model that combines expected request volume, average input tokens, average output tokens, the chosen model's pricing, and any caching benefits.
• C. Build a cost model that uses the average per-request cost from a similar Claude application the team built last year, scaling that figure by expected request volume.
• D. Build a cost model based on expected request volume and the chosen model's pricing, treating average input and output token counts as variables to be estimated post-launch.