Vision

The thesis

Claude Code and Codex will transition from end-user applications to programmable execution engines — the same way Docker became container infrastructure. Zgent is the orchestration layer that coordinates when, how, and where these engines operate.

The shift happening now

2023-2024: AI agents as applications
  └── Users interact directly with Claude Code, Copilot, etc.

2025+: AI agents as infrastructure
  └── Applications call AI agent engines to perform tasks
  └── Similar to: apps don't use browsers directly, they use Playwright

Technology consistently follows this pattern of descending from applications to infrastructure:

Domain	Application	Infrastructure
Browsers	Web browser	Headless Chrome / Playwright
Databases	MySQL	DBaaS / Embedded SQLite
LLMs	ChatGPT	GPT API / Claude API
AI coding	Claude Code CLI	Claude Agent SDK / Embedded engine

The proactive agent paradigm

Traditional agent frameworks are reactive — they wait for user input. Zgent introduces proactive capabilities where agents act on schedules, events, and triggers without being asked.

The value isn't in when the agent triggers. It's in what it does after:

# Traditional cron job
def daily_check():
    if cpu > 80:
        send_alert("High CPU")  # Human must investigate

# Proactive agent
async def daily_check():
    if cpu > 80:
        logs = await analyze_recent_logs()
        deploys = await check_recent_deployments()
        history = await search_similar_incidents()

        await notify("""
        CPU anomaly detected. Analysis:
        1. Service X deployed yesterday (70% probability)
        2. Historical pattern suggests memory leak (20%)

        Recommended action: Rollback Service X
        """)

Where Zgent fits in the stack

┌─────────────────────────────────────────────────────────┐
│                    Application layer                     │
│         (SaaS products, internal tools, etc.)           │
└────────────────────────┬────────────────────────────────┘
                         │
┌────────────────────────▼────────────────────────────────┐
│                    Zgent layer                           │
│  ┌─────────────┐  ┌──────────────┐  ┌────────────────┐  │
│  │  Scheduling │  │    State     │  │ Communication  │  │
│  │  (Channels) │  │  management  │  │    (Hooks)     │  │
│  └─────────────┘  └──────────────┘  └────────────────┘  │
└────────────────────────┬────────────────────────────────┘
                         │
┌────────────────────────▼────────────────────────────────┐
│              Agent execution engines                     │
│     Claude Code SDK  │  Codex  │  Future providers      │
└─────────────────────────────────────────────────────────┘

Capability	Zgent component	Value
When to trigger agents	Channels	Proactive automation
How to coordinate agents	Context + Dispatcher	Multi-agent orchestration
What state to maintain	AgentContext + Snapshot	Session recovery, audit trails
Where to route results	Senders + Filters	Integration with existing systems
Why decisions were made	Hooks + Logging	Observability and compliance

Differentiation

Dimension	Traditional frameworks	Zgent
Core focus	"Better LLM calls"	"Better agent orchestration"
Execution	Re-implement agent logic	Leverage existing engines
Triggers	Reactive (user-initiated)	Proactive (scheduled, event-driven)
State	Stateless or basic	First-class state management
Multi-provider	Tight coupling	Protocol-based abstraction

The thesis

The shift happening now

The proactive agent paradigm

Where Zgent fits in the stack

Differentiation

On this page