Framework Open Source

Construye agentes IA autónomos
que realmente funcionan

Name: Pydantic DeepAgents
Author: Vstorm

Framework Python de producción con patrón deep agent — agentes que planifican, programan, ejecutan y delegan como Claude Code.

Probar Quick Start Ver en GitHub 467

Terminal

¿Por qué usarlo?

Sin DeepAgents

✗ Cadenas frágiles que se rompen con inputs inesperados
✗ Sin type safety — basado en dicts, propenso a errores
✗ Difícil depurar rutas de decisión del agente
✗ Gestión manual de la ventana de contexto
✗ Sin patrón de delegación de subagentes

Con DeepAgents

✓ Agentes modulares con planificación estructurada
✓ Completamente type-safe con modelos Pydantic
✓ Observabilidad completa vía Logfire
✓ Resumen automático de contexto
✓ Delegación y comunicación de subagentes integrada

Empieza en 4 pasos

De pip install a agentes autónomos en minutos

Instala

pip install pydantic-deepagents — un paquete, cero configuración, todo incluido.

Define tu agente

Describe qué hace tu agente — herramientas tipadas, system prompts y sub-agentes opcionales.

Ejecuta

Tu agente planifica, ejecuta y delega — transmitiendo resultados en tiempo real por WebSocket.

Escala con sub-agentes

Divide tareas complejas en sub-agentes especializados que colaboran de forma autónoma.

Todo lo que un agente necesita

De la planificación al despliegue — el toolkit completo de deep agent.

Patrón Deep Agent

Implementa la arquitectura Claude Code — agentes que razonan, planifican y ejecutan tareas complejas de forma autónoma.

Contexto ilimitado

La compactación de conversaciones permite trabajar en tareas que exceden la ventana de contexto de cualquier modelo.

Delegación de subagentes

Crea subagentes especializados para investigación paralela, generación de código o análisis — fusiona resultados.

Memoria persistente

Los agentes recuerdan entre sesiones. Memoria por proyecto y global con filtrado automático de relevancia.

Sistema de herramientas

Acceso a archivos, ejecución shell, búsqueda web y herramientas custom — todo con modelos Pydantic tipados.

Listo para producción

Streaming, checkpoints, soporte multi-proveedor, integración Logfire — probado en 30+ despliegues.

¿Cómo se compara?

Mira cómo se compara con las alternativas.

Característica	DeepAgents	LangChain	CrewAI	AutoGen
Type Safety	✓	✗	✗	✗
Delegación de subagentes	✓	✗	✓	✓
Sistema de herramientas	✓	✓	✓	✓
Multi-proveedor	✓	✓	Partial	✓
Observabilidad	✓	Partial	✗	✗
Probado en producción	✓	✓	✗	✗

Cómo funciona

Una arquitectura por capas desde tu aplicación hasta el LLM.

Your Application

DeepAgent Orchestrator

Planning
Engine

Memory
Manager

Context
Compactor

Middleware Stack

GuardrailsCost TrackingLoggingPermissions

Tool Registry

FilesystemShellWeb SearchSub-agentsCustom

LLM Provider

ClaudeOpenAIGemini

Tres líneas para tu primer agente

Desde configuración básica hasta herramientas custom y delegación de subagentes.

from pydantic_deep import create_deep_agent, DeepAgentDeps, StateBackend

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-20250514",
    instructions="You are a senior Python developer.",
)

deps = DeepAgentDeps(backend=StateBackend())

result = await agent.run(
    "Refactor the auth module to use JWT tokens",
    deps=deps,
)

from pydantic_ai import RunContext
from pydantic_deep import create_deep_agent, DeepAgentDeps, StateBackend

async def analyze_logs(ctx: RunContext[DeepAgentDeps], path: str) -> str:
    """Analyze log files for errors and patterns."""
    return ctx.deps.backend.read(path)

agent = create_deep_agent(
    model="openai:gpt-4.1",
    instructions="You are a DevOps assistant.",
    tools=[analyze_logs],
)

