APIs for Agents: Rethinking API Programs in the MCP Era

Main Topics Discussed:

• Introduction to MCP: The session began with an introduction to the Model Context Protocol (MCP), a new protocol for enabling interactions between tools and data. MCP caters to LLM-based applications, differing from traditional APIs by focusing on structured operations and parameterized instructions that guide behavior.
• Calm Architecture: The speakers explored the use of Calm architecture paired with other protocols for seamless and accelerated development processes. This involves using architecture as code to deploy services across the platform at Morgan Stanley.
• Governance and Controls: Emphasis was placed on establishing robust governance and control systems. This includes building self-service guardrails to aid teams in moving quickly, and implementing codified architectural patterns to maintain security and automate compliance checks.
• Scalability and Innovation: The presentation covered strategies for scaling platforms effectively while limiting fragmentation and manual coordination. This approach ensures measurable security outcomes across large API estates.
• Agent to Agent Interaction (A2A): The session also touched on the evolution towards agent-to-agent interactions, highlighting the shift away from tool-centric designs to more autonomous systems capable of collaborative task execution.

Key Outcomes:

• Attendees learned practical approaches to modernize governance for agent-driven consumption without causing bureaucratic slowdowns.
• The talk provided actionable insights into employing platform capabilities combined with the FINOS Architecture as Code to enhance both speed and security in API programs.

Conclusion: The presentation emphasized the necessity for API programs to adapt to the evolving landscape where autonomous agents are the primary consumers. Adopting protocols like MCP and A2A offers substantial benefits but requires careful governance and innovation to realize their full potential.

This is the end of the AI-generated content.

As API programs mature, a familiar gap emerges: some teams operate with strong standards, reusable platforms, and clear governance,  while others rely on informal guidance and best-effort consistency. That disparity becomes a real risk at scale, even if it feels manageable when API consumers are known systems and human-built integrations.

The Model Context Protocol (MCP) changes the shape of the problem. APIs aren’t just consumed by human developers anymore — they’re consumed by tools and autonomous agents. That shift forces API programs to answer uncomfortable questions:

• What does an “API product” mean when the primary consumer is an agent?
• How do you introduce governance changes without slowing delivery to a crawl?
• How do you roll out fixes, evolving controls, and improvements across 200+ APIs without creating endless upgrade work for teams?

This talk explores how to evolve API programs for MCP-era workloads, using platform capabilities and FINOS Architecture as Code to improve both speed and security.

You’ll learn practical ways to:

• Build self-service guardrails that help teams move fast without turning governance into central gatekeeping.
• Codify architectural patterns to define and enforce security standards, automate compliance checks, detect drift, and roll out changes safely.
• Scale innovation reliably across large API estates — reducing fragmentation, limiting manual coordination, and keeping security outcomes measurable.
• Attendees will leave with practical patterns, examples, and an approach they can apply immediately to modernize governance for agent-driven consumption — without turning their API program into bureaucracy.