For teams running AI agents against real APIs

Your agents shouldn't hold your API keys.

PhysicsBase gives each AI agent its own identity, keeps your Stripe, CRM and vendor keys in a vault the agent never sees, caps what every agent can do, logs every call with its reason, and lets you cut off any one of them instantly. You set the policy once; nobody approves each step.

Start free

Free, every feature included. Running in two minutes: paste one URL into your agent.

Watch the 60-second demo

Registered: 0
Tokens issued: 0
Rogue blocked: 0
Humans in the loop: 0

0humans needed at runtime
5 mintoken life, bound to the agent's key
0API secrets in your agents' hands
1 clickto cut off one agent or the whole fleet

The 60-second demo

Five levels. One leaked key, one runaway loop, one rogue agent.

See what goes wrong when agents hold your API keys, and how PhysicsBase handles each case without a person in the loop.

The problem

Most agents run on a pasted API key. Here's what that costs you.

Copying a key into an agent's settings is the quickest way to get it working. It's also why teams can't say which agent did what, or stop one without stopping all of them.

Ten agents, one shared key

When something goes wrong you can't tell which agent did it, and the only fix is rotating the key for every agent at once.

Each agent has its own identity. Revoke one; the rest keep working.
The secret lives in the agent

It sits in environment variables, prompts and logs. One prompt injection or one leaked log, and your Stripe key is out.

Keys stay in the vault. PhysicsBase adds them on the way out; the agent never sees them.
Nothing stops a runaway loop

A bug or a confused model can make thousands of calls before anyone notices, and you pay for every one.

Limits per agent, per minute and per day, stop it on their own and alert you.
No record of who did what

A customer asks why they were refunded twice. Your logs show one API key and no reason.

Every call is logged with the agent, the policy that allowed it and the reason it gave.

What you get

A control plane for the agents your company runs

You decide once what each agent may do. PhysicsBase gives every agent an identity and enforces that decision on every request, so nobody has to approve each step.

01
Identity

Every agent gets its own key and ID. No shared API keys, no borrowed passwords.

Know exactly which agent is calling.
02
Scoped access

A policy names the apps, actions and APIs each agent may use. Your Stripe, GitHub and vendor keys stay in the vault.

Agents can't do what you didn't allow.
03
Audit trail

Every registration, token and API call, tied to the agent, the policy that allowed it and the reason it gave. Alerts go to Slack or email.

Answer "which agent did this?" in seconds.
04
Kill switch

Revoke one agent, a whole fleet or one API connection. Rate and daily limits stop runaway loops on their own.

Stop a bad agent before it costs you.

Built for engineering and platform teams running AI agents in production: support bots, ops and finance automations, sales agents, coding agents and internal tools.

See it work

Five moments where it matters

Each one plays out in seconds, with no person in the loop. Pick a case or let them run.

support-bot-41 · live

Step 1

An agent asks PhysicsBase to call Stripe.

Without PhysicsBase
With PhysicsBase

Three ways an agent gets an identity. Two never involve a person.

Independent

The agent generates a key and registers itself. It becomes its own user: apps that allow it let the agent sign up like anyone else, minus the forms and CAPTCHAs.

$ physicsbase-agent register
✓ agt_9fK2 · acting for: self

Enrolled fleet

You create one enrollment key with a policy: apps, actions, lifetime, how many agents. Every agent started with it registers on first run and works for you inside that policy.

env PHYSICSBASE_ENROLLMENT_KEY=pbk_…
✓ 500 agents registered themselves

Linked to a person optional

When an agent must act as one specific consumer, that person approves it once. After that it runs unattended like the others.

$ physicsbase-agent link
✓ acting for amina@example.com

Guardrails instead of gatekeepers

How PhysicsBase keeps agents inside the policy while they work unattended. Nothing waits on an approval prompt.