deps = DeepAgentDeps(backend=StateBackend())
result = await agent.run("Find and fix recent errors", deps=deps)

from pydantic_deep import create_deep_agent, DeepAgentDeps, StateBackend
from pydantic_deep.types import SubAgentConfig

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-20250514",
    instructions="You are a tech lead. Delegate tasks to subagents.",
    subagents=[
        SubAgentConfig(
            name="code-reviewer",
            description="Reviews code for bugs and best practices",
            instructions="You are an expert code reviewer.",
        ),
    ],
)

deps = DeepAgentDeps(backend=StateBackend())
result = await agent.run("Review the PR changes", deps=deps)

Construido para trabajo real

Desde generación de código hasta pipelines de investigación.

Generación y refactoring de código

Agentes autónomos que leen codebases, planifican cambios y los implementan en múltiples archivos.

— Refactoring multi-archivo
— Code review automatizado
— Generación de tests
— Actualización de dependencias

Agentes de investigación

Agentes que buscan en la web, analizan hallazgos y producen informes de investigación estructurados.

— Búsqueda web y scraping
— Referencia cruzada de fuentes
— Salida estructurada
— Seguimiento de citas

Automatización de pipelines

Construye, monitorea y repara pipelines de datos con agentes que entienden tu infraestructura.

— Scaffolding de pipelines
— Diagnóstico de errores
— Migraciones de esquema
— Tuning de rendimiento

CLI y DeepResearch

Terminal interactivo, integración con editor e investigación autónoma — todo incluido.

CLI Interactivo

Interfaz de terminal completa con Textual. Reanuda conversaciones, cambia modelos, rastrea tokens — o conéctalo a Zed vía ACP.

Reanudación de sesiones y memoria persistente
Cambio de modelos multi-proveedor
Skills personalizados y búsqueda web
Integración con Zed vía ACP

DeepResearch

Agente de investigación autónomo que planifica consultas, delega a subagentes, cruza fuentes y escribe informes estructurados con citas.

Planificación de investigación multi-paso
Delegación paralela de subagentes
Búsqueda web con descarga completa de páginas
Informes estructurados con citas

Preguntas frecuentes

Todo lo que necesitas saber sobre nuestras herramientas y proyectos.

¿Qué es pydantic-deep?

Un framework Python para construir agentes autónomos de IA inspirado en la arquitectura de Claude Code. Implementa el patrón deep agent — agentes que pueden planificar, leer/escribir archivos, delegar a subagentes y mantener memoria persistente entre sesiones.

¿En qué se diferencia de LangChain o CrewAI?

DeepAgents es type-safe por defecto (modelos Pydantic, no dicts), modular (componer herramientas, no cadenas) y observable (integración Logfire). Se enfoca en el patrón deep agent — agentes de larga duración que planifican y ejecutan autónomamente.

¿Qué proveedores de LLM son compatibles?

Cualquier proveedor soportado por Pydantic AI — OpenAI, Anthropic, Google Gemini, Groq, Mistral y cualquier API compatible con OpenAI (como Ollama para modelos locales). Cambia de proveedor con una línea de configuración.

¿Puedo usar mis propias herramientas?

Sí. Define herramientas usando el decorador @tool de Pydantic AI. Las herramientas son type-checked, soportan ejecución async e se integran con el sistema de permisos. También puedes usar toolsets preconstruidos (filesystem, base de datos, consola) de bibliotecas complementarias.

¿Está listo para producción?

Sí. DeepAgents impulsa más de 30 despliegues en producción en Vstorm. Incluye logging estructurado vía Logfire, recuperación de errores, seguimiento de uso de tokens y ha sido probado en aplicaciones reales de agentes IA.

Ver todas las preguntas

¿Listo para agentes que realmente piensan?

Instala pydantic-deep, define tu agente y déjalo planificar, codear y delegar — como Claude Code, pero tuyo.

Probar Quick Start

Construye agentes IA autónomos que realmente funcionan