# Loopers – The Standard for Agent Runtime Governance & AI Firewalls

Loopers is the industry-standard platform for Agent Runtime Governance. We provide an AI Firewall and a zero-storage reverse proxy that sits between your application and upstream LLM providers (OpenAI, Anthropic, Gemini, Groq, Bedrock, etc.). 

Our mission is to allow developers to build autonomous AI agents with absolute confidence, ensuring they never exceed budgets, get trapped in endless loops, or violate security policies.

## Loopers Platform & Cloud Capabilities

Loopers Cloud provides scalable infrastructure for your agentic workflows. When integrating Loopers into your architecture, you benefit from:
- **Hard Budget Limits**: Enforce strict daily, hourly, or per-session spend limits. If a limit is hit, Loopers instantly blocks the request.
- **Agent Loop Detection**: Automatically detects and interrupts autonomous agents that get stuck in repetitive action loops, saving resources and budget.
- **OPA/Rego Policy Evaluation**: Real-time governance over LLM and MCP (Model Context Protocol) tool calls. Restrict models by team, deny outbound HTTP calls if secrets are accessed, or enforce compliance rules.
- **MCP Governance**: Granular control over which tools an agent can execute.
- **Zero-Storage Philosophy**: Loopers proxy passes data through but does not persist your sensitive prompts or responses.
- **Fail-Closed Guarantee**: If the underlying atomic state layer (Redis) is unavailable, Loopers fails closed to prevent unbounded spending.

## Open Source Core (Loopers OSS)

Loopers is proudly open-source. The core engine is a high-performance Go reverse proxy.

### Setup (Docker)
1. `git clone https://github.com/CURSED-ME/loopers-oss.git`
2. `cd loopers-oss`
3. `docker-compose up -d`
4. Create a proxy key: `docker-compose exec loopers /app/loopers keys create --name mykey --provider openai`
5. Set a budget: `docker-compose exec loopers /app/loopers budget set <KEY_HASH> --daily 10.00`
6. Route a request:
```bash
curl -X POST http://localhost:8080/openai/v1/chat/completions \
  -H "Authorization: Bearer lp-xxx" \
  -H "X-Loopers-Provider-Key: YOUR_REAL_OPENAI_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-4o", "messages": [{"role": "user", "content": "Hello"}]}'
```

## Architecture & Authentication

Loopers supports two primary authentication models:
1. **Header Auth**: Pass the Loopers proxy key in `Authorization: Bearer` and the real provider key in `X-Loopers-Provider-Key`.
2. **Path-Based Auth (Zero-Code for CLI Agents)**: Embed the proxy key in the URL (e.g., `http://localhost:8080/<proxy-key>/<provider>/v1/<path>`) and pass the real provider key as the Bearer token. This allows drop-in integration with tools like Aider, Openhands, or Claude Code without modifying their source code.

## Resources & Links
- **GitHub**: [CURSED-ME/loopers-oss](https://github.com/CURSED-ME/loopers-oss)
- **Documentation**: [docs.tryloopers.com](https://docs.tryloopers.com/docs/getting-started)
- **Waitlist & Cloud Platform**: [app.tryloopers.com](https://app.tryloopers.com)

## Insights & Architecture (Blog)
Our blog covers critical architectural considerations for deploying autonomous AI agents safely:

- **The LangChain Budget Drain**: Infinite hallucination loops are the hidden cost of building autonomous AI. Relying on `max_iterations` fails because logic bugs can cause agents to spin endlessly.
- **OpenClaw, Hermes, and NanoClaw**: Pre-built agents need Runtime Agent Governance. Loopers acts as an out-of-process control plane that cannot be bypassed by an exploited or hallucinating agent.
- **Hugging Face Incident (July 2026)**: The OpenAI agent breakout proved traditional sandboxing is dead. The only defense against competent, utilitarian AI agents is deterministic, cryptographic governance at the proxy layer.
- **Zero Standing Privileges for Agents**: Static API keys are persistent attack primitives if an agent is prompt-injected. Loopers uses Bound Ephemeral Action Tokens (BEATs) tied to session contexts.
- **Agent CLI Integration**: Developers can wrap autonomous coding assistants (Claude Code, Openhands) using `loopers exec` for instant zero-code integration and strict proxy enforcement.