Agent Control

Agent Control addresses a specific gap in agentic systems: safety and behavior guardrails are usually hardcoded into agent logic, so changing a rule means a code change and redeploy. Agent Control instead runs as a self-hosted server with a UI, where controls are defined centrally and enforced at runtime — an SDK wraps your agent calls and checks them against the currently configured rules, which can be updated live via the server’s API or UI.

Evaluators (the logic that decides whether an agent action passes a control) are pluggable — built-in options include regex, list-membership, JSON schema, and SQL-based checks, with support for bringing your own evaluator logic. Framework support spans LangChain, CrewAI, Google ADK, and AWS Strands, meaning it’s designed to sit alongside whatever agent framework a team already uses rather than requiring a rewrite.

The project is Apache-2.0 licensed, distributed as both a PyPI package (agent-control-sdk) and an npm package (agent-control), with a self-hostable server component (also runnable via Podman) backing both.

What You Get

• A self-hostable server and UI for defining, managing, and updating agent safety controls centrally
• SDKs for Python (PyPI) and JavaScript/TypeScript (npm) that wrap agent calls and enforce controls at runtime
• Pluggable evaluators - regex, list, JSON, and SQL built in, or bring your own evaluation logic
• Framework compatibility with LangChain, CrewAI, Google ADK, AWS Strands, and others

Common Use Cases

• Centralizing safety rules across multiple agents so a policy update doesn’t require redeploying every agent’s code
• Enforcing runtime guardrails (content filtering, output validation, action restrictions) on agents built with different frameworks
• Auditing and updating agent behavior controls through a UI instead of digging through each agent’s source code
• Adding a consistent safety layer across a fleet of agents built by different teams on different frameworks

Under The Hood

Architecture Agent Control separates the control-plane server and ui from the sdks that integrate into agent code, with an engine handling control evaluation and evaluators implementing the pluggable check logic (regex, list, JSON, SQL) as distinct, swappable units. This split means the SDK’s job is narrow — wrap a call, send it to the server for evaluation, act on the result — while all the actual policy logic and configuration lives centrally in the server, which is what makes live updates possible without touching agent code.

Tech Stack Python (3.12+) for the core engine and server, with SDKs published to both PyPI (agent-control-sdk) and npm (agent-control) for Python and JavaScript/TypeScript agent codebases respectively. Docker Compose (and Podman) support deployment, and telemetry/models directories suggest built-in observability and structured data models for control decisions.

Code Quality The project tracks coverage via Codecov and runs CI on every change, with dedicated examples/ and TESTING.md documentation — signals of a project built for external adoption across multiple agent frameworks rather than an internal-only tool, backed by very active recent development.

What Makes It Unique Most agent guardrail approaches are baked into application code per-framework; Agent Control instead centralizes policy in a self-hosted control plane that multiple frameworks’ SDKs talk to, so a safety rule change propagates to every connected agent without a redeploy — closer to a feature-flag system’s operational model than typical hardcoded guardrail logic.

Self-Hosting

Licensing Model Apache-2.0 licensed — the server, UI, engine, and SDKs are all open source with no license key.

Self-Hosting Restrictions None found; the server can be self-hosted via Docker Compose or Podman with full functionality.

License Key Required No.