There is a pattern in how categories of infrastructure get born, and it is unusually consistent across decades.
It does not start with a manifesto. It does not start with a name. It starts with a problem that a thousand teams are quietly hitting at the same time, building their own answers to in their own corners, mostly badly, mostly without realizing that everyone else is doing the same thing for the same reason.
For a while, the answers are private. Each team thinks they have built something specific to their situation. They have a few hundred lines of code in a folder nobody loves. It works. They move on.
Then someone notices the pattern. They write the article. They give it a name. The name catches on. Within a few years, the layer that nobody had been talking about becomes a category that everybody has, and the version each company built privately gets quietly retired in favor of something built to be infrastructure from the start.
This has happened with load balancers, with API gateways, with identity providers, with object storage, with feature flags, with payment processors, with secret managers, with observability platforms, with vector databases, with a dozen other categories that now feel obvious and once felt like nothing in particular.
It is happening right now, very fast, with the layer that sits between AI agents and the systems they act in.
The pattern of quiet categories
The categories that get the loudest reception at launch are usually not the ones that end up mattering most. The ones that quietly become indispensable share a few properties.
They sit between two things that already exist and didn't have a clean way to talk to each other. Load balancers sat between users and a fleet of servers. API gateways sat between clients and a portfolio of backend services. Identity sat between users and the multiplying number of applications they had to log into. None of these layers introduced a fundamentally new capability. They introduced an organizing principle for capabilities that were already there.
They become valuable because of what they remove, not what they add. A good API gateway is valuable because every backend service stops having to implement its own auth, its own rate limiting, its own tracing, its own request shaping. The gateway absorbs work that used to be duplicated everywhere, and the system above it becomes cleaner in proportion.
They are easier to build the second time than the first. The first version is always specific. The first identity service was hand-rolled per company. The fifth one was a product. The hundredth one was a category. By the time the category exists, building it yourself is a strategic mistake - not because you can't, but because the value of the layer is in being shared with the rest of the ecosystem that uses it.
They are usually invisible. Nobody at a normal company has strong feelings about which load balancer is in front of their stack. The point of the layer is that the team above it doesn't have to think about it. When a layer is doing its job, it disappears. That is the goal, and it is also the property that makes the layer hard to sell early - because invisible doesn't pitch.
The layer between agents and the systems they act in checks every one of these boxes.
The mature shape of this layer
Take the long view for a moment. Forget the current moment. Imagine a world a few years from now, in which agentic features are not a novelty but a default. Every customer-facing product has at least one. Every internal workflow has several. The companies running them have stopped building new ones from scratch every quarter; they're operating the ones they have.
What does the architecture look like, in that world?
The agents themselves are not particularly impressive infrastructure. They are reasoning loops, mostly, sitting in containers, talking to models that they may or may not own. There are many of them. They are cheap to spin up. They come and go.
The systems they act in are the same systems we already have. Salesforce. Stripe. GitHub. Workday. Hundreds of internal services. None of them were designed for agents. None of them are going to be replaced because agents exist.
Between the agents and the systems is a layer. That layer has one address. Every agent in the company calls into it. It knows which agent is calling and on whose behalf. It knows what each agent is allowed to do. It evaluates the action. It pauses for approvals when policy requires. It executes against the right system using credentials the agent never sees. It records the entire chain - intent, decision, evaluation, approval, execution, response - as a single immutable record. It exposes that record to anyone who has reason to ask: the operator, the security team, the regulator, the customer.
Adding a new agent means giving it credentials to talk to the layer. Adding a new system means configuring the layer to talk to it. Changing what agents are allowed to do means changing policy in one place. Reviewing what happened means reading from one ledger.
This is not a controversial picture. Anyone who has run serious systems before will recognize it as the shape that infrastructure tends to settle into when the load gets high enough. Centralized at the boundary, distributed above and below, governed at one choke point so the rest of the system can be loose.
The only question is who builds this layer for the people who run those systems. The current answer, almost everywhere, is "they build it themselves." That answer is not going to age well, for the same reason that "we built our own load balancer" stopped being an answer twenty years ago.
Why now
The reason this layer is becoming a category right now, and not in two years, and not five years ago, is a confluence of things that happened in a short window.
Models got good enough to make tool use reliable. This was not true even three years ago. Tool calls were a research curiosity. Today, tool use is the default mode of every serious agent. Once tool use is reliable, the question of what tool, called how, against what system, with what authority becomes the dominant question.
Real teams started shipping real agentic features into real production systems. Not demos. Not toys. Features that customers depend on, that move money, that touch records, that have consequences. Once the consequences are real, the boundary becomes real.
The first wave of "we just gave the agent the API keys" deployments started producing the first wave of incidents. Quiet ones, mostly. Wrong actions caught by humans before they propagated. Audit requests that nobody could fulfill. Compliance teams asking questions that engineering couldn't answer. The pattern is visible to anyone paying attention.
And the people who build infrastructure for a living - the ones who have seen this pattern in previous waves of computing - started recognizing the shape of what was missing. The layer is not exotic. It is the same kind of layer that every previous era of distributed systems eventually grew. It just hasn't grown yet.
What we're building, in plain language
Formael is the bet that this layer is real, that it is the same layer for everyone who needs it, and that building it properly the first time is more useful than letting every company build it badly in private.
We are not building a model. We are not building an agent framework. We are not trying to be the place where you design your AI features. We are the place between your AI features and the rest of your stack - the place where intent becomes consequence, the place where governance is enforced, the place where the audit trail is written.
It is a deliberately narrow product. It is meant to be. The point of infrastructure is to do one thing reliably enough that the things above it can stop thinking about it. The categories that win are usually the ones that resist the temptation to grow into adjacent problems and stay disciplined about being the boundary, the directory, the gateway, the ledger.
We are very early. We are working with a small number of design partners who are running real agents in real production. We are shipping the layer they need, in the open, in conversations with the people building on top of it. We expect to be doing this for a long time, because infrastructure is a long game and the categories that matter are not built in a quarter.
If the framing here resonates - if you are running agents and you have started to feel the absence of this layer - we would like to talk.
The layer is going to exist. The interesting question is whether you are building it from scratch or adopting it. We are working hard to make the second option the obvious one.