Key-bound tokens
Every request is signed by the agent's private key. A copied token is useless.
Five-minute lifetime
Tokens expire fast and renew silently, so a revoked agent is out within minutes.
Scoped by policy
Agents only get the actions and APIs the policy names. Everything else is refused.
Credential vault
Store your Stripe, GitHub or vendor keys once. Agents call those APIs through PhysicsBase and never see a secret.
Signed for the open web
Outgoing calls carry Web Bot Auth signatures, so sites and CDNs can verify your agents instead of blocking them.
Rate and daily limits
Cap each agent per minute and per day. A runaway loop hits the ceiling, not your bill.
Kill switch
Cut off one agent, a whole fleet, or one API connection. It takes effect within minutes.
Audit trail and alerts
Every registration, token, API call and limit hit, with the agent and the reason it gave. Searchable, exportable, and sent to Slack or email as it happens.
Built for teams
Organisations with owners, admins and viewers. Agents act for the company, not for whoever set them up.

What an agent carries

Select a line of a real agent token to see what it does.

Bound to one key

The token names the agent's key. Each request must be signed by that key, for that exact method and URL. Copy the token without the key and it's worthless.

access_token, decoded

{
  ,
  ,
  ,
  ,
  ,
  ,
  ,
  
}

For the agent: one URL. For the app: one check.

Agents connect with nothing installed: an MCP URL or a URL prefix, plus an enrollment key. Teams that want agents to keep their own keys use the SDKs or the local gateway instead. Your API verifies people and agents with the same call.

Nothing to install: hosted MCP at /mcp and a proxy at /proxy/<any URL>
Works as a Claude.ai, Claude Desktop or ChatGPT connector: paste the URL, sign in, approve
SDKs for Node and Python agents, and an OpenAPI spec for the rest
MCP: protect your MCP server, connect agents with no browser
Any other API through the vault, with no change on their side
Open standards: OAuth, DPoP, Ed25519, passkeys
Two-minute setup for Claude Code, Claude Desktop, Cursor, LangChain and the OpenAI Agents SDK

import { PhysicsBase } from 'physicsbase-site';

const pb = new PhysicsBase({ issuer, clientId, appUrl, secret,
  scopes: { 'tickets:read': 'Read tickets',
            'tickets:write': 'Reply to tickets' } });

app.use(pb.middleware());

app.post('/api/tickets/:id/reply', (req, res) => {
  const who = pb.require(req.physicsbase, 'tickets:write');
  // who.isAgent, who.agent.name, who.isIndependent
});

// Any language, no SDK: put the PhysicsBase prefix in front of the URL.
const res = await fetch('https://www.physicsbase.ai/proxy/https://crm.example.com/api/tickets', {
  headers: {
    Authorization: `Bearer ${process.env.PHYSICSBASE_KEY}`,  // pbk_…
    'X-PhysicsBase-Agent': 'support-bot-41',
    'X-PhysicsBase-Reason': 'Triage new tickets',
  },
});
// The agent registers itself on first call; every call is checked,
// limited and logged under its own identity.

// Nothing to install. Cursor, Claude Code, the OpenAI Agents SDK, any MCP client:
{
  "mcpServers": {
    "physicsbase": {
      "url": "https://www.physicsbase.ai/mcp",
      "headers": { "Authorization": "Bearer pbk_…",
                   "X-PhysicsBase-Agent": "support-bot-1" }
    }
  }
}

# or plain HTTP, from any language or tool:
curl -H "Authorization: Bearer pbk_…" \
     https://www.physicsbase.ai/proxy/https://api.stripe.com/v1/charges

# Stripe has never heard of PhysicsBase. It doesn't need to.
# Dashboard → Connections: api.stripe.com, bearer sk_live_…
curl -X POST https://www.physicsbase.ai/proxy/https://api.stripe.com/v1/refunds \
  -H "Authorization: Bearer pbk_…" \
  -H "X-PhysicsBase-Reason: Refund order 8812" \
  -d charge=ch_123
# The vault adds the key, signs the call with Web Bot Auth,
# checks this agent's limits and logs it. The agent never sees sk_live_…

