How Agentic AI is Changing the Way Developers and QA Testers Are Using API's

Share
How Agentic AI is Changing the Way Developers and QA Testers Are Using API's

An AI agent can read your code, draft a plan, and talk you through a bug until the picture snaps into focus. That's the part people notice. The part that actually makes that happen is something going on in the background: the agent has to leave the chat window and talk to other systems.

The way this happens is API calls.

As agents have become common in software development and testing, they're changing how we interact with APIs because something that never used to make those calls is doing so practically all the time now. Fetch the codebase. Trigger the build in my development environment for me. Run the QA tests automatically. Create a write-up for me to review and approve to put on the pulse/issue. Post the result to the pulse/issue for me. Ask Stripe what happened to the payment. Ask GitHub whether the deploy finished. Ask a third party integrations whether an event management software software sent an API call to unlock a door at 6:00, not 6:02.

However, the reality is that the agent is only as useful as the API calls it can make — and only as trustworthy as whether it makes the right ones. Wrong API call means the wrong answer.


This Is Already How Every Website Works

Most websites and online software already run on API calls. You just never see them.

When you click your profile icon, the browser sends a request to the company's server: give me this person's profile. When you open a menu, another call happens: give me the items in this menu. You expand a dropdown. Another call: give me the options for this list. The page in front of you isn't one downloaded object. It's the result of the browser asking for the layout, then the data, then the picture next to your name — and stitching the answers together in milliseconds.

Every click is a request. Every request is an API call from your browser to a server, asking for the thing you just indicated you wanted.

Agents are doing the same job. They just don't wait for a click.

You can ask an agent to create a dashboard that shows all your follow-up tasks: emails you still need to respond to, teammates you need to nudge because you haven't heard from them in seven days, comments you still need to check on Monday pulses, and new updates on Jira issues from QA test reports you submitted. That dashboard isn't magic. It's the agent making API calls — at lightning speed — to Gmail, to Monday, to Jira, to whatever else you gave it access to, then assembling the answers into one view. You didn't click through four products. You asked once. The calls still happened. There were just a lot more of them, to a lot more places, in a lot less time.


How AI Agents Work with APIs

Picture an agent sitting down to do a real job. It doesn't get a single magic button to just magically make all that you ask it to appear (although getting an agent to gather information and do tasks can feel like magic). The agent makes connections with other companies — sometimes initiated by you, sometimes by a local plugin, or just access to the internet. Through those connections to GitHub, Stripe, your CI (your development cycle), your support desk ticketing system, the third-party integration your company software uses, and so on, the agent can ask for information and receive answers.

To do useful work, an agent has to:

  • Have access to fetch data so it can understand a company's codebase, a support ticket, or a customer's account
  • Have permission to trigger development builds and deployments
  • Be given instructions and tools to run tests and read what came back
  • Be able to integrate with external services — payments, calendars, door access monitoring systems, HVAC scheduling software, chats, the whole neighborhood of tools a person actually uses

Getting answers for how a system has been performing, creating charts and metrics for which features your customers use the most versus which ones they submit tickets about the most, or having an agent perform tasks for you isn't a result of "the AI just figured it out." It's the result of tens if not hundreds — sometimes thousands — of API calls that the agent made to whatever system it needed in order to get you the information you wanted, create what you wanted, or perform the task you asked it to. Each one of those is an HTTP request, with a URL, a method, a body, and a response that either made sense to the system that received it or didn't.

A short example. A coding assistant isn't "looking at your repository of company source code" in some mystical way. It makes specific API calls to figure things out. It calls something like GET /repos/your-org/your-app/contents/src to read files, then later POST /repos/your-org/your-app/actions/workflows/ci.yml/dispatches to kick off the build. If those calls fail — because it doesn't have access, or it made the wrong call — it's stuck, same as you.

How those calls are shaped matters as well, because there are multiple types of API calls. The oes most used by agents are REST API calls and SOAP API calls. However, they work differently so the agent has to approach each one differently.


REST: The Same Calls Your Browser Already Makes

REST is the most common style of API calls that agents use, and that's not a coincidence. It's the same style most websites and software already run on.


REST API calls use a small set of methods to say what to do:

  • GET to read something
  • POST to create something new
  • PUT or PATCH to change something that already exists
  • DELETE to remove it


Those are the same methods HTTP uses — HTTP (HyperText Transfer Protocol or HTTPS the secure version) is how messages travel across the internet. HTTPS is the secure version of that. When your browser loads a webpage, that's a GET. When you add a new song to a playlist, that's a POST (or sometimes a PUT). When you later remove that song, that's a DELETE.
REST just uses that same vocabulary for APIs. /users is the directory. /users/123 is one person. /users/123/orders is what that person bought.

The response is usually JSON, a simple way to write data as text so computers can send it to each other and humans can read it.

Example:

