Inspire AI: Transforming RVA Through Technology and Automation
Our mission is to cultivate AI literacy in the Greater Richmond Region through awareness, community engagement, education, and advocacy. In this podcast, we spotlight companies and individuals in the region who are pioneering the development and use of AI.
Your API might be perfectly callable and still be wildly unsafe for an autonomous agent. We open with a simple thought experiment: give a super capable “new employee” access to your APIs, but take away their ability to browse docs, ask questions, or intuit which operations are dangerous. That’s the reality of agentic AI. If your contracts only describe syntax, you’re leaving the most important information implicit and ambiguity doesn’t stay theoretical when software can execute it at scale.
We dig into what makes an AI native API contract different: semantics. Purpose, preconditions, side effects, required permissions, approval requirements, expected latency, and what failure actually means. Then we get concrete about idempotency and retries. When a network drop happens after a “create” call, an agent may retry because it learned nothing and suddenly you’ve got duplicate support cases, duplicate orders, or an accidental credit issued twice. The fix isn’t wishful thinking, it’s designing explicit contracts that assume retries will happen and define safe behavior.
We also tackle structured error handling for autonomous agents. A 403 is not guidance. An agent needs machine-readable signals that distinguish “retry later” from “reauthorize,” “request approval,” or “never retry because policy blocks this action.” Finally, we zoom out to architecture: REST and GraphQL still shine for deterministic domain boundaries, MCP helps agents discover tools and context, and agent-to-agent systems sit at a different abstraction level. Capability discovery becomes part of your product surface, because what agents can safely discover determines what they can safely do.
If you care about AI governance, API security, reliability, and building automation you can audit, this one is for you. Subscribe, share it with a platform or API team, and leave a review if it sharpened your thinking. What part of your API would an agent misunderstand first?
Want to join a community of AI learners and enthusiasts? AI Ready RVA is leading the conversation and is rapidly rising as a hub for AI in the Richmond Region. Become a member and support our AI literacy initiatives.
Welcome back to Inspire AI, the podcast where we translate fast-moving AI technology into practical mental models for people who have to design, lead, and live with what comes next. Imagine giving an extremely capable new employee access to your APIs. There's one catch. They can't call anyone. They can't browse your documentation the way the developer would. They won't inherently know which operations are dangerous. They may retry something because they aren't sure whether it worked, and they can operate hundreds of times faster than your human employees.
That's roughly the challenge of the AI native API. Callable is not necessarily understandable. We often describe APIs as machine readable, but most APIs are really developer readable and machine callable. Those aren't the same thing. An API might tell you post to use cases endpoint. A developer can infer quite a lot from that, but an autonomous system needs considerably more context. What does creating a use case even mean? Is it reversible? Can duplicate calls create duplicate cases? What permissions are required? And which errors should be retried? The list of questions goes on and on. An AI native contract needs to make more of that explicit. Traditional API descriptions are pretty good at syntax. There are parameters, there's JSON schema, and there's a response, right? AI native contracts increasingly need semantics. What is the purpose of this capability? What are its preconditions? What side effects can occur? What authorization is required? Is it idempotent? Does it require approval? And what is the expected latency? And what happens if there's a failure? What does failure even mean? So in other words, we're moving from describing how to call software toward describing how software should reason about calling software. And that's the shift that we're talking
about. So consider a simple action. Create a support case. An agent calls the API. The case is created, but the network connection drops before the response reaches the agent. What does the agent know? Absolutely nothing. So it retries. Now you've created two cases. Maybe that's just annoying, but how about replace create a case with send a message? Or place an order. Or even issue a credit. Now retry behavior becomes a business risk. Agent versus platforms should assume retries will happen. Item potency cannot be a nice to have buried in implementation details. The contract needs to tell the agent and the platform how repeated requests are handled.
Humans are surprisingly good at interpreting bad error messages. Agents need structured failure semantics. Errors need to tell machines what to do next. Imagine these four failures. You temporarily exceeded a rate limit, or your authorization expired. How about the action requires human approval? And even this action is prohibited. All four are failures. But the correct next action is completely different. One where you exceeded the rate limit, you might retry that later. The other, where your authorization expired, you need to reauthorize. You see what I'm getting at? An AI native API needs to make those distinctions explicit enough that autonomous software can respond safely. A useful error isn't simply 403 forbidden. It's more like this action is blocked by policy. Do not retry. Or possibly even this operation is permitted after approval. Pause this task and request approval with the ID of whatever. And that is a much richer machine contract, one in which the semantics are built
in. So where are the traditional technologies like REST or MCP or even agent to agent fit in? This is where the conversation often becomes unnecessarily tribal. Do APIs become MCP or does agent to agent replace REST? Should everything become an agent protocol? I don't think so. Different protocols solve different problems. REST and GraphQL remain extremely useful for deterministic domain boundaries and capabilities. For instance, get this record. It's not a whole lot of probabilistic concern there. Or update this status. Same thing. Query this data. Create this object. Those operations shouldn't become fuzzy merely because an agent invokes them. MCP is useful at another boundary, connecting an agent to tools and context in a standardized way. Think of it as helping an agent understand the capabilities that are available to them. Agent-to-agent frameworks address another problem, obviously, agents interacting with agents. And you wouldn't give it instruction like call this database operation. More like, here's a task. Can your agent perform it? That task might run asynchronously. It might generate artifacts and it might pause. It might just need more information. And it might even involve its own internal tools that the calling agent never even sees. So that's a completely different abstraction. What you probably don't want to do is turn every API into an agent. For example, suppose you have a mature billing API. You don't necessarily need a billing agent wrapping every operation. Your deterministic services should remain deterministic. The agent layer should sit where adaptive reasoning is useful.
Here's a helpful mental model. You've got customer agent to enterprise agent to agent tools to deterministic domain APIs. The deeper you move into systems of record, the less magical the architecture should become. And that separation helps enormously with reliability and security, testing and auditability.
Now imagine a future customer agent arriving at your platform. It won't require some instruction like click settings and then integrations, then advanced and blah blah blah, creating the workflow. It instead should be able to discover what capabilities exist here, what inputs do they require and what outputs do they produce? Which permissions are needed? Which operations cause side effects? Which operations are synchronous versus asynchronous? That suggests the capability discovery becomes part of product architecture. Your product isn't merely what humans can see in the interface. Your product is also what the autonomous actors can discover through machine readable contracts. For every important API, you want to ask, can an agent understand its purpose? Can it predict the consequences? Can it determine the required authority? Can it safely retry? Can it correlate an asynchronous response back to the original task? And if not, you don't necessarily have a bad API. You have an API built for a different operating
model. Here's the deeper point. The temptation here is to think that agent-native architecture means making APIs easier for language models to call. That's just too narrow. The objective is to make platform capabilities safe for autonomous consumption. Clarity of consequence is essential because in an agent-first environment, ambiguity becomes executable. A human sees an ambiguous button and hesitates. An autonomous system may call the endpoint. And that leads us directly to the next episode.
Because even the world's best API contract doesn't answer the most important security question. Who gave this agent permission to act? So until next time, stay curious, keep innovating, and build interfaces that machines can understand without making humans surrender control.