LIVE · api.prxy.monster · BYOK · signed Ed25519 receipts prxy.monster

Make your AI agents
visible, controllable, and
smarter over time.

prxy.monster mascot standing on the headline

Drop prxy.monster in front of your existing model calls. Keep your SDKs and provider keys. Every call gets cost attribution, policy metadata, a signed receipt, and an outcome loop.

No provider-token markup · BYOK · hash-only by default · Ed25519 receipts · works with Anthropic, OpenAI, Google, Groq, Bedrock, OpenRouter

-ANTHROPIC_BASE_URL=https://api.anthropic.com +ANTHROPIC_BASE_URL=https://api.prxy.monster +PRXY_KEY=prxy_xxx # your Anthropic key still does the inference +# every response now ships: +Payment-Receipt: https://receipts.prxy.monster/r/<id> +Payment-Receipt-Digest: sha-256=:<b64>: +Payment-Receipt-Kid: prxy-receipt-2026-q2

One base URL. Provider keys stay yours. Provider bills inference; prxy bills the control layer.

Built for what broke this month

Real incidents → real modules.

What broke Where The module
Auto-compaction regression dropping user intent mid-session Issue #36068 · Mar 19, 2026 Compaction Bridge
MCP tool definitions burning 67K–143K tokens before you type Apideck post · Mar 16, 2026 MCP Optimizer
Public reports of AI coding-tool budgets outrunning forecasts Benzinga report · Apr 2026 Cost Guard
Claude Code users reporting rapid rate-limit drain MacRumors report · Mar 26, 2026 Semantic + Exact Cache
Claude Code subscription availability/pricing tests Public timeline · Apr 2026 MIT self-host
Context rot after ~2 hours of session Widely reported · Apr 2026 IPC + Rehydrator

New high-signal agent incidents become module candidates. Read the dated log at /monster-log/ or rerun the proof at /benchmarks/ →

It's a proxy.
That's it.

You send a request to api.prxy.monster with your existing Anthropic, OpenAI, or Bedrock key. The request flows through your configured module pipeline — caching, MCP optimization, pattern injection, cost guards — then hits your provider with your key. The response comes back the same way. Same wire format you already use.

STEP 01

You send

curl -X POST https://api.prxy.monster/v1/messages \
  -H "Authorization: Bearer $PRXY_KEY" \
  -H "X-Provider-Key: $ANTHROPIC_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 200,
    "messages": [{"role":"user","content":"Hello, prxy."}]
  }'

SDK drop-in: just swap ANTHROPIC_BASE_URL

STEP 02

The pipeline runs

 mcp-optimizer       # prune tool defs
 semantic-cache      # dedupe near-matches
 patterns            # inject past solutions
 cost-guard          # enforce budget ceiling
 your provider       # your key, your bill

Toggle modules per key via PRXY_PIPE

STEP 03

You get back

● 200 OKCACHE HIT
{
  "id": "msg_01HZ...",
  "type": "message",
  "role": "assistant",
  "content": [{
    "type": "text",
    "text": "Hi. How can I help?"
  }],
  "usage": { "input_tokens": 12, "output_tokens": 8 }
}

x-prxy-cache: HIT · x-prxy-latency: 18ms · x-prxy-saved: $0.0024

Cache hits skip repeated provider calls

prxy.monster does not bill you for tokens. Your provider bills you for tokens. We bill you for the gateway and the module pipeline. We never mark up inference.

Not an inference provider. Not a web proxy. Not a VPN. Not prxy.com.

01
Point & forget

For supported Anthropic Messages and OpenAI Chat Completions clients, change the base URL. Check the compatibility matrix for partial and planned APIs.

02
It learns

Every conversation forges patterns. Outcomes are tracked. Failures retire. Good solutions reinforce.

03
Compounds

Patterns inject before each request. Context never resets. Your AI bill goes down over time.

Every request flows through the monster first — your key, your provider, your bill.

Each module fixes a specific thing that broke.

Twelve composable modules · toggle per key via PRXY_PIPE

See all 12 modules →

Your provider bill stays yours.

