For a long time, APIs operated on a quiet assumption that humans sat somewhere in the loop. Developers read documentation, interpreted endpoint names, inferred meaning from examples, and compensated for unclear behavior. Ambiguity was manageable because people could compensate for it. Intent existed across documentation, shared knowledge, and engineering judgment.

That model breaks once APIs are consumed primarily by machines.

AI-driven clients depend on explicit signals. These include structured schemas, consistent semantics, and predictable behavior. When intent is underspecified, automation produces incorrect behavior that can be difficult to diagnose and expensive to correct.

This highlights a gap that has existed in API design for years. Many endpoints describe what they do, but provide limited guidance on when they should be used or under what conditions. Humans can navigate these gaps by interpreting context. Automated systems cannot. In agentic workflows, these gaps accumulate. API calls feed into other calls. Decisions are chained. Small misunderstandings propagate.

Teams are starting to treat intent as part of the API surface. Schemas are being expanded to communicate meaning. Contracts increasingly describe expectations, constraints, and acceptable usage patterns. This changes how APIs are governed and operated in practice. Policies can be applied based on declared purpose. Rate limits can reflect observed usage patterns. Observability improves because behavior can be evaluated against stated intent.

As AI agents plan and act autonomously, APIs become tools whose behavior must be discoverable and dependable. An underspecified API introduces uncertainty that compounds across decisions. Making intent explicit is what allows autonomy to scale without losing control. In an AI-driven environment, APIs function as instructions for machine-operated systems. Intent becomes part of the contract and is designed, versioned, and governed alongside other system boundaries.

As software systems become more automated and traffic patterns less predictable, observability is shifting from a developer convenience to a core operational requirement. That is why Austin Parker has become a reference point for teams trying to make observability work at scale. A long-time OpenTelemetry maintainer and Director of Open Source at Honeycomb, Parker focuses on how telemetry behaves in real production environments.

Rather than treating observability as instrumentation sprinkled across services, Parker frames it as infrastructure that needs ownership, consistency, and control. Much of his work emphasizes the OpenTelemetry Collector as a coordination layer, where configuration, routing, and policy decisions live centrally instead of being duplicated across teams. This approach reflects the reality of large systems, where drift and inconsistency create more blind spots than missing metrics.

In recent writing and community work, Parker has highlighted how automation and agent-driven workloads change observability requirements. Non-linear traffic, retries, and chained tool calls increase volume and variance, making ad hoc telemetry pipelines fragile. His focus has been on declarative configuration and standardized pipelines as a way to keep telemetry reliable as systems scale and automate.

Parkerʼs perspective stands out because it avoids promises of visibility through tooling alone. He consistently points out that observability fails when it is treated as an afterthought or left to individual teams to manage independently. As systems become more autonomous, Telemetry has to be governable and predictable, or it stops being useful when teams need it most.

Resources & Events

apidays Singapore brings together API builders, architects, and platform leaders in one of Asiaʼs biggest fintech and digital transformation hubs, with a strong focus on how APIs are evolving for the AI and agentic era. The program blends practical case studies and technical sessions across API management, security, governance, and automation. Details →

apidays New York is positioned as a high-density gathering for teams operating APIs at scale, with sessions spanning monetization, security, AI-driven automation, and platform governance. Itʼs built for senior practitioners and decision-makers, bringing together 1,500+ participants from 1,000+ companies, making it a strong anchor event for anyone tracking where enterprise API strategy is heading next. Details →

You can find a list of all Apidays events in 2026 here

LEAP is Tyk’s API-focused conference centered on how APIs are evolving in an AI-driven world. The 2026 edition emphasizes API governance, security, and control layers needed to support agentic systems, with practical sessions for platform teams managing scale, reliability, and policy enforcement across modern API stacks. Details→

Dynatrace surveyed 919 senior leaders and found that agentic AI is still early in execution, with around half of initiatives in proof of concept or pilot, and 26% of organizations running 11 or more projects. Most deployments still keep humans in the loop, with 69% of agentic decisions verified by humans, 87% building or deploying agents that require human supervision, and only 13% using fully autonomous agents. The report also notes spending momentum, with 74% expecting agentic AI budgets to increase over the next year. Read →

As vibe coding becomes embedded in day-to-day development, APIs are increasingly encountered through AI-driven trial and error. This shifts pressure onto platforms to behave predictably under exploratory use, where agents probe endpoints, retry calls, and move on quickly when behavior is unclear.

This session looks at how AI-assisted coding is changing what breaks first in development workflows. Speakers from Google and GitHub focus on how loosely defined prompts and implicit assumptions fail once AI systems are responsible for more of the implementation.

Stay tuned for bold ideas, fresh perspectives, and the next wave of API innovation

-The Apidays Team

Visit the Website