Actra

Control what runs before it runs

Admission Control for Agentic and Automated Systems

Actra introduces Decision Control — a runtime layer that evaluates policies before operations execute.

It allows systems to permit or block actions safely, preventing unsafe operations triggered by AI agents, APIs & automation systems

Instead of embedding control logic directly in application code, Actra evaluates external policies before state-changing actions run.

Where Actra applies

Actra protects operations in systems such as:

• AI agents
• APIs and services
• automation pipelines
• background workers
• workflows and schedulers

Runs Everywhere

SDKs

Python • JavaScript • CLI

Server: Node • Bun • Deno Edge: Cloudflare Workers • AWS Lambda • Vercel Edge • Netlify Edge • Fastly Compute@Edge Browser: Web Browsers WASM Runtimes: Wasmtime • Wasmer

---

See Actra in Action

An AI agent attempted to call an MCP tool.

Actra evaluated policy and blocked the unsafe operation before execution.

Try in 30 seconds

Run Actra directly in your browser:

👉 https://actra.dev/playground.html

No setup required. Uses the real WASM engine.

---

Generate Policies with Claude (AI-assisted)

Actra provides a Claude Skill to help you generate:

• policy YAML
• schema definitions
• governance rules
• real-world policy patterns

What it can do

• Convert natural language to Actra policies
• Suggest safe policy patterns
• Generate test sample payload

Example prompts

Generate a policy to block refunds above 5000 for non-admin users

Create a governance policy that ensures all delete actions require approval

Use the Claude Skill

Install Claude Skill

---

Why Actra?

Modern systems increasingly perform actions automatically:

• AI agents calling tools
• workflow automation
• API integrations
• background jobs

These systems can trigger powerful state-changing operations, such as:

• issuing refunds
• deleting resources
• sending payments
• modifying infrastructure

Today these controls often live inside application code:

ifamount>1000:
raiseException("Refund too large")

This creates problems:

• rules duplicated across services
• difficult to audit behavior
• policy changes require redeploys
• automation becomes risky

Actra moves these decisions into deterministic external policies evaluated before actions execute.

---

20-Second Example

@actra.admit()defrefund(amount):
...

The rule lives in policy:

rules:
- id: block_large_refundscope:
action: refundwhen:
subject:
domain: actionfield: amountoperator: greater_thanvalue:
literal: 1000effect: block

Result:

refund(200) -> allowed refund(1500) -> blocked by policy

Actra evaluates the policy before the function executes and blocks refunds greater than 1000.

---

JavaScript Example

import{Actra,ActraRuntime,ActraPolicyError}from"@getactra/actra";// 1. Schemaconstschema=`version: 1actions: refund: fields: amount: numberactor: fields: role: stringsnapshot: fields: fraud_flag: boolean`;// 2. PolicyconstpolicyYaml=`version: 1rules: - id: block_large_refund scope: action: refund when: subject: domain: action field: amount operator: greater_than value: literal: 1000 effect: block`;// 3. Compileconstpolicy=awaitActra.fromStrings(schema,policyYaml);// 4. Runtimeconstruntime=newActraRuntime(policy);// 5. Context resolversruntime.setActorResolver(()=>({role: "support"}));runtime.setSnapshotResolver(()=>({fraud_flag: false}));// 6. Protect functionfunctionrefund(amount){console.log("Refund executed:",amount);}constprotectedRefund=runtime.admit("refund",refund);// 7. ExecuteawaitprotectedRefund(200);// allowedtry{awaitprotectedRefund(1500);// blocked}catch(e){if(einstanceofActraPolicyError){console.log("Blocked by policy:",e.matchedRule);}}

Python Example

fromactraimportActra, ActraPolicyErrorfromactra.runtimeimportActraRuntimeschema="""..."""policy_yaml="""..."""policy=Actra.from_strings(schema, policy_yaml)
runtime=ActraRuntime(policy)
runtime.set_actor_resolver(lambdactx: {"role": "support"})
runtime.set_snapshot_resolver(lambdactx: {"fraud_flag": False})
@runtime.admit()defrefund(amount: int):
print("Refund executed:", amount)
refund(200)
try:
refund(1500)
exceptActraPolicyErrorase:
print("Blocked by policy:", e.matched_rule)

