Theme: The Craft
Length: ~700 words
Hook: Practical — give people a framework
The most important question in agentic AI isn't "how do we build this agent?"
It's "should we build this agent at all?"
We've seen teams spend months building agents for problems that a simple script could solve. Not because the agent was better — because "we need an AI agent" was the mandate from above.
So here's a practical test. Before you build an agent, ask these five questions:
1. Does the task require reasoning?
If the task is "if X, then Y" — it's a rule. Use a rule engine. Don't build an agent.
If the task is "given X, figure out Y based on context, partial information, and trade-offs" — that's reasoning. An agent might be appropriate.
Example: "Route this email to the right department based on keywords" → rules. "Understand this customer's complaint, determine if it's a billing issue or a product issue, and draft an appropriate response" → reasoning.
2. Does the task require adaptation?
If the task never changes — same inputs, same outputs, same context — automate it deterministically.
If the task shifts based on context, user behavior, or external conditions — an agent can adapt.
Example: "Generate a monthly report from this database" → scheduled job. "Monitor this system, identify anomalies, investigate root causes, and recommend fixes" → adaptation.
3. Does the task require multi-step planning?
If it's a single step (input → output), use a function.
If it requires breaking down a goal into sub-tasks, executing them in order, handling failures, and re-planning — that's planning. Agents excel here.
Example: "Summarize this document" → single step. "Research this topic: find sources, extract key claims, verify facts, synthesize findings, and produce a report" → multi-step planning.
4. Does the task require tool use?
If the task only needs text generation — use an LLM directly.
If the task needs to interact with external systems (APIs, databases, file systems, other agents) — an agent that can call tools is appropriate.
Example: "Write a poem about cats" → LLM. "Check this customer's account status, review their payment history, determine if they qualify for a refund, and process it if they do" → tool use.
5. Does the task require judgment under uncertainty?
If there's a clear right answer — compute it.
If the answer depends on context, trade-offs, and incomplete information — judgment is needed. Agents can reason under uncertainty.
Example: "Calculate 2+2" → compute. "Should we approve this loan application given the applicant's history, current market conditions, and risk appetite?" → judgment.
The Scoring
- 0-1 Yes: Don't build an agent. Use rules, scripts, or direct LLM calls.
- 2-3 Yes: Maybe. Consider a simple agent with limited autonomy. Start with a proof of concept.
- 4-5 Yes: Build an agent. But govern it — intake, evaluation, approval, monitoring.
- Latency: Agents are slower than rules. Always.
- Cost: Every agent call hits an LLM. Rules are free.
- Reliability: Agents hallucinate. Rules don't.
- Maintainability: Agent behavior is harder to debug than deterministic code.
- Governance: Every agent needs governance overhead. Rules don't.
The Real Cost of Unnecessary Agents
Building an agent when you don't need one isn't just wasted effort. It's actively harmful:
The best agent is the one you didn't build.
Before you reach for "let's build an agent," reach for "let's understand the problem." The problem will tell you what you need.