AI agents are radically reimagining virtually every aspect of digital technology, forcing us to reconsider everything from software design to how businesses operate. While agentic AI is opening up a wide range of exciting new possibilities, it also brings its own share of risks. Agentic AI can behave unpredictably, sometimes wreaking major damage if left ungoverned.

This also puts our APIs at risk, as they provide the infrastructure that makes agentic AI possible. The explosion of agentic AI is also causing a surge in APIs. A new model of API governance is emerging in light of this new reality.

API governance in the agentic era was one of the leading themes in this year’s Nordic APIs Summit. To help get a sense of how AI agents are shaping the way we design and use APIs, we’ve talked to a handful of experts from a wide cross-section of different industries to see how API governance is changing in the era of agentic AI.

How API Governance Is Evolving in the Agentic Era

The agentic AI era is making API governance more important than ever. Gil Feig, the co-founder and CTO of Merge, warns that with agents acting autonomously, “a single misconfigured permission can cause far more damage than it would with a human in the loop.” A bad API call used to be a mistake someone made once, back when humans wrote and approved calls by hand. Now, many teams hand an agent data sources and destinations and let it run, which means the same error can repeat “a hundred times before anyone notices.”

Unfortunately, simply implementing agentic identity isn’t enough. Daniel Lindau, a principal engineer at Curity, warns that the most common mistake is “treating AI agents as a new kind of identity to manage.” Registering every agent, giving it a profile, and slotting it into an existing identity and access management (IAM) directory produces what he calls “identity sprawl at machine speed,” cluttered with orphaned entries for agents that existed for only seconds.

Luckily, Lindau offers some advice on how API governance should be handled in the age of AI agents. “The governance question isn’t who the agent is,” he says. “It’s what the agent is allowed to do, in this context, on whose behalf, right now.” Framed that way, the unit of governance becomes the action and the token that authorizes it, not the directory entry. According to Lindau, most organizations haven’t made that shift yet, which is why their existing IAM investments don’t quite fit what agents need.

Company-Wide Frameworks

As APIs proliferate, companies need organization-wide frameworks to manage security risks. BECU chief information security officer (CISO) Sean Murphy describes how BECU adopted a company-wide API framework — a single governance policy that applies to all developers. APIs are also an attractive target for malicious actors, as noted by Steve Winterfeld, Akamai’s Advisory CISO, who reports that 42% of reported incidents involve an API connected to an AI.

Lunar.dev CEO Eyal Solomon describes his company’s approach as “a layered control architecture” spanning outbound APIs, AI traffic, and agent and Model Context Protocol (MCP) governance. Centralized enforcement, identity-based access controls, runtime policies, and audit trails help companies monitor and secure interactions.

Thankfully, establishing a company-wide framework helps minimize those risks. According to Winterfeld, organizations should fold API and AI governance into their existing risk-management processes, with an emphasis on security training, a security-first culture, and guardrails around deployment. Establishing a company-wide framework helps bake these protections in from the very beginning rather than trying to repair damage once it’s occurred.

Non-Human Identity Governance

As agentic AI has grown, so has the number of API calls made by machines. According to Solomon, agent traffic creates “new governance pressures around identity, scope, determinism, cost control, and observability.” As he puts it, “The challenge is no longer just securing APIs, it is governing agentic behavior.” That means tracing lineage across the full execution chain, from user to agent to model to MCP server to API call, and guarding against risks like prompt injection and over-permissioned agents.

Governance matters all the more when 56% of API calls are coming from automated scripts, servers, and bots.

More Intelligent Access Control

Agentic AI requires a more nuanced approach to identity and access management. It requires a more continuous approach to validating authorization. “With AI agents, a continuous authorization model becomes increasingly important,” says Lindau. Access decisions are an ongoing process, he explains — an agent authorized an hour ago might not be authorized for a new request if policy requires a fresh authentication event.

As a result, the case for ephemeral access is growing. As Lindau also notes, “Each action should require its own token, scoped narrowly to that action and discarded when it’s done.” Broad, long-lived tokens have always been a bad idea, he adds, but in agent workflows with long call chains, the blast radius is much larger.

API Governance Within the Tool Layer

Considering how disastrous compromised agentic access can be, it’s no longer an option to rely on intuition to secure our APIs. Feig stresses the need to move API governance into the tool layer. “The most urgent priority for strong API governance is moving from soft controls to hard ones,” he says. Prompting an agent to behave a certain way only goes so far — the tool implementation itself must enforce the boundary, regardless of what the agent decides to do.