prxy.monster OpenRouter Portkey Helicone LiteLLM
BYOK provider invoice Provider bills you directly Direct BYOK with post-free-tier fee Customer provider key / gateway billing Customer provider key / gateway billing Self-hosted provider key
Published hosted billing unit YES Model token prices / credits Recorded logs / requests Requests + storage usage Open source self-host
Provider inference markup on API-key BYOK No markup; no provider settlement No token markup; BYOK fee after 1M requests No published token markup No published token markup No hosted bill in OSS mode
Public itemized payment ledger receipts.prxy.monster Not a public ledger Not a public ledger Not a public ledger N/A
MCP token optimization YES NO NO NO NO
Infinite context (compressed) YES NO NO NO NO
Pattern learning across sessions YES NO NO NO NO
Semantic cache YES NO YES NO NO
Self-host (MIT/Apache) YES — MIT NO YES — Apache 2.0 YES YES
Composable modules YES NO NO NO NO

prxy.monster charges for the gateway pipeline, not provider inference on BYOK routes. Sources: OpenRouter FAQ, Portkey pricing, Helicone pricing, LiteLLM GitHub.

Every call gets a receipt.

Receipts prove what happened. Outcomes prove what mattered. Patterns reuse what worked. The four headers below ride on every routed call — public JWKS at /.well-known/prxy-receipt-keys.json closes the loop.

Visible
See what your agents did

Cost by model, project, and agent. Cache hit / miss. Policy decision. Module chain. Provider, status, latency. Public_demo / public_minimal / public_redacted / public_full / private — your call.

  • Cost attribution per call with pricing-table provenance
  • Lair dashboards: cost, agents, projects, drift
  • Public receipt endpoint per id at receipts.prxy.monster/r/<id>
Controlled
Control what agents can do

Per-project monthly budgets with off / warn / hard_fail enforcement. Hash-only payload capture by default; encrypted-at-rest is opt-in. BYOK + provider routing.

  • hard_fail emits a signed blocked receipt for the audit trail
  • encrypted_at_rest seals payloads under your X25519 key
  • none mode disables capture beyond receipt hashes
Verified
Prove what happened

Ed25519 over RFC 8785 JCS-canonicalized receipt body. Public JWKS, key id prxy-receipt-2026-q2. Verify in browser, in CLI, or in your own code.

  • Four canonical hashes: client req, provider req, provider resp, client resp
  • prxy-cli receipt verify <id> runs the full canonicalize-and-verify path
  • Live <VerifyBadge> on every public receipt page
Compounding
Reuse what worked

Submit an outcome anchored on a receipt. Positive outcomes feed memory_candidates. A reviewer in lair promotes useful candidates into patterns. Patterns ride into future calls.

  • POST /v1/outcomes — succeeded / failed / partially_solved / +8 more
  • Notes are sha-256 hashed server-side; raw text never persists
  • No auto-promotion. A human always promotes
View a verified receipt → Read the receipt schema → How outcomes work →

Works with what you already use.

Same wire format for supported Anthropic Messages and OpenAI Chat Completions routes. Most integrations are a single base URL change.

All integration guides →

Cloud or local. Same modules.

Self-host the entire pipeline · MIT · Same modules, your hardware

Cloud
api.prxy.monster

Hosted gateway. Zero ops. Account-scoped memory and cache.

  • API keys, usage, billing, and team workflows managed for you
  • Patterns + cache available across your workspace
  • Bring your own provider key or use configured provider routes
  • Cost guards and hard limits available per key
Local
prxy-local

Single local gateway. Private data volume. MIT licensed.

  • Runs on your laptop, your homelab, your VPS
  • No telemetry. Patterns stay on your machine.
  • Same composable modules as cloud
  • BYOK to whichever providers you trust
Self-deploy
Private cloud

Dedicated deployment for teams that need their own account boundary.

  • Your data stays inside your controlled environment
  • Dedicated provider routing and policy controls
  • Custom domain, workspace policy, and support path
  • Best for regulated teams and sensitive codebases

What it costs
to run your stuff
through the monster.

Requests, not tokens. Your provider already charges you per token — we don't double-dip.

prxy_FREE

$0 forever

1,000 requests / month · hard cap

  • Bring your own provider keys
  • Local mode
  • Core production modules
  • Community support
Start free →

prxy_PRO

$20 / month

100,000 requests / month · then $0.20 per 1k

  • Everything in Free
  • All production modules
  • API-key management
  • Module analytics
  • MPP merchant endpoint preview
  • Email support
Go Pro →

prxy_TEAM

$99 / month

1,000,000 requests / month · then $0.10 per 1k

  • Everything in Pro
  • Team controls
  • Audit logs
  • Shared policies
  • Priority support
