ai notes
Concept

Designing Agents as Teammates Not Tools

Effective agentic AI requires treating agents as teammates who need proper context and experience design, not as tools you configure with the right parameters.

Created Last updated 5 min read

This structure note argues that effective agentic AI requires treating agents as teammates who need proper context and experience design, not as tools you configure with the right parameters.

The Core Argument

Agents fail most often not because of technical limitations, but because they lack the context and experience design we’d naturally provide to human teammates. We should invest in AX (Agents Experience) with the same rigor as DX (Developer Experience)—giving agents clear goals, proper context, and feedback mechanisms. The design patterns that work (Reflection, Planning, Tool Use) succeed because they mirror how humans improve through feedback.

The Investment Case

We should invest in AX (Agents Experience)

We invest heavily in Developer Experience (DX) because better context and tooling make developers more effective. The same logic applies to agents. Agents are teammates, not APIs:

  • They need clear goals (not vague prompts)
  • They need relevant context (not everything or nothing)
  • They need feedback mechanisms (not one-shot execution)
  • They need appropriate autonomy (not too much or too little)

Treating agent design as “prompting” misses the point. You’re designing a work environment for a teammate.

Understanding Autonomy Levels

Agentic AI can be less or more autonomous

Agents exist on a spectrum:

Low autonomy: Predetermined steps, human approval at each stage Medium autonomy: Agent chooses between defined options High autonomy: Agent creates new tools and approaches

The right level depends on:

  • Task clarity (well-known processes → higher autonomy)
  • Risk tolerance (high stakes → lower autonomy)
  • Learning goals (want to see agent reasoning → lower autonomy initially)

There’s no universally “best” autonomy level—it’s about matching autonomy to context.

When Agents Work Well

Agentic AI works better for well know, linear processes

Agents excel when:

  • Steps are known and relatively sequential
  • Standard operating procedures exist
  • Assets are primarily text-based
  • Success criteria are clear

Agents struggle when:

  • Process is genuinely novel (no prior examples)
  • Steps are highly parallel or unclear
  • Heavy multimodal content (images, videos)
  • Success is subjective or context-dependent

This doesn’t mean “only use agents for simple tasks”—it means design agent workflows to decompose complex tasks into well-defined steps.

Agentic workflows are only as good as their weakest component + error analysis

Agent failures often come from one weak component, not overall design. Use Theory of Constraints thinking:

  1. Examine traces/spans to see where agent fails or slows
  2. Identify the bottleneck (unclear instructions? Poor tool? Bad context?)
  3. Improve that component
  4. Repeat

This requires treating agents like systems you debug, not black boxes you prompt differently until they work.

The Reflection Pattern

Reflection (Agentic Pattern) consistently outperforms direct generation on a variety of tasks

Reflection—where agents evaluate and improve their own output—mirrors how humans work. You draft, review, revise. Agents that reflect outperform one-shot generation because:

  • They can catch obvious errors
  • They can refine toward success criteria
  • They can incorporate feedback

Reflection (Agentic Pattern) can use external feedback from tools to improve output

Reflection becomes powerful with external feedback. Example: agent writes code, runs tests, sees failures, fixes issues. The tool (test runner) provides grounded feedback, not just LLM self-criticism.

This is why good agent design includes tools that can provide objective feedback signals.

The Evaluation Challenge

Agents can be evaluated objectively or subjectively

Objective evaluation: Clear success criteria (code compiles, tests pass, output matches spec) Subjective evaluation: Quality judgments (writing is engaging, design is intuitive)

For subjective tasks:

“LLM as a judge” grading with a rubric gives more consistent results when evaluating Reflection (Agentic pattern)

Using another LLM with a clear rubric provides more consistent subjective evaluation than human judgment at scale. This enables:

  • Consistent quality bars across many agent runs
  • Faster iteration on subjective tasks
  • Clearer success criteria for reflection loops

The rubric is key—without it, you get inconsistent LLM judgments.

The Planning Pattern

Planning (Agentic Pattern) with code improves performance

When agents express plans in executable code rather than natural language:

  • Plans become more precise (code forces specificity)
  • Plans are testable (you can validate the plan)
  • Plans enable richer reasoning (code structures thought)

This doesn’t mean “only write code”—it means use code as a thinking tool where it provides leverage.

Practical Implications

For agent design:

  • Start by designing the experience (goals, context, feedback) not the prompts
  • Choose autonomy level based on task characteristics and risk
  • Build in reflection loops with objective feedback where possible
  • Design tools that provide clear feedback signals

For debugging agents:

  • Examine traces to find bottlenecks
  • Fix the weakest component, not the whole system
  • Use Theory of Constraints thinking
  • Treat it as system debugging, not prompt tweaking

For evaluation:

  • Use objective metrics where possible
  • For subjective tasks, create clear rubrics before using LLM judges
  • Build evaluation into the design, not as an afterthought

Where This Leads

As agents become more capable, the bottleneck shifts from “what agents can do” to “how well we design agent experiences.” The teams that treat agents as teammates—providing proper context, feedback mechanisms, and appropriate autonomy—will get far better results than teams that treat agents as tools to configure.

This is the AX (Agents Experience) investment thesis: the same rigor we apply to DX should apply to designing work environments for our agent teammates.

Related Structure Notes:

Related Hubs: