Agent Control

The Agent Control SDKs allow you to register agents, manage controls, and evaluate requests from your application. There are two primary implementations available:

• Python SDK: The primary SDK, featuring the @control() decorator and asynchronous client APIs.
• TypeScript SDK: Consists of a generated OpenAPI client supplemented with TypeScript wrappers.

Agent Control Telemetry provides shared telemetry contracts used across the Agent Control SDK and server. It defines reusable abstractions to ensure consistent observability. Key components include:

• Sink Contracts: Definitions for both synchronous (sync) and asynchronous (async) data sinks.
• Trace-Context Helpers: Utilities for managing and propagating trace contexts across distributed components.

The agent-control-evaluators package provides a set of standard evaluators used by the Agent Control server and SDK runtime to perform common validation tasks:

• regex: Performs pattern matching using regular expressions.
• list: Validates values against allow/deny lists.
• json: Validates data against a specific JSON schema.
• sql: Validates SQL queries to ensure they meet specific criteria.

The Agent Control Server is a FastAPI-based server that acts as the central management hub for the Agent Control ecosystem. It provides:

• Agent Management: Registration of agents and association with specific controls.
• Control Management: CRUD operations for controls and configuration of evaluators.
• Runtime Evaluation: An endpoint at /api/v1/evaluation that supports pre- and post-processing stages to evaluate requests.
• Observability: Endpoints to monitor system events and statistics.
• Security: API key authentication for production environments.

The TypeScript SDK allows consumers to interact with the Agent Control platform. This specific example demonstrates the following core capabilities:

• Generated client usage: Interacting with the platform via a generated client.
• Agent and control API calls: Managing agents and applying controls through the API.
• Health check flow: Implementing basic health monitoring for the agent integration.

The examples/ directory contains runnable implementations demonstrating various integration patterns for Agent Control. Each example includes a quick-run section and links to full documentation walkthroughs.

Key integration patterns demonstrated include:

• Framework Integrations: CrewAI, LangChain (SQL Agent), and AWS Strands.
• Google ADK Integration Patterns: Using AgentControlPlugin (recommended), lifecycle callbacks, or the @control() decorator for tool-specific protection.
• Evaluator Implementations: Custom evaluators using DeepEval or direct Galileo Luna scorers.
• Security Scenarios: PII protection, prompt-injection defense, and protecting SQL agents from dangerous queries.
• Advanced Control Patterns: Dynamic control updates, steering actions (observe, deny, steer), and binding controls to external target contexts (e.g., env=prod).

The evaluators/contrib/ directory contains community-contributed evaluators and starter templates for extending the Agent Control framework.

Available components:

• galileo/: Integration for the Luna evaluator.
• template/: A starter template designed to help developers implement and add their own new evaluators to the system.

For a detailed implementation guide on creating custom evaluators, refer to the official documentation at: https://docs.agentcontrol.dev/concepts/evaluators/custom-evaluators

The Agent Control UI provides a visual interface for several management tasks without requiring code changes:

• Control Management: Create, enable, disable, and edit controls.
• Agent Association: Associate specific controls with agents and review which configurations are currently active.
• Real-time Monitoring: Monitor evaluations, denials, and recent activity as they occur.
• Evaluator Inspection: Inspect different evaluator types and their specific configuration details in a centralized view.

Agent Control provides four built-in evaluators designed to intercept and validate agent requests or responses at different stages of the execution lifecycle. They can be used to block unsafe operations, enforce access controls, validate schemas, or detect sensitive information in outputs.

The Agent Control Engine is the runtime component responsible for applying control logic consistently across the ecosystem. It performs three primary functions:

1. Evaluates controls: Processes the logic defined in your control configurations.
2. Resolves selectors: Handles payload extraction and selector evaluation.
3. Runs evaluators: Executes the actual evaluation logic and aggregates the results.

It is designed to be used by both the Agent Control Server and the SDK to ensure uniform behavior.