Go Team →

One request = one HTTP call into our gateway. Streaming counts as one. Cached hits count as one. Failed-upstream calls don't count. API-key BYOK users pay providers directly at provider list rates; prxy.monster does not mark up that invoice. Managed MPP is separate: the $0.05 MPP price includes the upstream call when settlement is enabled.

Try it
in 30 seconds.

Create a free account, get a PRXY API key, register your provider key, then paste this in your terminal. Same Anthropic Messages shape.

curl -X POST https://api.prxy.monster/v1/messages \ -H "Authorization: Bearer $PRXY_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "claude-sonnet-4-6", "max_tokens": 200, "messages": [{"role":"user","content":"Hello, prxy."}] }' # → Your request runs through the active module pipeline # → Swap model names to any provider route configured for your account

Frequently asked.

What is prxy.monster?
prxy.monster makes AI agent work visible, controllable, verifiable, and reusable — with a base URL change. It is the control and receipt layer in front of your existing model calls. It is not an inference provider.
Is this an inference provider?
No. We sit in front of Anthropic, OpenAI, Google, Groq, AWS Bedrock, and OpenRouter. The provider runs the model and bills inference. prxy bills the gateway / control layer separately.
Whose key pays for tokens?
Yours, by default. BYOK: configure your provider key once and the provider bills you directly at list rates. We never mark up provider inference. The MPP route is the exception — agents pay for managed-MPP calls via Stripe SPT after the protocol surface goes through HTTP 402 / quote / sessions / charge.
What is a receipt?
A signed JSON record of one inference call: identity, provider attribution, tokens, cost with pricing-table provenance, pipeline metadata, four canonical request/response hashes, and an Ed25519 signature. Verifiable against the public JWKS at /.well-known/prxy-receipt-keys.json by anyone — no prxy code required.
What is an outcome?
An outcome is a learning signal anchored on a receipt: did this call solve the user's problem, fail it, or land somewhere in between. Positive outcomes feed the memory_candidates queue. A reviewer in lair promotes useful candidates into patterns, which then ride into future calls via the patterns module.
What is retained, by default?
hash_only is the default. We persist the four canonical sha-256 hashes plus receipt metadata. Plaintext request and response bodies are not stored unless you opt in to encrypted_at_rest, in which case they are sealed under your X25519 public key. Outcome notes are hashed server-side and never persist in raw form. Full matrix at /security/data-retention/.
How do modules work across providers?
Each module declares which provider capabilities it requires (chat, streaming, tools, prompt caching, embeddings) and how it falls back. If a capability is missing, the module either skips, degrades, or blocks — never silently corrupts a request. The receipt's module_chain tells you exactly which modules ran.
What is the anonymous sandbox for?
Try the product without a signup or a credit card. The sandbox runs 5 real Bedrock Nova Micro calls and emits 5 signed public_demo receipts you can click into. Do not paste secrets, private code, or customer data — sandbox receipts are public_demo by design.
How does local mode differ?
prxy-monster-local is the MIT self-host edition. Same module API as cloud. No telemetry to prxy.monster, no hosted sync, no managed MPP. State (cache, patterns, archived context) lives in your local volume. Use it when policy or compliance forbids sending traffic through a hosted gateway.
Can agents pay per call?
MPP discovery, the HTTP 402 challenge flow, /v1/agent/quote, and /v1/agent/sessions are live. Production Stripe SPT settlement is gated on Stripe Link SPT GA + production-payment credentials. Until that is configured, paid retries can return verification-failed. Managed MPP is $0.05 per call and includes the upstream model call. The protocol surface is wired end-to-end so you can build against it now.
Open source?
prxy-monster-local, @prxy/module-sdk, and prxy-cli are MIT-licensed on npm. Self-host the entire pipeline on your own infrastructure for free. The hosted gateway, lair operator dashboard, and the receipts ledger surfaces are closed source.
Cancel anytime?
Yes. Stripe customer portal, one click. No retention games. Your API key keeps working until the end of the billing period.

Start
today.

Create your account, choose a plan, and continue through Stripe Checkout. When payment succeeds, your prxy_ API key is provisioned and emailed automatically.

No password required at checkout. Account is provisioned when payment succeeds. We email a magic-link to sign in at lair.prxy.monster.

Opening Stripe Checkout...
Something went wrong. Try again or email [email protected].