{
"name": "Jane",
"email": "jane@example.com",
"id": 123
}

So the "grammar" that REST uses is already everywhere. An agent can discover endpoints from documentation (which many companies post on their website or inside their software), follow the resource structure without inventing a new dialect for every service, and reuse the same patterns it learned on GitHub when it later talks to Stripe or Jira. Less guessing. More correct calls without a human sitting next to it, whispering the next URL.


That's also why REST became so popular. It rides on the same request-and-response pattern browsers already use. It works for websites, mobile apps, and now agents. It's lightweight. It's predictable. And almost every public API you've heard of — GitHub, Stripe, Slack — is a REST API running over HTTPS.

A short example. You ask an agent, "What's on this customer's latest order?" On a REST API it doesn't need a secret handshake. It goes GET /users/45821, finds the account, then GET /users/45821/orders?limit=1.

GET /users/45821/orders?limit=1 HTTP/1.1
Host: api.example.com


The JSON comes back with an id, a total, a status:
{
"id": 9901,
"customerId": 45821,
"total": 49.99,
"status": "failed"
}

If the order is status: "failed", the next likely stop is already obvious: GET /orders/9901/payments. Same kind of call your browser makes when you click "Order history" on the webpage. The agent just made it without the click.


SOAP: Still Out There — So Agents Still Hit It

SOAP is a different style of API call. It's not what most new software is built on, and it is not what agents prefer. It is still what a lot of important systems actually speak — banks, hospitals, government, telecom, older enterprise tools. Those systems are expensive to replace. So they stay.

SOAP doesn’t give you a tree of URLs. It gives you one address and a list of named jobs: GetCustomerInfo, PlaceOrder, UnlockDoor. The message is XML. The instructions live in a WSDL file — a contract that lists every job, every required field, and the exact shape of the reply.

Agents can work with this. They just have to do it differently. They read the contract instead of following a path. They send XML instead of JSON. Last week’s Stripe instincts don’t transfer.

The twist: that strictness can help. REST leaves room for “maybe this field is optional.” SOAP does not. If CustomerID is required, it’s required. For an agent, less guessing is a gift — even if the wrapping paper is XML.

So if the data lives in a hospital system or a bank, the agent will make SOAP calls. Not because SOAP is fashionable. Because that’s where the data lives.

A short example. Same question — "What's on this customer's latest order?" — but the service is SOAP. There's no /users/45821/orders. The agent has to open the WSDL, find GetLatestOrder, and send something like:

<soap:Envelope>
  <soap:Body>
    <GetLatestOrder>
      <CustomerID>45821</CustomerID>
    </GetLatestOrder>
  </soap:Body>
</soap:Envelope>

Harder to write. Easier to know you didn't skip a required field.


More Work With Agents Means More Calls — and More Kinds of Calls

This is the part that isn't obvious when you only think about one prompt and one answer.

Developers are using agents to help them write code for new features, identify bugs, fix the existing code, build an artifact of those changes, deploy it to a development environment, run automated tests (Playwright and other tools), commit the changes, and open a pull request to merge them into the main branch. Each of those steps is not one conversation. It's a chain of API calls: read the files, search the repo, run the tests, trigger the CI build, create the commit, open the PR, post the description in the PR.

QA testers are using agents to create test cases before a developer makes and changes, set pass and fail criteria, analyze the code changes the developer just made, and auto-adjust which tests are needed. They have the agent reread the new feature spec or the bug in the support ticket, perform as much of the actual test as can be automated, make sure those tests actually cover what the original spec or customer issue asked for, write up the QA test report, and — once approved — post it to the Monday pulse or the Jira ticket.

Because of that, API call usage has gone up a lot. The kinds of API calls have gone up too.

When this work was done by hand, you made fewer calls, and you made fewer different calls. You opened one screen at a time. You clicked the profile, the menu, the ticket. The browser asked for what that screen needed and stopped. You didn't also, in the same ten minutes, fetch the codebase, dispatch a workflow, query Stripe, reread a spec, run a suite of edge-case tests, and POST a report to two ticketing systems. A person batching work through a UI stays inside a small set of GETs — load this page, load this list. An agent fan-outs. It reads and writes. It talks to GitHub and CI and Jira and Monday and the payment provider and the integration under test. Different systems, different shapes, different methods — GET, POST, PATCH, SOAP operations — because one request from you turned into a workflow.

That's why the traffic looks different now. Not just more of the same. More destinations, more verbs, more contracts.


In Development: The Pair Who Can Call Out

This is the part most people have already felt, and seen the effects of. The coding assistant isn't only completing your functions. It's going out into the network on your behalf.

It generates API client code from a REST spec or a SOAP WSDL so you don't hand-write the same boilerplate for the fifth payment provider. It stands up a mock server so you can keep building when the real service is down or you don't want to charge a real card. It looks at your project and says, "You're going to need a webhook endpoint for this." And when a call fails, it doesn't just shrug — it reads the request, reads the response, and starts walking the pattern, figures out what went wrong and corrects it automatically!