Feig adds that teams need “a centralized place to manage, monitor, and revoke agent access,” along with the ability to trace an agentic flow, including thoughts, actions, and information access. Today, he says, that information is usually spread across a dozen systems, and nobody has a complete picture.

Solomon describes a similar model at Lunar.dev, where every interaction runs through centralized enforcement layers rather than “distributed ad hoc controls.” APIs and tools are scoped to identities, policies apply at runtime, secrets stay hidden from users and agents, and a single audit trail captures every interaction.

The New Emphasis Is on Runtime Governance

“The most urgent shift is moving governance from static API management to runtime governance of agentic systems,” says Solomon. Existing governance models assume deterministic consumers, he explains, but AI agents are adaptive systems, so governance must become context-aware, identity-aware, and real time.

It’s no longer enough to simply guard against attacks. According to Winterfeld, security teams that have spent years successfully blocking attacks now “need to shift to thinking about governing the traffic.” Organizations can lose revenue when they can’t tell a malicious scraper from a high-value automated partner. “Security can no longer be a wall,” he says. Instead, it must act as a smart filter that manages permissions based on behavioral analysis.

Observability and Runtime Monitoring

With so much traffic coming from AI agents, it’s increasingly important to be able to monitor what’s happening inside an API as well as where API calls are coming from. This is one of the reasons Merge built runtime observability into its tooling, as noted by Feig. “We also built logging for every action an agent takes, because teams kept telling us they had no idea what their agents were actually doing in production.”

Solomon also stresses what happens after execution, when “observability and audit trails become critical.” Organizations need to be able to reconstruct exactly how an agent arrived at a decision or action, including the prompts, tool calls, and downstream APIs involved.

Centralized API Lifecycle Governance

As with API governance, in general, it’s no longer good enough to make things up as you go along when you’re designing, deploying, and decommissioning an API. API lifecycle governance needs to be standardized if you want to make sure your APIs are secure. As Edgar Kussberg, Director of Product Manager for AI at Sonar, puts it, the OpenAPI Specification “isn’t just a best practice, it is the foundation for validating every new endpoint or schema change automatically.” Without transparent, machine-validated contracts between systems, he warns, AI agents will inevitably break integration logic.

He goes on to explain that AI-driven APIs are client-agnostic. Agents often need data in specific “shapes,” similar to GraphQL, along with robust server-side filters that weren’t previously a priority. Governance must keep these APIs “flexible yet strictly bounded,” says Kussberg, since they now provide “the raw intelligence for autonomous agents” rather than just serving buttons on a screen.

Reducing API and MCP Sprawl

API governance for agentic AI doesn’t just mean keeping track of an agent’s behavior. It’s equally important to keep track of an agent’s credentials, as unauthorized access to your API can have disastrous consequences. Feig calls the problem “credential sprawl.” Once teams start connecting agents to third-party apps, he explains, they quickly lose track of which apps an agent is connected to, what credentials it’s using, and where data is flowing.

Merge’s answer was to offer configurable bundles of connectors scoped to specific use cases, along with rules that define what data an agent can read and what actions it can take. Solomon points to another tactic from enterprises adopting MCP at scale: centrally cataloging MCP servers and risk-assessing them before they’re exposed to agents.

Kussberg describes how agents outpace manual oversight, providing further evidence of why monitoring AI agents matters when they’re accessing your APIs. Because agents can generate and consume APIs transiently, they create a dynamic surface that’s hard for humans to keep up with. The result is what he calls “visibility debt,” where the speed of agent-led discovery makes it difficult to track which endpoints are active or for what purpose. And since agents often interpret API documentation on the fly, governance must also account for non-deterministic behavior that can bypass static security policies or rate limits designed for human users.

Final Thoughts on API Governance in the Agentic Era

Agentic AI has raised the stakes in terms of the need for API governance. When speaking with the experts we consulted, a clear pattern emerged.

Governance is no longer a one-off event. API governance needs to happen across an agent’s entire runtime. Authorization is becoming increasingly granular, as well, no longer granted solely when accessing an API. Instead, API governance in the agentic era requires authorization for individual actions. API governance also helps give greater control when an agent accesses an API, taking command away from the prompt and giving it to the gateways and tools making the calls, instead.

Finally, the agentic era demands transparency. As Feig warns, “By the time something goes wrong, it’s too late to retrofit governance in. It has to be built into how agents connect to APIs from day one.” Organizations that treat API governance as core infrastructure instead of an afterthought will be the ones best able to let agents do real work safely.