Waxell website screenshot

Waxell

Waxell is an AI agent governance and observability platform that provides runtime policy enforcement, auto-instrumented LLM telemetry, MCP governance, cost management, and durable workflow execution for agents built in any Python framework or third-party agentic tool (Claude Code, Cursor, LangChain, CrewAI, OpenAI Agents SDK, and 200+ more).

2 APIs 10 Features
AI Agent GovernanceObservabilityPolicy EnforcementLLM TelemetryCost ManagementMCPAgent Runtime

APIs

Waxell Observe API

The Waxell Observe REST API exposes the AI agent governance and observability control plane. It is used by the waxell-observe Python SDK and the Developer MCP server to record r...

Waxell Developer MCP Server

Waxell Developer MCP is a hosted Model Context Protocol server that lets coding agents (Claude Code, Cursor, Windsurf, VS Code, Claude Desktop) query a Waxell instance in real t...

Collections

Pricing Plans

Waxell Plans Pricing

2 plans

PLANS

Rate Limits

Waxell Rate Limits

3 limits

RATE LIMITS

FinOps

Waxell Finops

FINOPS

Features

Auto-Instrumentation

Two-line setup auto-instruments 200+ libraries (OpenAI, Anthropic, LangChain, LlamaIndex, CrewAI, LiteLLM, etc.) without code changes.

Runtime Policy Enforcement

26 policy categories (cost, kill switch, PII, compliance, scope, safety) returning seven decisions (allow, warn, redact, throttle, block, skip, retry).

MCP Governance

Auto-instrumentor, server middleware, and governance proxy for Model Context Protocol traffic with PII scanning and rug-pull detection.

Cost Management

Built-in model pricing for 20+ models, tenant overrides via REST, budget enforcement that warns/throttles/blocks at thresholds.

Prompt Management

Versioned managed prompts retrievable by name and label (e.g. production, staging) directly from the SDK.

Workflow Envelope

Durable execution boundary with checkpoint and resume; Redis-backed in production, in-memory for development.

Human-in-the-Loop Approvals

Custom handlers route policy blocks to Slack, webhooks, or terminal prompts for human review.

Audit Trail

Immutable, timestamped record of all agent actions, decisions, and governance events.

Developer MCP

Hosted SSE MCP server (dev-mcp.waxell.dev/sse) with 15 live tools and 8 docs resources for coding agents.

Field-Level Encryption

PII fields encrypted at the application layer with AES-256-GCM and AWS KMS (FIPS 140-2 Level 3) before database storage.

Use Cases

Govern Third-Party Coding Agents

Enforce policies on Claude Code, Cursor, Windsurf, VS Code, and Claude Desktop without modifying their code.

Instrument Self-Built Agents

Add full observability to LangChain, CrewAI, OpenAI Agents SDK, or custom Python agents with the @waxell.observe decorator.

Cost-Capped Agent Deployment

Set budgets on token spend per agent, user, or tenant; block runs that exceed configured limits.

PII-Safe MCP Tool Use

Scan MCP tool inputs/outputs for PII, credentials, and secrets with warn/block/redact responses.

Durable Long-Running Workflows

Use the WorkflowEnvelope to checkpoint multi-step agent workflows so they can resume after interruption.

Compliance-Ready AI Operations

Maintain SOC 2 Ready posture with immutable audit trails, encrypted PII, and EU data residency.

Integrations

OpenAI

Auto-instrumented LLM provider; cost and token tracking out of the box.

Anthropic

Auto-instrumented LLM provider; supports Claude family models.

LangChain / LangGraph

First-class callback handler (WaxellLangChainHandler) for tracing chains and graphs.

CrewAI

Auto-instrumented multi-agent framework support.

LlamaIndex

Tracing for RAG pipelines built with LlamaIndex.

LiteLLM

Unified telemetry across LiteLLM-routed providers.

Claude Code

Governance overlay for Anthropic's Claude Code coding agent via the Developer MCP.

Cursor / Windsurf / VS Code

Coding-agent governance via the SSE MCP server at dev-mcp.waxell.dev.

OpenAI Agents SDK

Auto-instrumentation for OpenAI's Agents SDK runs.

AWS Bedrock / Azure OpenAI / Google Vertex AI

Cloud LLM providers covered by Waxell's auto-instrumentation.

Pinecone / Weaviate / Qdrant / Milvus / Chroma

Vector database call tracing with retrieval span recording.

Slack / Webhooks

Human-in-the-loop approval handlers for policy blocks.

Stripe

Listed subprocessor for billing.

Solutions

Connect

Govern third-party agents (Claude Code, Cursor) without code changes via the MCP governance proxy.

Observe

Instrument self-built agents with auto-instrumentation, policy enforcement, and cost attribution.

Runtime

Governed execution environment for high-risk workflows with the durable WorkflowEnvelope.

Semantic Vocabularies

Waxell Context

26 classes · 6 properties

JSON-LD

API Governance Rules

Waxell API Rules

14 rules · 5 errors 9 warnings

SPECTRAL

JSON Structure

Waxell Policy Decision Structure

0 properties

JSON STRUCTURE

Waxell Run Structure

0 properties

JSON STRUCTURE

Example Payloads

Waxell Get Prompt Example

2 fields

EXAMPLE

Waxell Policy Check Example

2 fields

EXAMPLE

Waxell Start Run Example

2 fields

EXAMPLE

Resources

