Clasper Core
Trust • Policy • Approvals

Stop AI tools from running without approval.

Clasper sits between AI/OpenClaw and tool execution. Govern first — prove what happened.

OpenClaw Quickstart Read the Docs

Trusted for production workloads

The Problem

AI agents do not fail gracefully in production. Most agent frameworks optimize for capability. Very few are designed for operability. That gap is where production incidents happen.

Unapproved Actions

Agents executing high-stakes actions without explicit approval, bypassing human oversight entirely.

Unpredictable Behavior

Stochastic models changing behavior without explanation, making debugging and reproduction impossible.

Silent Costs

Runaway token usage and API calls racking up bills silently in the background with no budget enforcement.

No Audit Trail

Black-box execution leaves no usable logs for compliance, security reviews, or incident post-mortems.

No Rollback

Once an agent acts, it's done. No state management to revert changes or compensate for failed steps.

Tenant Leakage

Cross-tenant data exposure when agents access resources without proper isolation boundaries.

What Clasper Core Is

Clasper Core is a governance-first control plane for AI agents. It can run in governance-only mode or with the optional stateless runtime for execution. It never executes OS or browser actions directly. Execution always remains owned by your systems — Clasper Core only decides and records.

"Governance, audit logs, and cost visibility for agent execution."

clasper-control-plane
Status Active
Policy Configured
Audit Log Enabled
> monitoring agent_execution...
> risk_score: available
> cost_tracking: enabled
> trace_view: ready

Two Ways to Deploy

Start governance-first, then choose whether Clasper Core also runs the stateless runtime.

Governance-Only

Use the Ops Console and governance APIs to audit, review, and control agent behavior while execution remains in your existing runtime or backend systems.

Governance + Managed Execution

Add the stateless Clasper Core runtime to handle LLM execution via API while keeping all OS, browser, and data actions in your backend.

Frequently Asked Questions

Is Clasper Core open source?
Yes. Clasper Core is open source and built for local, single-tenant governance of AI execution. Clasper Cloud adds shared authority, approvals, fleet views, and externally verifiable audit that require centralized trust and accountability.
Why do I need Clasper Cloud if there’s open source?
Open source is sufficient when you govern execution you own. Once multiple users, environments, or compliance needs are involved, you need centralized authority, shared approvals, and external proof — which is what Clasper Cloud provides.
Does Clasper Cloud run my agents for me?
Clasper Cloud can optionally run a stateless LLM execution runtime. It does not perform OS, browser, or data-side actions. Those always remain in your systems and are explicitly governed by policy. Clasper’s role is to decide whether execution is allowed — not to take control of your environment.
What data does Clasper Cloud see?
Clasper Cloud receives governance metadata and execution traces needed for approvals, audit, and fleet visibility. It does not require access to your source code, secrets, or customer data, and does not perform side-effecting actions in your environment.
When should I use open source versus Cloud?
Use open source for local, single-operator governance and experimentation. Use Cloud when you need shared authority, human approvals, compliance guarantees, or fleet-level governance across teams.

How It Works

Adapters request execution. Clasper Core evaluates policy, risk, and cost, gates when required, issues a bounded scope, and records evidence you can verify offline.

Execution Request

Adapter → POST /api/execution/request

↓

Clasper Core

  • Policy Evaluation + Decision Trace
  • Risk + Cost Signals
  • Audit Log
  • Pending Decisions (Cloud approvals)
↓

Execution + Telemetry

Execute in granted scope, ingest telemetry, resolve trust status, export evidence

Core Capabilities

Governance, Safety & Trust

Policy-driven control, tamper-evident audit chain, trust status on traces, and verifiable exports for offline evidence.

Policy & Explainability

Policy as data, decision traces, and human-readable explanations for every allow/deny/approval gate.

Human-in-the-Loop Approvals

Async approval workflows with pending decisions and single-use decision tokens to safely resume execution.

Cost & Risk Intelligence

Cost tracking, usage dashboards, and risk scoring available via Ops APIs.

Verifiability & Evidence

This is how you answer auditors, security teams, and incident reviews with proof — not screenshots. Clasper Core is designed for environments where you need proof, not just logs.

Trust status on every trace

Each execution resolves to a trust status (verified / unverified / compromised) so operators can filter and prioritize investigations.

Offline verifiable exports

Export bundles for auditors and security reviews and verify them offline. Signing is optional by default.

See trust guarantees →

Enterprise-Ready Governance

Built for multi-tenant SaaS, regulated environments, and security reviews.

  • Policy as data
  • Decision explainability (decision traces)
  • Human-in-the-loop gating (async approvals)
  • Auditable override history
  • Trust status + verifiable export bundles
  • Third-party verification readiness

Designed for Real Systems

Built for multi-tenant SaaS platforms, regulated environments, and platform teams shipping agent capabilities internally.

Clasper Core is NOT

  • A personal AI assistant or OS-level automation runtime
  • An autonomous agent platform
  • A scheduling engine
  • A workflow engine
  • An agent memory store
  • An OS or browser executor

Clasper NEVER

  • Self-initiates actions without a request
  • Persists agent memory (stateless by design)
  • Executes OS/browser actions directly
  • Schedules autonomous background jobs

Open by Design

Governance infrastructure must be inspectable. Trust beats lock-in. Standards matter more than hype.

Apache-2.0 License
100% Inspectable

Open Source Core Includes

The governance core, APIs, and adapters are open-source; deployment and operations remain self-hosted by default.

Runtime Daemon Execution Adapters Ops Console Governance APIs Audit + Trace Storage

Deployments

Self-hosted by default Governance-only install Runtime adapters optional Verifiable exports

Production Principles

Clasper is built on the belief that AI agents are not demos—they are software.

Determinism Over Magic

If an agent cannot be replayed, it cannot be trusted. Every decision must be traceable, inspectable, and reproducible.

Skills Are Software

Prompts are not vibes. Skills are versioned, tested, permissioned, and immutable. If it can't be tested, it doesn't ship.

Safety as Default

No implicit access. No silent escalation. No cross-tenant leakage. The safest path is always the default path.

Who Uses Clasper

  • • Platform teams shipping AI features internally
  • • Security & compliance teams reviewing AI behavior
  • • Infrastructure teams owning cost, risk, and auditability

Why Teams Adopt Clasper

"We can't explain what our agents are doing — and that's unacceptable."

Clasper gives you confidence to ship, evidence for auditors, and control when something goes wrong.

Start with trust. Scale with confidence.

Capability Comparison

Capability Agent SDK Orchestration Platform Clasper
Traceability Partial Varies Full + Trust
Policy enforcement No Partial Yes
Async human approvals No No Yes
Offline verification No No Yes
Budget & risk Limited Partial Yes

Ready to govern your agents?

Read the docs, explore the repos, or go straight to the trust guarantees.

Read the Docs Trust Guarantees Talk to Us