AI Engineer Europe 2026
Platforms for Humans and Machines: Engineering for the Age of Agents — Juan Herreros Elorza
Loading slides…
Read the talk
Platforms for Humans and Machines
A coding agent cannot fix a deployment process that depends on knowing whom to ask. Self-service APIs, local feedback and observable success make platforms usable by both people and machines.
From a talk by Juan Herreros Elorza
Before you start: Familiarity with deployment pipelines, APIs and basic application observability will help you follow the platform design choices.
How does finished code become a running system?
How does a developer get an application running when deployment, infrastructure and operational knowledge sit outside the application code? At Banking Circle, that problem spans client APIs, core banking, internal tools, data systems and payment infrastructure. Juan Herreros Elorza introduces himself as the lead of its cloud-native technology team. The company provides cross-border payments, accounts and liquidity management. Juan reports that Banking Circle processes over €1 trillion annually and provides banking services to over 700 regulated financial institutions. These are company-scale figures, also reflected in its payments-bank brochure, rather than measurements of platform performance.
Juan reports that more than 250 people at Banking Circle build technical systems. Their responsibilities extend from client-facing APIs and core banking to internal tools, data science, data engineering and integrations with the clearing schemes that settle payments. The platform team's purpose is to abstract infrastructure and cloud concerns so those teams can concentrate on their systems.
That platform is Atlas, organized into several capabilities:
| Capability | What teams use it for |
|---|---|
| Compute | Running applications on Kubernetes |
| Infrastructure | Provisioning blob storage, databases and secret management |
| Messaging | Connecting applications and systems |
| Observability | Understanding applications and payment processing |
Providing these capabilities is only part of the work. The developer also needs a usable route through them.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The application is ready; the deployment is not
Juan illustrates the problem with fictional characters drawn from his experience at Banking Circle. A new developer joins a team and writes an application, perhaps for a payment system. The application code is ready. Then the developer reaches the boundary of what they know: where and how should it run?
A teammate points to an existing deployment pipeline and suggests copying it. The developer does so, adjusts it for the new application's requirements and runs it. The pipeline fails, but the error concerns something outside the application they wrote. The teammate's next suggestion is to contact someone in infrastructure. That colleague recognizes a recurring error and fixes it.
The deployment now succeeds, only to reveal another dependency: the application also needs a database or blob storage. The developer returns to the infrastructure colleague, who is willing to help but occupied with other work. Provisioning will have to wait until next week. Completing the application has led to a sequence of copied configuration, unexplained failures, personal referrals and another queue. Whatever documentation exists is supplemented by knowing whom to ask.
A human can sometimes navigate that process by walking to another floor and finding the right person. A coding agent ordinarily cannot. An agent might communicate through Teams or a voice model, but that is not a dependable assumption for a coding workflow. The same gaps that frustrate developers therefore become hard limits on what their agents can accomplish. Agents expose existing platform weaknesses. Human handoffs and delayed discovery of pipeline problems were already costly before agents arrived.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Make the whole operation self-service
Self-service means completing the operation without depending on a particular person. If a developer needs a platform resource, they should be able to request it themselves; an agent should have the same route. Automation alone does not make that route usable. Fetching building blocks from five different places, assembling them and triggering a separate flow leaves the caller responsible for discovering the process. The easier and more intuitive the complete operation is, the more effectively it becomes self-service.
Self-service can take the form of a message or a button, but a well-defined API provides a useful foundation for agents. A CLI can wrap it, as can a Model Context Protocol tool interface. Those interfaces give callers ways to discover operations and their available options without reconstructing the workflow from someone else's pipeline.
Schema validation checks whether a request has the expected structure; it does not establish that the request will succeed or achieve the task. Authentication and authorization govern who can perform an operation. Depending on the workflow, the agent might act with the developer's credentials or use its own identity. With those boundaries in place, the API's responses become feedback: the agent attempts an operation, examines the response and uses that result to decide its next action.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Move feedback into the agent's working loop
In the setup Juan describes, the agent works on the developer's machine while the model runs elsewhere. Server-hosted agents, including setups using OpenClaw, are another possibility. The platform should make operations accessible from the environment where the agent does its work. For the local case, that means letting the agent validate and act from the machine it already uses.
Fail as early as possible. Requiring an agent to push a change to version control and wait several minutes for a workflow failure delays information it could have used immediately. Where checks can run up front, expose them locally through the API or a wrapper. The agent can then make a change, validate it and revise it without repeatedly crossing a remote pipeline boundary. A clearly defined desired result gives that iteration a direction.
Direction alone is insufficient: the task also needs a completion condition. A developer may verify deployment by inspecting the application and checking a metrics dashboard. An agent needs access to the underlying evidence. Expose logs, metrics and traces through an API, CLI or MCP server so that success does not depend on visually reading a dashboard. The loop can then cover the whole task:
- Read the requested outcome and its success criteria.
- Perform the operation through the platform interface.
- Retrieve the application state and operational evidence.
- Compare that evidence with the criteria before declaring completion.
A successful deployment request and a correctly running application are different observations. The platform needs to make both accessible.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Put instructions where the agent can find them
Documentation that exists but cannot be found does little to remove a dependency on colleagues. Its placement should match its scope:
- Small repositories: Keep documentation beside the code it explains, so an agent working in that repository can discover both together.
- Larger systems and shared platforms: Provide a central place where an agent can discover the available documentation.
- Retrieval: Make relevant pieces available through an API, avoiding the need to load an entire HTML page and extract the useful parts.
These choices address both discovery and the amount of unrelated material the agent must process.
Agent-specific instructions add working conventions to that documentation. Juan names AGENTS.md, CLAUDE.md and copilot-instructions.md, depending on the agent in use. A repository can specify how to build, test, deploy and verify the result. For the deployment problem above, a concise Markdown instruction could make the completion requirement explicit:
markdown
# Deployment workflow
Before deploying, read the platform documentation and identify all
required resources, including databases and blob storage.
Run the available local validation checks before pushing changes.
Resolve validation failures before requesting deployment.
After deployment, retrieve application state, logs and metrics through
the platform interface. Check them against the task's success criteria.
Do not treat acceptance of a deployment request as proof of completion.
The important content is the working procedure and its verification step, rather than merely a description of what the repository contains.
General guidance can be supplemented with project- or repository-specific AGENTS.md instructions. Skills capture conventions for a particular kind of task—for example, how to interact with a platform—so the agent can apply the relevant procedure when that task arises. Repository instructions establish the working context; task-specific guidance explains how to carry out a recurring operation.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Welcome contributions without handing off responsibility
An internal platform serves developers who can also help improve it. Juan reports seeing greater willingness to contribute as agents lower the entry barrier. That can help the platform gain features its users need, but it does not transfer maintenance responsibility away from the owning team. Security, compliance and consistent engineering standards still have to hold across contributions.
Use two complementary mechanisms:
| Mechanism | Responsibility |
|---|---|
| Enforced policies | Prevent outcomes that must not occur |
AGENTS.md and skills | Explain conventions and the intended contribution process |
Instructions guide behavior; policies enforce boundaries. Give contributors' agents enough context to work in the preferred way, while placing non-negotiable constraints in systems that enforce them. That combination supports participation without making the platform's safety depend on an agent following every instruction.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Measure the outcome the platform was meant to improve
Once developers and agents can use the platform, the next question is whether the changes helped. Choose the intended outcome and compare it before and after the intervention. An API, a documentation portal or an agent workflow is an implementation choice; its existence does not by itself establish an improvement.
For application delivery, Juan points to DORA, recalling change frequency, mean time to recovery and lead time, while leaving the fourth traditional metric unnamed. The traditional terms are deployment frequency, lead time for changes, mean time to recovery and change failure rate. The current DORA guide uses five metrics: deployment frequency, change lead time, failed deployment recovery time, change fail rate and deployment rework rate. This distinction matters when defining a measurement program: broad recovery time and recovery from a failed deployment are not interchangeable.
Delivery is not the only useful lens:
- Reliability: Examine application errors and traffic behavior. This is particularly consequential in a fintech environment.
- Platform support: Track support requests. Effective self-service may reduce them; a confusing implementation may increase them.
- Developer experience: Use a framework such as SPACE to consider satisfaction alongside other dimensions of productivity, rather than reducing the assessment to one number.
Juan supplies no measured before-and-after improvement. The practical requirement is to decide what making the platform easier for agents should accomplish, then measure that outcome.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Use interest in AI to fund the missing foundations
These practices form a starting point for platform work, not an exhaustive specification. Self-service and APIs give the agent a route to act; local feedback, documentation and observability give it a route to complete the task and verify the result. Contributions can extend that platform, while measurement tests whether the work is helping its users.
The final obstacle may be organizational rather than technical. API-first interfaces, locally accessible workflows and proper documentation may have lost priority even when teams already understood their value. Interest in AI—from executives to individual contributors—creates a reason to revisit those decisions. Use that attention to secure investment in the foundations that were missing all along. The work that lets an agent finish a deployment also removes the referrals, unexplained failures and waiting that blocked the developer.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Definitions and practical guidance for measuring delivery throughput and instability using DORA’s five-metric model.
The February 2021 paper introducing a multidimensional approach to developer productivity.
Examples and conventions for giving coding agents repository-specific build, test, and contribution instructions.
The 2025-11-25 protocol version’s tool discovery, invocation, schemas, error handling, and security requirements.
A personal AI assistant connecting models, tools, and messaging channels through a Gateway.
Further reading
Juan’s slides summarize Atlas, platform design recommendations, and outcome measurement.
Defines SKILL.md metadata and instructions, with optional supporting scripts, references, and assets.
Full transcript
Loading transcript…