🔗
Documentation
Documentation
🚀
GettingStarted
GettingStarted
🚀
GettingStarted
GettingStarted
📦
SDKs
SDKs
🌐
Console
Console
📝
Signup
Signup
💰
Pricing
Pricing
🔗
Plans
Plans
🔗
RateLimits
RateLimits
🔗
FinOps
FinOps
🟢
StatusPage
StatusPage
📰
Blog
Blog
🔗
Glossary
Glossary
🔗
Security
Security
🔗
TrustCenter
TrustCenter
🔗
Compliance
Compliance
🔗
LinkedIn
LinkedIn
👥
GitHubRepository
GitHubRepository
🔗
SpectralRules
SpectralRules
🔗
Vocabulary
Vocabulary
🔗
JSONLD
JSONLD
💻
Examples
Examples
💻
Examples
Examples
💻
Examples
Examples
💻
Examples
Examples
🔗
LlmsText
LlmsText

Sources

Raw ↑
opencollection: 1.0.0
info:
  name: Waxell Observe API
  version: '1.0'
request:
  auth:
    type: apikey
    key: X-Wax-Key
    value: '{{X-Wax-Key}}'
    placement: header
items:
- info:
    name: Runs
    type: folder
  items:
  - info:
      name: Start Run
      type: http
    http:
      method: POST
      url: https://{tenant}.waxell.dev/api/v1/observe/runs/start/
      body:
        type: json
        data: '{}'
    docs: Begin a new agent execution run and obtain a `run_id` used for subsequent telemetry calls.
  - info:
      name: Complete Run
      type: http
    http:
      method: POST
      url: https://{tenant}.waxell.dev/api/v1/observe/runs/:run_id/complete/
      params:
      - name: run_id
        value: ''
        type: path
        description: Identifier of the run returned by `POST /runs/start/`.
      body:
        type: json
        data: '{}'
    docs: Mark an in-flight run as completed (or failed) and finalize aggregate metrics.
- info:
    name: Telemetry
    type: folder
  items:
  - info:
      name: Record LLM Call
      type: http
    http:
      method: POST
      url: https://{tenant}.waxell.dev/api/v1/observe/runs/:run_id/llm-calls/
      params:
      - name: run_id
        value: ''
        type: path
        description: Identifier of the run returned by `POST /runs/start/`.
      body:
        type: json
        data: '{}'
    docs: Log a single LLM API call (model, tokens, latency, cost) attached to a run.
  - info:
      name: Record Step
      type: http
    http:
      method: POST
      url: https://{tenant}.waxell.dev/api/v1/observe/runs/:run_id/steps/
      params:
      - name: run_id
        value: ''
        type: path
        description: Identifier of the run returned by `POST /runs/start/`.
      body:
        type: json
        data: '{}'
    docs: Record a single execution step within an agent run.
  - info:
      name: Record Span
      type: http
    http:
      method: POST
      url: https://{tenant}.waxell.dev/api/v1/observe/runs/:run_id/spans/
      params:
      - name: run_id
        value: ''
        type: path
        description: Identifier of the run returned by `POST /runs/start/`.
      body:
        type: json
        data: '{}'
    docs: Capture an OpenTelemetry-compatible span (tool call, retrieval, decision).
  - info:
      name: Record Score
      type: http
    http:
      method: POST
      url: https://{tenant}.waxell.dev/api/v1/observe/runs/:run_id/scores/
      params:
      - name: run_id
        value: ''
        type: path
        description: Identifier of the run returned by `POST /runs/start/`.
      body:
        type: json
        data: '{}'
    docs: Submit a quality, safety, or evaluation score against a run.
- info:
    name: Prompts
    type: folder
  items:
  - info:
      name: Get Managed Prompt
      type: http
    http:
      method: GET
      url: https://{tenant}.waxell.dev/api/v1/observe/prompts/:name/
      params:
      - name: name
        value: ''
        type: path
        description: Name of the managed prompt
      - name: label
        value: ''
        type: query
        description: Label (e.g. `production`, `staging`) to resolve to a specific version
      - name: version
        value: ''
        type: query
        description: Explicit version number
    docs: Retrieve a managed prompt by name, optionally pinned to a version or label.
- info:
    name: Governance
    type: folder
  items:
  - info:
      name: Check Policy
      type: http
    http:
      method: POST
      url: https://{tenant}.waxell.dev/api/v1/observe/policy-check/
      body:
        type: json
        data: '{}'
    docs: 'Evaluate the configured governance policies for a proposed agent

      action. The response indicates whether to allow, warn, redact,

      throttle, block, skip, or retry the action.

      '
  - info:
      name: Record Event
      type: http
    http:
      method: POST
      url: https://{tenant}.waxell.dev/api/v1/observe/events/
      body:
        type: json
        data: '{}'
    docs: Append a governance or audit event to the immutable audit trail.
- info:
    name: Cost Management
    type: folder
  items:
  - info:
      name: List Model Costs
      type: http
    http:
      method: GET
      url: https://{tenant}.waxell.dev/api/v1/observe/model-costs/
    docs: Return the merged cost table (defaults plus tenant overrides) for known models.
  - info:
      name: Override Model Cost
      type: http
    http:
      method: PUT
      url: https://{tenant}.waxell.dev/api/v1/observe/model-costs/:model_id/
      params:
      - name: model_id
        value: ''
        type: path
        description: Provider-qualified model identifier (e.g. `openai/gpt-4o`).
      body:
        type: json
        data: '{}'
    docs: Set a tenant-specific input/output token price for a given model id.
  - info:
      name: Remove Model Cost Override
      type: http
    http:
      method: DELETE
      url: https://{tenant}.waxell.dev/api/v1/observe/model-costs/:model_id/
      params:
      - name: model_id
        value: ''
        type: path
    docs: Remove a tenant-specific override and revert to the default cost.
bundled: true