Open Source • Kubernetes-Inspired

The Control Plane for
Agentic Applications

Define resources once. Enforce policies everywhere. Run on any framework.
EV treats prompts, agents, knowledge, and guardrails as declarative resources with centralized governance.

MIT License
Framework Agnostic
Production Ready
wrap_agent.py
from agno import Agent
from ev_core import EV

# Your existing agent
agent = Agent(
    model="gpt-4o",
    instructions="You are a helpful assistant"
)

# Wrap with EV - policies auto-apply
executor = await EV.build_executor(agent)
response = await executor.run(task="Help me draft release notes")
Why EV

What Changes with EV

Building production AI means managing guardrails, prompts, and policies across multiple frameworks and teams.

CapabilityBeforeWith EV
Framework-agnostic guardrails—
Versioned prompt management—
Built-in PII & jailbreak defense—
Declarative resource specs (YAML)—
Policy enforcement audit trail—
Centralized knowledge management—
Architecture

Kubernetes-Inspired Resource Control

Like Kubernetes for containers, EV treats every AI capability as a declarative resource. The Controller orchestrates operators, enforces policies, and maintains the resource registry.

Resources as Boundaries

When resources are attached to an agent, they define its operational boundaries. An agent can only access the MCP connectors, knowledge bases, and tools that are explicitly declared. This ensures deterministic, auditable behavior.

GitOps Ready
YAML specs fit naturally into repos, PR reviews, and CI/CD
Policy at Every Hook
Governance enforced at CREATE, LOAD, UPDATE, DELETE lifecycle events
Extensible Operators
Add new resource types by extending the Pydantic schema
YAML Specs
Local / Git
+
Python SDK
Runtime
EV Controller
Resource ManagerPolicy EngineRegistry
Agents
Prompts
Knowledge
Guardrails
Models
Agno
CrewAI
OpenAI
Open Agentic Resource Specification

Declarative Resource Types

Every resource follows the same YAML contract: enabled, version, type, metadata, spec. Interoperable across frameworks, governed centrally, extensible by anyone.

Prompts

Version-controlled templates with variable substitution and model hints

type: prompt
spec:
  name: review-summary
  model: openai-gpt-4o
  content: |
    Summarize: ${"input::string::doc"}

Knowledge

Embeddings, vector stores, and RAG pipelines with access control

type: knowledge
spec:
  name: product-docs
  embedding:
    provider: openai
    model: text-embedding-3-large
  storage: mongodb-default

Guardrails

Policy enforcement hooks for PII, jailbreak, cost controls

type: guardrail
spec:
  name: pii-redaction
  implementation:
    module_path: ev_guardrails.pii
    class_name: PIIRedactionGuardrail

Agent Definitions

Declarative agent blueprints decoupled from runtime SDKs

type: agent_definition
spec:
  name: github-agent
  engine: agno
  resources:
    guardrails: [compliance-check]

Models

Provider configuration with pricing metadata and capabilities

type: model
spec:
  name: openai-gpt-4o
  provider: openai
  pricing:
    prompt: 0.00001
    completion: 0.00003

MCP Connectors

Model Context Protocol integrations for tools and data sources

type: mcp
spec:
  name: github-mcp
  transport:
    type: http
    url: https://mcp.github.internal

Framework Agnostic

Wrap existing agents or build from declarative definitions. EV normalizes lifecycle events across all supported frameworks.

Agno
Full Support
CrewAI
Full Support
OpenAI
Full Support
LangChain
Community
Deployment

Run Anywhere

From local development to production, EV fits your infrastructure.

Self-Hosted

Run ev_core locally with resources in Git or local directories. Full control, no external dependencies.

pip install ev

Server Registry

Centralized resource management with ev_server. MongoDB-backed registry with hot reload across deployments.

docker-compose up
Coming Soon

EV Cloud

Managed control plane with built-in observability, team collaboration, and enterprise features.

100% Open Source

MIT licensed. Built by developers, for developers.