AI Agents for Testers — LLM + Tools + Loop, MCP and the STLC

Why this matters on the job

Picture a sprint review at a product company in Bengaluru or a client delivery team in Pune. The engineering manager says: "Our competitors are using AI agents to write and fix tests. Can we cut our regression automation backlog in half this quarter?" Half the team has only used AI chat to paste a stack trace and ask what went wrong. The other half has tried an agent that clicked around the app, wrote a test, ran it and fixed its own mistakes - and they are either excited or worried.

In 2026 the conversation has moved from "AI suggests a line of code" to "AI agents explore the app, write tests, run them and repair them". Testers who understand how an agent works - the model, the tools it can call, and the loop it runs - are the people who can make it useful and safe. Testers who do not understand it either avoid agents completely or trust them blindly. Both are career risks. This lesson gives you the mental model you will use for the rest of the course.

Concepts

Three generations of AI help for testers

It helps to separate the hype into three clear generations. Most teams in India and abroad now use all three side by side.

The jump from generation 2 to 3 is not about a smarter model. It is about giving the model hands (tools) and time (a loop). That is why the same model can feel like a toy in a chat window and like a junior automation engineer inside an agent.

Anatomy of an agent: LLM + tools + loop

• LLM (the brain) - reads the goal, the conversation so far and the tool results, then decides the next action. It does not "see" your app directly; it only sees what tools return.
• Tools (the hands) - functions the model is allowed to call: navigate a browser, take an accessibility snapshot, click, read a file, run a shell command, call an API. Each tool has a name, a description and an input schema.
• Loop (the persistence) - the host program sends the model's tool request to the tool, captures the result and sends it back to the model. This repeats until the model says it is done, a step limit is reached, or a human stops it.
• Context (the memory) - everything the model can see in one turn: instructions, files you attach, previous tool outputs. Context is limited, so good agents summarise and good testers keep prompts focused.
• Guardrails - permissions, approvals, allowed websites, step limits and human review. Without guardrails, an agent is just an automated way to make mistakes faster.

The following pseudo-code is not a real product, but it shows the loop every agent host runs, whether it is VS Code, Claude Code or a CI bot:

# Simplified agent loop - for understanding only
def run_agent(goal, tools, llm, max_steps=25):
    messages = [{"role": "system", "content": "You are a test automation agent."},
                {"role": "user", "content": goal}]
    for step in range(max_steps):
        reply = llm.chat(messages, tools=[t.schema for t in tools])
        if reply.tool_call is None:          # model says it is finished
            return reply.text
        tool = next(t for t in tools if t.name == reply.tool_call.name)
        if tool.needs_approval and not human_approves(reply.tool_call):
            messages.append({"role": "tool", "content": "User denied this action."})
            continue
        result = tool.run(**reply.tool_call.arguments)   # e.g. click, run tests
        messages.append({"role": "tool", "content": result})
    return "Stopped: step limit reached - ask a human to review."

Notice three tester-relevant details: the max_steps limit (agents can loop forever), the approval check (some tools are risky), and that every tool result goes back into the context (so a malicious web page can talk to the model - we will cover that prompt-injection risk in lesson 9).

Model Context Protocol (MCP) basics

Before MCP, every AI tool vendor wrote its own plugin format. The Model Context Protocol is an open standard that defines how an AI application discovers and calls external tools and data. Write a tool server once and many clients can use it - VS Code with GitHub Copilot, Claude Code, Cursor and others.

Servers can run locally as a child process (communicating over standard input/output) or remotely over HTTP. Most testing servers you will use start with an npx command. A typical client configuration looks like this (the exact file name and top-level key differ per client - VS Code uses .vscode/mcp.json with a servers key, many other clients use mcpServers):

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

This is the configuration documented on the Playwright MCP getting started page. Important point for testers: an MCP server is code that runs on your machine with your permissions. Treat adding one like installing a dependency - only from trusted publishers, pinned and reviewed.

Where agents fit in the STLC

Agents are not equally useful in every phase. Use this map when your manager asks "where should we start?"

Limits you must explain to stakeholders

• Non-determinism - the same prompt can produce different tests on different runs. Commit the generated code, not the prompt, as the source of truth.
• Confident but wrong - agents can write assertions that always pass (for example checking that a page has a title) and report success.
• Cost and speed - every tool call is a model call. Running the LLM inside every CI test run is slow and expensive; use agents to create and maintain tests, and plain Playwright to run them.
• Data privacy - anything the agent reads may be sent to the model provider. Never point agents at production data or paste client PII; use synthetic data and practice sites. In India the Digital Personal Data Protection (DPDP) Act 2023 applies to personal data, and EU clients will expect GDPR discipline.

Real-world assignment

Prepare a two-page "Agentic testing opportunity map" for a realistic product (for example a UPI payments app or an e-commerce site like saucedemo.com). For each STLC phase, list one task an agent could do, the MCP tools it would need, what a human must review, the risk level and how you would measure success. Add a diagram of the agent loop in your own words. Publish it in your portfolio repository as a Markdown file - interviewers increasingly ask candidates how they would introduce AI agents safely.