How agents get in today, and with PhysicsBase

Question	Forms and CAPTCHAs	API keys	OAuth	PhysicsBase
Agent can sign up by itself	Blocked	A person makes the key	A person clicks Allow	Yes
No human at runtime	No	Yes	Until consent expires	Yes
A stolen credential is useless	No	No	No	Yes, bound to the agent's key
Scoped and short-lived	No	Rarely	Yes	Yes, five minutes
App knows it's an agent, and which	No	No	Rarely	On every request
Agent never holds the API secret	No	It sits in the agent's env	Refresh token does	Yes, kept in the vault
Per-agent rate and daily limits	No	Per key, shared	No	Yes
Audit trail per agent	No	No	Per app	Every call
Revoke one agent or a whole fleet	No	Rotate and redeploy	Per app	One click

Why PhysicsBase

Weeks of security work you don't have to do

Why not build it yourself?

You could. It means encrypted key storage, signing every outgoing call, blocking requests to your internal network, per-agent limits, OAuth for MCP clients, an audit log and a kill switch that takes effect at once. Each piece is easy to get subtly wrong, and none of it is the product you're building.

PhysicsBase does all of it, tested, for free. Point your agents at it today and keep your engineers on your product.

Who it's for

Teams with more than one agent calling paid or sensitive APIs: payments, CRM, support, email
Fintech and support automation, where one agent mistake costs money or a customer's trust
Anyone connecting Claude, ChatGPT or Cursor to company tools who wants limits and a record
Companies that have to answer "which agent did this, and why?" to a customer or an auditor

Fair questions

Why would I trust you with my API keys?

Because today they sit inside your agents, which is riskier. In PhysicsBase each key is encrypted with AES-256-GCM, the encryption key is kept apart from the database, and no agent ever receives it: PhysicsBase adds it to the request on the way out. Calls to private and internal network addresses are refused. You can rotate or remove a key at any time, every use is logged, and you can export or delete all of your organisation's data whenever you like. How we protect your keys.

Does it slow my agents down?

Calls through the vault take one extra network hop through PhysicsBase. For agents that spend seconds thinking between calls, that rarely matters.

How is this different from Okta, Auth0 or an API gateway?

Identity providers manage people and their logins. API gateways protect APIs you run yourself. PhysicsBase sits on the agent's side: it gives each agent an identity, holds the keys to other companies' APIs, and enforces your limits on every call those agents make, to Stripe, your CRM or any other API. It works alongside the tools you already have.

What happens if PhysicsBase is down?

Calls through it stop rather than going out unchecked: an agent can't skip its limits because PhysicsBase didn't answer. We check the service from outside around the clock and are alerted automatically when anything fails.

Is it really free?

Yes. Every feature, up to 25 active agents and 100,000 requests a month per organisation, no card. Paid plans for very large fleets will come later, and nothing you set up now will need to change. Need more today? Talk to us.

Pricing

Free. Every feature, no card.

Use PhysicsBase for real work and see what it does for you before you ever pay. Paid plans for very large fleets will come later, and nothing you set up now will need to change.

Hosted free

Every feature: identity, vault, limits, audit trail, alerts, kill switch, teams
Up to 25 active agents and 100,000 requests a month per organisation
Running in two minutes: paste one URL and a key into your agent, nothing to install

Start free

Bigger fleets talk to us

Custom

More than 25 agents or 100,000 requests a month
Help connecting your agents and APIs, and a direct line to the team
Higher limits while we're in early access, at no charge

Get in touch

Take the keys out of your agents.

Start free Read the docs

Your agents shouldn't hold your API keys.

Five levels. One leaked key, one runaway loop, one rogue agent.

Most agents run on a pasted API key. Here's what that costs you.

Ten agents, one shared key

The secret lives in the agent

Nothing stops a runaway loop

No record of who did what

A control plane for the agents your company runs

Identity

Scoped access

Audit trail

Kill switch