A short example. You're adding card payments. You drop an OpenAPI file in the chat and say, "Generate the client, and don't hardcode the key." The agent reads the spec, writes the typed client, puts the secret in the environment, and scaffolds a mock server that returns a fake payment_intent so QA can test the "card declined" path without Stripe. Then the real checkout endpoint starts returning 500s. The agent pulls the last request and response, notices the payload still sends amount in dollars while the new version wants cents, and shows you the one-line fix. That's not a search result. That's a coworker who can see the wire.


In QA Testing: This Is Where It Gets Fun

If development is the agent learning to make the call, QA is the agent learning to not believe it, but test and prove it out.

This is the part that still lights me up. Testing an API used to mean reading the docs, writing cases by hand, running them, staring at failures, writing them up, and hoping you covered all the ways that something needed to be tested based on what was changed. Agents don't ever get tired (although they may run out of tokens). They can quickly studied all the detailed changes and additional changes to the code to know what needs to be tested. They can generate the cases, run them, chain them into a workflow, notice that twelve failures are really one failure in a costume, and keep going at a scale an afternoon of human effort cannot match.

Automated Test Generation

Give an agent the documentation and it starts inventing the questions a good tester asks. For REST, it writes a test for each endpoint — happy path, missing login, bad ID, extra field. For SOAP, it reads the WSDL and writes a test for each operation, including the ones nobody put on the plan.


The docs say POST /users needs an email, a password, and a name. The agent doesn’t stop at “valid user, 201 Created.” It also tries an email with no @, a password of 1, a duplicate email, a missing field, and a burst of requests to see if rate limiting is real or just on a wiki page. You still decide what’s worth running. You just didn’t have to think of every case at 4:30 on a Friday.


Intelligent Test Execution

Generating tests is only half of it. The useful part is what happens when they fail.

An agent can run the suite, read the failures, and see a pattern instead of a pile. It can chain calls the way a real user would — create the user, create the cart, apply the coupon, pay — and when step four breaks, it already has the IDs from steps one through three. It can tell a flaky timeout from a real bug. It can reread the feature spec or the support ticket, look at what the developer actually changed, and check that the tests still match what was asked for.

A hundred API tests run. Fifteen fail. A human sees fifteen problems. The agent notices all fifteen died talking to payments, all with 401 Unauthorized, all after 2:14 PM — right when the test key rotated. It doesn’t “fix production.” It hands you the sentence you needed: the product isn’t broken; the credentials expired. That’s the difference between an afternoon of chasing ghosts and a two-minute update.

Contract Testing

An API makes a promise: if you ask this way, you’ll get this back. Other apps are built around that promise. Then someone “just makes a small change,” and a mobile app already in customers’ hands breaks — because it was still expecting the old answer.

Agents are good at checking that the promise didn’t quietly change. For REST, they look at the data that comes back and ask: are the same pieces still there, in the same form? For SOAP, they check the XML against last year’s contract — the WSDL — and ask: does this operation still accept what it used to?

A new version ships. created_at used to be a date written as text. Now it’s a number. The demo looks fine. Two partner companies still expect text. Their software will break on Monday. The contract test is how you find that on Thursday, while you can still fix it.

Load and Performance Testing

Correct is not the same as ready. An endpoint can return perfect JSON for one user and fall apart when Black Friday shows up.

Agents can simulate traffic that looks like real use, not one URL getting hammered. They watch response times, error rates, and where things slow down, then point at the bottleneck: this database query, that payment call, this missing cache. The suggestion isn’t always right. It’s usually a better starting point than “it felt slow.”

You ask for a load test on checkout. The agent looks at last year’s traffic, ramps up, and finds everything is fine until payments hit about 5,000 requests a minute — then it falls off a cliff. The report isn’t “checkout is slow.” It’s “payments are the cliff.” You still make the call. You didn’t have to find that cliff in production.
And when the testing is done, the last calls are the ones people forget to count: draft the write-up, wait for you to approve it, then post it to the Monday pulse or the Jira ticket so the rest of the team can see what actually got tested.


Speed Is the Point, Judgment Is Still Yours

The advantage is not that agents are smarter than a good developer or a good tester. It's that they can talk to APIs at a scale and a speed people can't match — generate the cases, run them, read the contracts, notice the pattern, catch the thing before it reaches production.

REST will keep being the easier map. SOAP will keep being the stricter front desk. Agents will keep getting better at both and help developers and QA testers improve at their job.

What they won't do — and shouldn't — is decide what "good" means without you. They can make the call. They can tell you what came back. You still decide whether the door unlocked at the moment it mattered. The buck always stops with a person.

So happy AI prompting, and may your API calls always return 200 OK!