Boundary infrastructure for the agentic enterprise.
Formael is the governed execution layer between AI agents and the external systems they act in. One protocol. One audit trail. One place to decide what an autonomous system is allowed to do in the real world.
Why this exists
The moment AI stopped just talking.
For years, the interesting question was whether AI could understand a request. That question is largely answered. The interesting question now is what happens when AI is allowed to act on a request - to send the contract, to issue the refund, to provision the account, to update the deal.
The instant a model can reach into a production system, the problem changes shape. Reasoning becomes a side effect. A wrong sentence is embarrassing; a wrong action is operational. And every team building agents quickly discovers that the hard part is no longer the model - it is the boundary the model crosses to do anything that matters.
That boundary doesn’t exist as infrastructure today. It exists as glue: hand-written API clients, ad-hoc credential management, prompt-level guardrails, spreadsheets of approval rules, and the quiet hope that nothing ever goes wrong. Formael is the conviction that this layer deserves to be a first-class piece of infrastructure, the same way load balancers and API gateways became first-class in earlier eras of compute.
What we build
A single, opinionated outbound gateway.
Every agent action passes through one place. That place authenticates the agent, resolves what it’s actually trying to do, evaluates organizational policy against it, optionally pauses for a human, executes against the right external system using credentials the agent never sees, and records the entire chain as evidence.
The agent never holds keys. The agent never learns one provider’s API and gets stuck. The organization never has to wonder what happened or who approved it. Switching providers becomes a configuration change, not a code change. Adding governance becomes a conversation about policy, not a sprint of refactoring.
That is the entire product. Everything else - the connector catalog, the policy engine, the approval workflows, the analytics - is in service of that one idea.
What we believe
Four convictions the platform is built on.
01
Intent over implementation
An agent should reason about goals, not endpoints. The boundary translates intent into the right deterministic call against the right system.
02
Governance is a choke point, not a sprinkle
Policy that lives inside agent prompts is policy that can be talked out of. Real control needs a single, un-bypassable surface to evaluate every action.
03
Audit is a first-class output
Every action produces evidence - what was attempted, why it was approved, what was executed, what came back. Append-only by default.
04
Speed comes from constraint
A good gateway lets teams ship faster precisely because it removes choices: one credential model, one approval shape, one trace format.
Where we are
Early, by design.
Formael is in early access. We work directly with a small number of design partners who are already building real agentic features into real products and want a serious answer to governance, audit, and connectivity from day one.
That shape is intentional. Infrastructure earns trust by being used in anger, not by collecting logos. We’d rather ship the right primitives for a handful of teams that depend on us than the wrong abstractions for a market we don’t yet understand. Pricing, packaging, and roadmap are all shaped in public conversation with the people running it in production.
Where we’re headed
The boundary becomes bidirectional.
Outbound agency is the first surface that needs governing. It is not the only one. The same control plane extends naturally to inbound events and, eventually, agent-to-agent traffic across organizational boundaries.
Today
Agent → API
Agents submit intent. Formael evaluates policy, executes through the right connector, and writes the audit trail. The boundary is one-way and outbound.
Next
Agent ↔ Webhook
External systems push events back through the gateway. Inbound events get the same governance treatment before they reach an internal agent.
Later
Agent ↔ Agent
Organization A's agent talks to Organization B's gateway. Each side enforces its own policies. The intent envelope becomes a wire protocol for inter-agent commerce.
Get involved early.
If you are building agents that take real actions in production systems - or thinking carefully about how you will - we’d like to talk. Design partners get direct access to the team and meaningful influence on what we build next.
Early Access
Build the AI agents
you actually want to ship.
Join the Formael early access program. Get the boundary infrastructure your agent fleet needs - governed execution, immutable audit, and 34+ connectors - before you need to build it yourself.
Your Agent
Semantic intent envelope
Formael
Govern · Execute · Trace
External APIs
DocuSign · Jira · Slack…