AI agent
An AI agent is a system based on artificial intelligence that can carry out tasks with some degree of autonomy, drawing on instructions, context, tools, and control mechanisms. In agile teams working with AI, an agent doesn't replace human responsibility: it acts as an operational collaborator under the supervision, limits, and verification criteria the team defines.
An AI agent is not simply a language model or a more sophisticated chatbot. The difference lies in its ability to act within an environment: read information, use tools, consult sources, modify artifacts, execute steps, maintain the state of a task, and produce verifiable results.
A useful way to understand it is:
The model provides the ability to reason about language, generate responses, recognize patterns, and propose actions. The harness provides the operating environment: instructions, context, tools, permissions, memory, verification sensors, limits, and supervision rules.
Without a harness, the model responds. With a harness, the agent can work.
What sets an AI agent apart
The term "AI agent" is used broadly and sometimes confusingly. There's no single, universally established definition that fits every context, but in professional work it usually involves several elements.
| Element | Function |
|---|---|
| Model | Interprets instructions, reasons about the context, and generates responses or actions. |
| Instructions | Define the goal, the operational role, the limits, and the expected way of working. |
| Context | Provides relevant information: documentation, specs, history, architecture, data, or decision criteria. |
| Tools | Allow it to act on the environment: search, read files, run code, call APIs, create documents, or modify systems. |
| Memory or state | Helps maintain continuity across steps, sessions, or tasks. |
| Verification sensors | Check whether the result meets the criteria: tests, linters, reviews, fact-checking, validations, or human review. |
| Governance | Sets permissions, limits, traceability, usage policies, and accountability. |
An AI agent doesn't need every one of these elements at its highest level to count as an agent. But the more it acts on real tasks, the more necessary the controls become.
The difference between model, chatbot, assistant, and agent
It's worth distinguishing terms that often get mixed up.
| Concept | What it is | Example use |
|---|---|---|
| AI model | A system trained to process and generate information. | An LLM answering a question. |
| Chatbot | A conversational interface for interacting with a model or system. | A chat that answers frequently asked questions. |
| AI assistant | A tool that helps a person carry out tasks, usually under direct instructions. | Helping draft an email, summarize a document, or explain code. |
| AI agent | A system that can pursue a goal across multiple steps, using context, tools, and controls. | Reading a spec, modifying code, running tests, fixing errors, and preparing a review summary. |
The boundary isn't always clean. An assistant can behave like an agent if it has tools, persistent instructions, task memory, and the ability to execute chained actions. That's why it's better to look at the working system than to rely on the marketing label alone.
Degrees of autonomy
Not all agents have the same level of autonomy. In professional teams, it's better to talk about degrees rather than absolute autonomy.
| Level | Description | Main risk |
|---|---|---|
| One-off assistance | The agent responds to specific instructions and waits for new directions at each step. | Low productivity if everything requires micromanagement. |
| Guided execution | The agent follows a spec, a task list, or a flow defined by the team. | Poor execution if the context or criteria are ambiguous. |
| Supervised autonomy | The agent decides some intermediate steps, uses tools, and reports results for human review. | Accepting results without checking the evidence. |
| Extended autonomy | The agent works over longer periods, coordinates subtasks, or interacts with several systems. | Loss of control, accumulated errors, or unwanted actions. |
In agile settings, the most useful level is usually supervised autonomy: enough to offload operational work, but with clear limits and human review.
What an AI agent can do in an agile team
An AI agent can support many agile activities, as long as the team defines the scope and controls well.
It can help with:
- analyzing discovery information;
- synthesizing interviews or user feedback;
- refining user stories;
- generating acceptance criteria;
- writing or reviewing specs;
- building prototypes through vibe coding;
- implementation guided by Spec-Driven Development;
- generating an initial set of tests;
- reviewing code with a focus on risks;
- technical documentation;
- preparing materials for a Sprint Review;
- analyzing patterns in retrospectives;
- detecting inconsistencies, duplicates, or risks.
But these tasks don't all carry the same level of risk. Asking an agent to summarize notes is not the same as letting it modify production code, change permissions, process sensitive data, or take actions affecting real customers.
AI agents in Scrum with AI
In Scrum with AI, the agent doesn't become a new Scrum role. It's not a Product Owner, not a Scrum Master, and not a Developer in the accountable sense. It's an operational participant in the working system.
Accountability remains human:
- The Product Owner or Product Architect decides what's worth building and which hypotheses are worth validating.
- The Product Builders define specs, review outputs, integrate results, and answer for technical quality.
- The Scrum Master or Agile Enabler facilitates the human-AI system: flows, limits, governance, trust, and continuous improvement.
The agent can carry out part of the work, but it doesn't take on accountability. If an increment fails in production, responsibility can't be handed off to "the AI did it."
Relationship with the Definition of Ready for AI
Before assigning work to an agent, the team should check that the item is ready. This idea can be understood as a Definition of Ready specific to AI.
An item is ready for an agent when:
- the spec is complete and reviewed;
- the agent has access to the context it needs;
- the acceptance criteria are verifiable;
- technical and security constraints have been defined;
- the prompts or instructions are precise enough;
- time has been set aside for human review;
- it's clear who will review and take ownership of the result.
Without this onboarding, the agent may produce fast outputs that are irrelevant, incomplete, or dangerous.
Relationship with a strengthened Definition of Done
An agent's work isn't done when the agent declares it's done.
In a team working with AI, the Definition of Done needs to be strengthened with specific controls:
- human review of the output;
- automated tests where applicable;
- static or quality analysis;
- security review;
- verification against the spec;
- checking for duplication or problematic dependencies;
- traceability of relevant decisions;
- explicit acceptance by an accountable person.
The agent can produce the output. The team decides whether that output can become part of the increment.
Common types of agents
Agents can be classified by the function they perform.
| Agent type | Typical function | Example |
|---|---|---|
| Research agent | Searches, organizes, and synthesizes information. | Preparing a summary of evidence for discovery. |
| Product agent | Helps structure hypotheses, criteria, stories, or specs. | Turning a hypothesis into verifiable acceptance criteria. |
| Code agent | Implements, modifies, or reviews software. | Carrying out a task defined in a spec and passing tests. |
| Reviewer agent | Evaluates outputs from another agent or a person. | Reviewing risks, inconsistencies, or vulnerabilities. |
| QA agent | Generates or runs tests and analyzes failures. | Proposing edge cases for a feature. |
| Documentation agent | Produces or updates documentation from changes. | Updating a technical guide after a change. |
The classification isn't rigid. A single agent can fulfill several functions if the harness allows it, but for critical work it's usually better to narrow the mission.
An agent shouldn't grade its own homework
An important rule of thumb: you shouldn't rely on the same agent that produced an output being the only one responsible for verifying it.
If an agent writes code and is then asked to review it, it will tend to validate its own decisions or overlook assumptions it was already carrying. This doesn't mean self-review is useless, but it shouldn't be the only control.
For important tasks, it's best to combine:
- computational sensors: tests, linters, static analysis, validators;
- human review;
- reviewer agents with different instructions;
- verifiable examples;
- acceptance criteria external to the implementing agent.
Verification must sit outside the generator's optimism.
Relationship with prompt engineering and context engineering
Prompt engineering helps you communicate better with an agent: phrasing instructions, scoping tasks, requesting formats, setting criteria, and avoiding ambiguity.
Context engineering deals with what information the agent sees at any given moment: documents, examples, history, constraints, sources, tools, or the state of the task.
Both matter, but neither is enough on its own. A reliable agent also needs the right tools, limited permissions, sensors, review, and governance.
A good prompt can improve a response. A good harness improves the whole working system.
Main risks
AI agents introduce specific risks because they don't just respond: they can act.
Operational hallucination
The agent can fabricate data, sources, APIs, dependencies, paths, prior decisions, or test results. The more convincing the response, the more dangerous the error can be.
Prompt injection
If the agent processes external content, that content can include malicious or deceptive instructions. For example, a web page, an issue, an email, or a document could try to alter the agent's behavior.
Unwanted actions
An agent with too many permissions can delete, modify, send, publish, or execute actions without enough control.
Loss of traceability
If decisions, sources, prompts, outputs, and reviews aren't logged, the team won't be able to reconstruct why something was done.
Over-reliance
The team can lose its judgment if it accepts outputs by default, delegates substantive decisions, or stops understanding the work being produced.
Agent washing
Some tools present themselves as "agents" even though they're just simple automations or chatbots with a marketing layer. The label guarantees neither useful autonomy nor quality.
Good practices
To integrate AI agents rigorously, it's worth applying these practices:
- Start with narrow tasks. The more critical the work, the less initial autonomy.
- Define minimal permissions. The agent should only access what it needs.
- Separate generation and review. Whoever produces shouldn't be the only one who verifies.
- Use specs and verifiable criteria. Ambiguity raises the cost of review.
- Maintain traceability. Log relevant decisions, sources, actions, and outputs.
- Protect sensitive data. Don't expose secrets, credentials, or confidential information without safeguards.
- Design sensors. Tests, checklists, validators, reviewers, and controls before production.
- Review the real cost. Measure not just generation, but review, rework, errors, and value delivered.
- Keep responsibility human. The agent executes; the team answers for it.
When not to use an agent
Not every task improves by turning it into an agentic one.
It may be better not to use an agent when:
- the task is simple and a deterministic automation solves it better;
- the cost of reviewing the output outweighs the benefit;
- there are no clear criteria for knowing whether the result is correct;
- the agent would need access to sensitive data without adequate controls;
- a wrong action would have serious consequences;
- the team doesn't have the capacity to supervise;
- the task requires an ethical, legal, or strategic decision that a person must make.
A simple rule: if you can't review the result, you shouldn't delegate it.
Common mistake
Treating the AI agent as if it were an accountable member of the team. An agent can collaborate, carry out tasks, and produce valuable outputs, but it doesn't take on professional responsibility. Accountability remains human. If the team doesn't define limits, context, verification, and owners, the agent becomes a source of apparent speed and real risk.
Resources
🏦 Harness EngineeringSkill Arena · Scrum Manager
🏦 SDD - Spec Driven DevelopmentSkill Arena · Scrum Manager
References
- Anthropic. (2024). "Building effective agents." Anthropic.
- Anthropic. (2025). "Writing effective tools for agents — with agents." Anthropic.
- IBM. (2025). "What Are AI Agents?" IBM Think.
- NIST. (2023). Artificial Intelligence Risk Management Framework (AI RMF 1.0). National Institute of Standards and Technology.
- OpenAI. (2025). "Agents SDK." OpenAI API Documentation.
See also
Want to take your agility further? You can look for upcoming course and exam dates, or go at your own pace by becoming an Agile Club member. Membership includes exclusive resources, e-learning classrooms, and access to Skill Arena: a space to practice and measure your agile skills whenever it suits you.