Identity for the agents
that act on your behalf.
Arcane is the identity, authorization, and policy enforcement layer for AI agents. Let agents interact with real systems — APIs, SaaS, internal tools, MCP servers — without handing them unchecked access.
Agents are not users.
Agents are not service accounts.
A human clicks one action. A service account does one narrow job. An agent accepts an abstract task, plans steps, decides what tools to call, transforms parameters, and performs hundreds of delegated actions in a day on behalf of a single employee.
Traditional OAuth scopes and API keys tell you the ceiling of what is possible, not the safe subset of what should happen in a specific task.
One policy engine. Two paths to the resource. Every action explained.
A user delegates to an agent. The agent executes on a workload. Arcane binds all three, issues a short-lived token for the task, evaluates it against policy, and enforces the decision in-line.
Who is acting, through what agent, from what trusted environment.
A composite identity binds three independent layers into a single, verifiable authorization context — answering not just "who is asking?" but "who is asking, through what software, running where?"
Composite token scopes are the intersection of what each layer allows — not the union. All three must agree.
→ User U delegated to Agent A, executing on Workload W, against Resource R.
Short-lived. Scoped. Bound to the task.
The Security Token Service turns a composite identity into a credential an agent can actually use. It evaluates the delegation context and issues an Arcane Token carrying only the permissions policy grants — for this task, in this environment, right now.
Not a bearer token. It doesn't just say "this caller is authorized." It says "this caller is authorized to do these specific things, in this context, right now."
{
"iss": "sts.arcane",
"sub": "composite/u.olsen@acme|agent.pk-93f|pod.sre-prod-4",
"task": "reconcile-invoices-q3",
"scopes": ["jira.read:proj/FIN", "confluence.write:space/FIN-OPS"],
"constraints": { "net": "corp-vpn", "rate": 60 },
"exp": 1744209120 // ttl: 15m
}Declarative rules. Deterministic decisions.
The policy engine evaluates the Arcane Token's composite identity and task context against your rules — rules that draw on the user's role, the agent's trust tier, the workload's network zone, or attributes of the target resource itself.
# agents on the reconcile workflow may read Jira
# in FIN projects, from corporate network only.
allow {
input.agent.trust_tier >= 2
input.action == "jira.read"
startswith(input.resource.project, "FIN-")
input.workload.network == "corp-vpn"
}Two integration modes. One policy engine behind both.
Enforcement is where the decision becomes a fact. Arcane ships two modes so you can protect every system you run — not just the ones you can modify.
Embedded at the tool boundary
A drop-in library for MCP server developers. Extracts the Arcane Token from the request context, calls the policy engine, enforces the result — before the tool runs.
Transparent enforcement for the rest
For systems you cannot modify — third-party SaaS, legacy APIs, tools with no plugin model. The agent calls through Arcane; policy decides; the upstream never knows Arcane exists.
Every layer has to agree. That's the point.
No single identity layer covers every attack. Binding them gives you specific failure modes — so when something is wrong, the system can tell you which layer flagged it.
Every decision is logged, signed, and explainable.
Nothing reaches the resource without a policy decision and a signed audit entry. Dry-run policy against real traffic before you ship it. Version policies. Attribute every allow and every deny to the rule that made the call.
Cryptographically signed
Every allow, review, and deny records the composite identity, the task, the matching rule, and the outcome.
Dry-run against live traffic
Promote a new policy in shadow mode. Compare lanes against production. Ship only when the deltas are acceptable.
Allow · review · deny over time
Per-agent, per-policy, per-resource. Integrates with Prometheus, Datadog, OpenTelemetry.
Trace any action end-to-end
From delegation to enforcement. Reproduce the exact decision context for audit, IR, and policy tuning.
Built for regulated enterprise from day one.
Arcane is the control plane. We never see your codebase, your agent traffic, or your resource contents. What we see — and what we attest to — is the authorization decision.
- 01We never see your codebase. A Claude Code skill generates a BOM of your agent's dependencies locally; only that declaration reaches us.
- 02Policy evaluation runs inside your VPC. No traffic leaves your perimeter for an allow/deny.
- 03Tokens are signed with keys you can rotate. JWKS lives in your control plane.
- 04The proxy is deployable as a sidecar, gateway, or per-region fleet. You own the topology.
Ship agents to production.
Keep your compliance posture.
Arcane Identity is in limited availability. We work directly with security and platform teams at regulated enterprises that are putting agents on the critical path.