Key Concepts

Actra evaluates policies using a small set of core concepts.

Action
The operation being requested.
Example: refund, delete_user, deploy_service.

Actor
The identity performing the action (user, service, or agent).

Snapshot
External system state used during evaluation.
Example: account status, fraud flags, environment.

Policy
Rules that determine whether an action should be allowed or blocked.

Governance
Optional policies that control how operational policies themselves can be defined or modified.

Admission Control
Actra evaluates policies before the action executes, allowing or blocking the operation.

---

Governance

Actra optionally supports governance policies.

Governance policies validate operational policies at compile time, ensuring that critical safety rules cannot be removed or weakened.

Governance can enforce constraints such as:

• requiring specific safety rules to exist
• preventing unsafe rule patterns
• limiting the number of certain rule types
• restricting which fields policies may reference
• applying constraints only to specific actions

This allows platform or security teams to enforce organization-wide policy standards across services.

Governance policies operate above normal admission policies, providing a control layer that validates policies themselves before they are accepted.

Installation Python

pip install actra

See the examples/ directory for quick start examples.

Installation JavaScript

Install:

npm install @getactra/actra

---

Architecture

Actra evaluates policies before operations execute.

flowchart LR
subgraph Governance Layer
G[Governance Policies]
end
subgraph Policy Layer
S[Schema]
P[Operational Policies]
end
subgraph Runtime Layer
A[Application / Agent / API]
C[Actra Admission Control]
R[Runtime Context]
end
A --> C
R --> C
S --> C
P --> C
G --> P
C --> D{Decision}
D -->|Allow| E[Execute Operation]
D -->|Block| F[Operation Prevented]

Loading

Schema defines the structure of actions, actors, and snapshots used during policy evaluation.

---

Example Use Cases

Actra can control many automated operations.

AI Agents

• restrict tool execution
• prevent critical infrastructure changes
• enforce safety policies

APIs

• block large refunds
• prevent destructive operations
• enforce safety checks

Automation

• enforce workflow rules
• restrict financial operations
• require approval thresholds

Infrastructure

• prevent destructive changes
• enforce safe deployment policies

---

Actra Platform Support

Actra runs across server, edge, and browser environments.

SDKs and Engines.

SDK/Engine	Status
Rust Core Engine	Available (Publishing Pending)
Python SDK	Available
JavaScript Runtime SDK	Available
JavaScript Browser SDK	Available
Go SDK	Planned

JavaScript Runtime Compatibility

Runtime	Status
Node.js	Available
Bun	Available
Cloudflare Workers	Available
AWS Lambda	Available
Web Browsers	Available
Deno	Available
Fastly Compute@Edge	Available
Vercel Edge Runtime	Available
Netlify Edge Functions	Available

Native WebAssembly Runtime Targets

Runtime	Status
Wasmtime	Planned
Wasmer	Planned

---

Actra vs OPA vs Cedar

Feature	Actra	OPA	Cedar
Primary purpose	Decision control for operations	General policy engine	Authorization policy language
Evaluation timing	Before executing actions	Usually request-time decisions	Authorization decisions
Integration model	Function / action enforcement	API / sidecar / middleware	Service authorization
Policy style	Structured YAML rules	Rego language	Cedar language
Governance support	Built-in policy governance	External tooling	Limited
Determinism focus	Strong	Moderate	Strong
Target systems	Agents, automation, APIs	Infrastructure, Kubernetes	Application authorization
Typical use case	Control automated operations	Policy enforcement in infra	Access control

Positioning

Actra focuses on controlling actions before they execute, especially in automated or agent-driven systems.

OPA and Cedar focus primarily on authorization decisions, such as:

• “Can user X access resource Y?”

Actra focuses on admission control for mutations, such as:

• Should this refund execute?
• Should an agent run this tool?
• Should this workflow step proceed?

Actra also supports governance policies, which validate operational policies at compile time to ensure safety rules cannot be removed or weakened.

Example Scenarios

Scenario	Best Tool
Can a user access a document?	Cedar
Can a service access an API?	OPA
Should an automated system execute an operation?	Actra
Should policies themselves follow safety standards?	Actra

---

Documentation

Full documentation available at https://docs.actra.dev

---

License

Apache 2.0