Your agents run in Frankfurt.So does everything they touch.
Keel runs the agent, the API behind it, the site in front of it and the database under it in one EU region, and records every model call and every tool call as a step you can open.
- eu-central-1, Frankfurt
- egress denied unless the host is on the list
- encrypted at rest in Frankfurt
- every step recorded
Why this exists
An agent is not a web app.
A web request lasts 200 milliseconds and touches one database. An agent run lasts minutes or hours. It calls a model, reads your ERP, writes to your database, and then acts on what it found.
A generic host gives you two things for that. Stdout, and an open internet.
So when a run breaks at two in the morning you read your own log lines and guess. And when someone asks where the customer data went, the honest answer is that the container could reach anything, and nothing kept a record of what it reached.
Running that outside Europe is not illegal. It is work, and it is your work. Assess the transfer, write down the measures that make it safe, defend the assessment when it is reviewed, and start again when the ground moves. For an agent there is no clever measure to write down, because the platform has to read the data in the clear to run the thing at all. Encryption protects data from everyone except the machine doing the work.
Which is why so many European teams keep their agents on a laptop, in a cron job, in a prototype that never ships.
Put the agent in Frankfurt and both questions get an answer from the infrastructure instead of from you.
What you get
Three things a generic host does not do.
The trace
Every model call and every tool call is a step with its request, its response and its duration. The gateway records it from the traffic itself, so the step exists whether or not your code logged anything.
Open a failed runThe boundary
A container starts with no route out. Traffic leaves only to hosts on the list. An IP literal, a port other than 443 and any other hostname are closed at the network, and the refusal is written into the trace as a step.
See where the boundary sitsThe whole stack
The agent, the API it calls, the site in front of it and the Postgres under it run on the same platform, in the same region, under the same egress policy, on one bill in euros.
Walk through the four
The run trace
Two in the morning, the run failed, and this is the screen.
The ERP session expired and answered with its sign-in page, carrying a 200. A container host tells you the process exited. Keel tells you which step, what came back, and what the model would have read next.
- agent
- invoice-reconciler
- revision
- rev_01J9WZ
- trigger
- schedule · every 15m
- error
- tool_output_invalid
01model1.84sokbedrock.eu / anthropic.claude-sonnet1204→96 tok
input
system: You reconcile open invoices against ERP records. user: Reconcile invoices created since 2026-09-16T02:00:00Z.
output
tool_use: erp.list_open_invoices
{ "since": "2026-09-16T02:00:00Z", "limit": 50 }02tool412msokerp.list_open_invoices200
input
GET https://erp.internal.example/api/invoices?since=2026-09-16T02:00:00Z&limit=50 authorization: Bearer ****
output
{ "invoices": [ { "id": "inv_4471", "total": 1290.00, "currency": "EUR" }, … 11 more ] }03model2.21sokbedrock.eu / anthropic.claude-sonnet2876→71 tok
input
tool_result: erp.list_open_invoices → 12 invoices
output
tool_use: erp.get_invoice
{ "id": "inv_4471" }04tool1.29sfailederp.get_invoice200
Response was text/html, expected application/json. The ERP session expired and returned its sign-in page with a 200.
input
GET https://erp.internal.example/api/invoices/inv_4471 authorization: Bearer ****
output
<!doctype html> <html lang="en"> <head><title>Sign in · ERP</title></head> <body><form action="/login" method="post">…
05error3msfailedrun failed
input
classification: tool_output_invalid step: 4 policy: fail_fast
output
Callback queued → https://app.example.com/hooks/keel (delivery dlv_01J9X4N)
Step 04 is why this run failed. Expand it to see exactly what the tool returned and what the model would have received.
The supervisor redacts every payload before it leaves the container, and what is stored is encrypted with your organization's key.
Residency
Where the data goes, and what stops it leaving.
Residency is a property of the network, not a sentence in a policy document. Four mechanisms hold it up.
eu-central-1, Frankfurt
- agent run
- api service
- static site
- postgres
- valkey
- logs
- trace payloads
- backups
egress gateway
The only route out. It reads the hostname from the TLS handshake before it forwards anything.
Allowed
A model endpoint on the verified list
Inspected and recorded as a model step, with the request and the response kept.
Allowed, and yours
A host you listed in keel.yaml
Recorded as a tool step. A host you add is outside the residency guarantee, and the dashboard says so.
Denied
Every other hostname, IP literals, any port but 443
The connection is closed before a byte is forwarded and an error step is written into the trace.
One region
Compute, databases, backups, logs, traces and build artifacts are created in eu-central-1 and nowhere else. There is no second region to fail over to, which is the point.
One door
Outbound traffic from a container reaches the internet only through the egress gateway. It reads the hostname out of the TLS handshake and matches it against the policy before a single byte is forwarded.
A list, not a promise
The verified endpoint list is versioned data with the evidence recorded for each entry, and an agent pins the version it was deployed against, so the boundary cannot move underneath a running agent.
Encrypted where it sits
Trace payloads and the rest of your data at rest are encrypted with a KMS key held in the same region. Per-organization keys, one per tenant, land with the multi-region layout and are not in place yet.
A host you add yourself is outside that guarantee, and the dashboard says so where you add it, though every connection to one is still a step in the trace.
One platform
Four kinds of thing. One region, one CLI, one bill.
Your app does not have to move for the agent to move. When it does, the rest of the stack has somewhere to land.
Agents
On a schedule, on a webhook, or always on.
Every model call and tool call is recorded by the gateway, so the step is there whether or not your code logged it.
keel run invoice-reconciler --followIncluded in every plan
Services and APIs
Always-on containers with public HTTPS.
A new revision is rolled out one replica at a time, and a replica that fails its health check is replaced while the others keep serving.
keel deployAgents and bots 49 EUR, app services 19 EUR per replica-month
Static sites
Your frontend, served from Frankfurt on your own domain.
Every deployment is immutable, so rolling back switches a pointer and the previous bytes come back exactly as they were.
keel sites deploy ./distIncluded on Business and Enterprise
Databases
Managed Postgres and Valkey, one command each.
Neither has a public port. They answer only on the internal agent network, which is why database traffic never touches the egress gateway.
keel db create mainPostgres 19 EUR, Valkey 9 EUR per month
How a deploy feels
From an empty directory to your own domain.
Three commands, and the same three for an agent, an API or a site. The session beside them adds a database, because that is usually the next thing you need. Nothing to click through, no console, no region to pick.
keel initDescribe the app
Pick a template or let Keel read the project. It writes a keel.yaml naming the app, its resources, its secrets and the hosts it may talk to.
keel deployBuild and ship
The image is built in Frankfurt, a revision is created, and the service answers on its platform hostname with egress locked to the allowlist. A project without a Dockerfile gets one generated for the build.
keel domains add api.example.comPut it on your domain
Create the TXT and CNAME records the command prints. The certificate is issued on the first request and renewed for you, and traffic moves over with no restart.
No Dockerfile, no problem.
A Node, Bun, Python or Go project without one is detected and a Dockerfile is rendered for the build. Run keel deploy --print-dockerfile to read it before it ships.
$ keel init --template api-node
Wrote keel.yaml, Dockerfile, .dockerignore, src/server.ts, package.json.
$ keel db create main
postgres main is ready. Secret DATABASE_URL written.
Reference DATABASE_URL under secrets: in keel.yaml, then keel deploy.
$ keel deploy
Building from ./Dockerfile … done in 41s
Revision rev_01JA2K is live: https://api-0a1b2c3d.svc.keelhosting.dev
Egress: deny-all, allowlist v12, 0 custom hosts
$ keel domains add api.example.com
TYPE NAME VALUE
TXT _keel-verify.api.example.com keel-domain-verification=3f9c…
CNAME api.example.com api-0a1b2c3d.svc.keelhosting.dev
$ keel domains verify api.example.com
api.example.com is active. Certificate issued on the first request.Pricing
Every price is on this page.
Three plans, annual terms, no hidden tier. Every plan runs in Frankfurt with the same egress policy and the same trace. Enterprise pays for the guarantee in writing, not for more compute.
Starter
490 EUR
per year, billed annually
A solo developer moving agents off a laptop or a generic host.
- 3 agents
- 5,000 runs and 10,000 run-minutes per month
- 15-minute maximum run duration
- No always-on services
- No managed databases
- No static sites or custom domains
- 7-day trace retention
- Frankfurt region
- Community support
Business
most teams4,990 EUR
per year, billed annually
A team running agents in production behind their own product.
- 15 agents
- 50,000 runs and 150,000 run-minutes per month
- 2-hour maximum run duration
- Agents and bots 49 EUR, app services 19 EUR per replica-month
- Managed Postgres 19 EUR and Valkey 9 EUR per month
- Static sites and custom domains included
- 30-day trace retention
- Tool connectors and outbound callbacks
- Email support
Enterprise
From 25,000 EUR
per year, invoiced
Organisations that need the residency guarantee in writing.
- Unlimited agents
- Long-running, checkpointed runs
- Agents and bots 49 EUR, app services 19 EUR per replica-month
- Managed Postgres 19 EUR and Valkey 9 EUR per month
- Static sites and custom domains included
- Signed data processing agreement
- Customer-managed encryption key
- SSO and audit log export
- Private network option and SLA
What the rest of the stack costs on top
Services, databases, sites and domains are priced per resource on Business and Enterprise, in euros, and there is no charge for egress.
- Agent or bot replica
- 49 EUR per replica-month
- An always-on AI agent or bot. Pro-rated by the hour a replica is up. Never consumes run minutes.
- App service replica
- 19 EUR per replica-month
- An API, a web app or a worker. Same platform, same rollout, pro-rated by the hour.
- Managed Postgres
- 19 EUR per month
- Backed up, connection string injected as a secret.
- Managed Valkey
- 9 EUR per month
- Redis-compatible cache and queue, same region as your services.
- Static site
- Included on Business and Enterprise
- Served from Frankfurt, certificates managed for you.
- Custom domain
- Included on Business and Enterprise
- For services and sites. One CNAME, automatic certificates.
Usage above the included allowance is metered on runs and run-minutes and settled separately. Always-on services are billed per replica-month, pro-rated by the hour a replica is up, and never consume run minutes: agents and bots 49 EUR per replica-month, app services 19 EUR per replica-month, set with service.kind in keel.yaml. Managed databases are billed per database-month, pro-rated the same way. Model tokens are not billed by Keel. You bring your own model credentials and pay your provider directly.
Next
not built yetThe Agent Builder will take the Dockerfile out of the loop.
Today you bring a repository or an image. The Agent Builder will let you describe the agent in the dashboard instead, walk through a short wizard, and finish with a URL you can call.
It is being built. There is no date and no price for it yet, and nothing else on this page waits on it.
- You will describe the agent in a wizard. No repository, no Dockerfile.
- You will bring your own model key. Keel will not resell tokens then either.
- You will get a URL you can call, plus Slack, schedule and webhook triggers.
- It will sit in the same region, behind the same egress allowlist, with the same per-step trace as everything above.
What we do not claim
The honest part of the page.
We hold no SOC 2 report and no ISO 27001 certificate. What this page offers instead is the mechanism, and we would rather you test the mechanism than trust a badge.
We publish no uptime figure, because we have not measured one over a period long enough to mean anything. Enterprise gets a service level agreement, and a contract is a commitment, not a measurement.
There are no customer logos here. Keel has not launched yet, and an invented logo would be the first thing on this page we made up.
A host you add to your own allowlist is outside the residency guarantee. The dashboard says so where you add it, and every connection to one is still a step in the trace.
The Agent Builder above does not exist yet. It carries no date and no price here because we do not have either, and nothing you would buy today depends on it.
Model tokens are not ours to bill. You bring your own credentials and pay your provider directly, which is why an allowlist, rather than custody of your keys, is what keeps the traffic inside the EU.
The longer list, with where your data lives, every company involved and the documents an EU buyer asks for, is on the trust page.
The boundary is built. The waitlist is open.
Waitlist
Starter and Business open in order of signup.
One email when your spot opens. Nothing else, and the address is stored in Frankfurt like everything else here.
Enterprise
Need it in writing? Talk to a person.
Data processing agreement, customer-managed key, SSO, audit log export, private networking. Send a note, or email enterprise@keel.example directly.