By Sabri Skhiri and Laetitia D.

Recently, our Engineer, Laetitia, and our CTO, Sabri, attended AGNTCON + MCPCon Europe 2026 in Amsterdam. Unlike many AI conferences that linger on theoretical possibilities, this event was resolutely practical. The focus was firmly on systems operating with real users, prioritizing reference architectures, and the production post-mortems over academic research.

For engineering leaders and middle managers, the primary takeaway is a paradigm shift: getting an AI agent to work initially is now the easy part. Today, the real challenge lies in packaging these agents, governing them securely, and maintaining code quality over time.

Because we are addressing a dual audience of business decision-makers and technical practitioners, this article deliberately focuses on the strategic takeaways. Find here a link to a more in-depth exploration for those seeking comprehensive technical coverage.

1. Rethinking the "Software Factory" and the Productivity Myth

The hype surrounding AI coding agents has reached a fever pitch, but empirical evidence presented at the conference demands a reality check. Insights from the SlopCodeBench research revealed a critical vulnerability: while AI agents excel at initial, well-bounded tasks, they consistently degrade code quality, structural integrity, and readability over time during long-horizon tasks.

This introduces a significant gap in our Continuous Integration/Continuous Deployment (CI/CD) pipelines. Traditional regression testing is designed for deterministic outcomes and human throughput; it does not translate well to non-deterministic AI outputs. Consequently, standard pass-rate testing can actively conceal underlying code failures, as an agent might pass every functional checkpoint while producing code that becomes progressively harder to maintain.

The actionable advice for managers is clear: the modern software factory requires a fundamental redesign. To "fight slop," engineering teams cannot simply rely on writing better AI prompts. Instead, they must deliberately introduce deterministic code (such as strict hooks, callbacks, and rigorous architectural gates) into non-deterministic flows. Moving forward, the critical question is no longer whether an AI agent can produce a code change, but whether the surrounding system can safely absorb that change without degrading.

2. The AI Control Plane: Governing What You Cannot Trust

As AI agents act autonomously, traditional security measures are proving inadequate. Simply placing an API gateway in front of an AI agent is insufficient for robust enterprise governance. A gateway might intercept tool calls, but it fails to answer what agents exist, what they have actually done, and what happens when they misbehave.

The solution is adopting an "AI Control Plane": a centralized layer of policy and configuration operating independently of the executing agents. This introduces a three-layer governance model:

• Curate: You must know exactly what agents and tools exist in your ecosystem. A registry of approved agents is the first step of governance, because you cannot govern what you cannot enumerate.
• Monitor: Implement real-time hooks and comprehensive audit logs to track exactly what an agent is actually doing, rather than just what it intended to do.
• Isolate: Limit system exposure through disposable sandboxes, network proxies, and secure credential stores, ensuring an agent never holds raw secrets.

Crucially, organizations must eliminate the "Robot Account." Using a single shared account for an AI agent is a massive security anti-pattern because it pools the permissions of every user behind one agent. Instead, access must be strictly scoped. Solutions presented at the conference, such as Zalando’s identity broker, demonstrate how to implement delegated authorization where effective access is the strict intersection of what the user may do and what the agent is allowed to do.

3. Architectural Shifts Your Tech Leads Are Navigating

The infrastructure supporting AI agents is rapidly maturing. Notably, the underlying technology enabling agents to interact with tools—the Model Context Protocol (MCP)—has recently gone "stateless." For a manager, this translates to a massive reduction in operational complexity and network traffic. Removing stateful sessions eliminates sticky routing issues, making it vastly easier and cheaper to scale AI infrastructure securely in the cloud.

When integrating these agents into internal systems, tech leads are currently navigating three distinct "doors" to tools:

• MCP Servers: The optimal choice when an AI agent needs to cross organizational boundaries or interact with separate back-end systems.
• WebMCP: A newer approach that runs directly within a user's browser tab. This leverages the user's existing authenticated session and security origin, reducing deployment and authorization overhead.
• CLI (Command Line Interface): Best suited for local developer workflows, utilizing the context of the working tree.

As teams rapidly deploy multi-agent workflows, they are experiencing a sense of distributed systems déjà vu. Synchronizing parallel agents, handling partial failures, and managing state are classic distributed computing problems. The reassuring news is that the answers largely already exist: traditional software engineering practices still apply, and agent frameworks are simply rediscovering them.

4. Conclusion & Next Steps for Tech Leaders

Implementing AI agents is no longer an experimentation phase; it is a serious infrastructure and governance challenge. The transition from proof-of-concept to production requires deliberate architectural planning and strict operational boundaries.

We encourage managers to audit their current AI initiatives by asking these critical questions:

1. Can we track and measure AI-driven code degradation?
2. Are we actively mitigating it?
3. Do we have a centralized, clear inventory of all active agents in our environment?
4. Are we inadvertently relying on unsafe shared credentials or "robot accounts"?
5. Can our workflows handle parallel agent synchronization failures?

Engineering leadership requires testing agent isolation and code durability before scaling production access. Should you wish to discuss those questions further, feel free to reach out to our team.