Skip to content
Everything is a tool • Python-first • Composition runtime

LazyBridge is the Python framework for composable LLM workflows.

Functions, agents, deterministic plans, humans and external systems all compose through one tool interface — with validation, checkpointing and tracing built in.

Get started → See the model
Multi-provider Python-first Plan-based Observable Human-in-the-loop
LazyBridge mascot

One abstraction, not five

Most agent frameworks split your system into chains, graphs, tools, agents, routers, and executors. LazyBridge collapses them into one recursive model: everything is a tool.

See how it composes →

Fail at build time, not at 3am

Deterministic plans catch duplicate steps, broken references, type drift, and invalid sentinels before the first LLM call runs.

See validation →

Nested systems stay traceable

Agents can call plans, plans can call agents, and sub-agents can become tools — while sessions, event logs, costs, and OpenTelemetry spans roll up automatically.

See Session →

Under the hood

From a one-liner to governed multi-agent pipelines — one composition model throughout.

Progressive Complexity: 6 steps from a single Agent call to a full Multi-Agent System

Agent = Engine + Tools + State

Engine Switchboard: swap LLMEngine, Plan, HumanEngine, or Supervisor

Recursive Tools: functions, MCP, plans, and agents all compose through the same tool interface

Plan Calls Agent: a plan step can invoke a nested agent

Human Review Loop: agent produces output, human approves, edits, or stops

PulseAgent Overview: LazyPulse adds adapters, tick loop, and policy to a LazyBridge Agent

One Tick, Start to Finish: Recover, Intake, Execute, Emit on every heartbeat

Trust × Action Matrix: PulsePolicy authorizes by sender identity before the worker runs

Same mental model: from a one-line agent to nested, checkpointed pipelines.

from lazybridge import Agent, LLMEngine

agent = Agent(engine=LLMEngine("claude-sonnet-4-6"))
print(agent("Explain LazyBridge in one sentence.").text())

from lazybridge import Agent, LLMEngine, Plan, Step, Session, from_step

search    = Agent(engine=LLMEngine("gpt-5.4-mini"),      name="search")
summarise = Agent(engine=LLMEngine("gemini-2.5-pro"),    name="summarise")
writer    = Agent(engine=LLMEngine("claude-sonnet-4-6"), name="write")

research = Agent(
    engine=Plan(Step("search"), Step("summarise")),
    tools=[search, summarise], name="research",
)
article = Agent(
    engine=Plan(Step("research"),
                Step("write", context=from_step("research"))),
    tools=[research, writer], session=Session(),
)
print(article("AI agents in 2026").text())

from lazybridge import Agent, AgentPool, LLMEngine, conclude

pool = AgentPool()
researcher = Agent(engine=LLMEngine("claude-sonnet-4-6", max_tool_calls_per_turn=1),
                   name="researcher", tools=[pool.as_tool(), conclude])
writer     = Agent(engine=LLMEngine("claude-sonnet-4-6", max_tool_calls_per_turn=1),
                   name="writer", tools=[pool.as_tool(), conclude])
pool.register(researcher, writer)        # register after construction

# one pool = one local action space; researcher and writer self-organise
# inside it. researcher may route("writer", ...); any agent may conclude(...)
print(researcher("Brief me on 2026 AI trends.").text())

The LazyBridge ecosystem

Not an agent framework — a composition runtime. Three focused packages, one mental model.

core

LazyBridge

The composition runtime. Build agents and pipelines where functions, plans, humans, and other agents all share one tool interface.

pip install lazybridge →
pulse

LazyPulse

Turn workflows into always-on governed services. Receive events from Telegram, Gmail, or webhooks, run policy, request review, and keep an audit trail.

pip install lazypulse →
tools

LazyTools

Connector clients, reusable tool providers, and safety wrappers for bringing external systems into LazyBridge without bloating the core.

pip install lazytoolkit →
pulse

From workflow to governed service.

LazyPulse runs LazyBridge agents on inboxes, webhooks and schedules, applies policy before risky actions, escalates to human review and logs every decision.

Input Telegram • Gmail • Webhook
↓
Agent LazyPulse agent — always-on, tick-driven
↓
Policy Auto-approve or escalate to human review
↓
Audit Every decision logged — tamper-proof
Explore LazyPulse →

What's new

Key releases and milestones across the LazyBridge ecosystem.

  • Jun 2026 core

    ReplanEngine — the adaptive replan loop, with checkpoint/resume

    The dynamic counterpart to Plan: instead of a fixed DAG, a planner agent (built with output=PlanRound) decides the work one round at a time. ReplanEngine dispatches the tasks it emits — agents, plain functions, or pool routes alike — running parallel=True siblings concurrently, then feeds the results back for the next round. Workers can be plain functions, so it works on a simple agent too. Pass store= + checkpoint_key= and it checkpoints after every round, so a crash resumes from the right round instead of redoing completed work — same single-writer semantics as Plan. ReplanEngine guide → · Dynamic re-planning recipe →

  • Jun 2026 tools

    Code Support Agent — delegate to Claude Code & Codex

    LazyTools adds a Code Support Agent connector that puts Claude Code and Codex behind a LazyBridge agent — each in two modes: CLI (the CLI is the agent: one call, one delegated task) or MCP (the CLI exposes its own tools for your agent to orchestrate). build_cli_collaboration() makes the two collaborate — Claude Code analyses, Codex critiques, a synthesizer plans, an executor implements — as a single tool. See the guide →

  • May 2026 core

    Pool chains — dynamic workflows from bounded local action spaces

    AgentPool isn't just a routing registry — it's a bounded local action space: the set of specialists an agent may reach directly via a single route(agent_name, task) tool. Give a chosen agent access to a second pool and it becomes a gateway that links one local world to the next, composing a pool chain. The builder defines the local worlds and transition points; the runtime path emerges from agent decisions. Where Plan is the static workflow runtime (topology known up front), AgentPool is the dynamic one — and conclude(…) lets a terminal agent end the whole chain. Pair with LLMEngine(max_tool_calls_per_turn=1) for a single, traceable path. Dynamic graph → · Pool chains →

  • May 2026 core

    First framework to support Claude Opus 4.8

    LazyBridge ships claude-opus-4-8 support on day one — adaptive thinking, no-sampling mode, updated thinking-token extraction (SDK ≥ 0.105), and tier cascade (top → opus-4-8, expensive → opus-4-7).

  • May 2026 pulse

    LazyPulse v0.2.0 — cron triggers & PulsePolicy

    Schedule agents on cron expressions with timezone support. PulsePolicy gates every action on sender trust level before the worker runs, with concurrency-safe compare-and-swap scheduling.

  • May 2026 core

    LazyBridge v0.9 — one framework becomes three

    v0.9 marks the point where a single monolithic package was split into three focused libraries: LazyBridge (the composition runtime), LazyPulse (always-on governed services), and LazyTools (connector clients and safety wrappers). Each package ships and versions independently, so teams only install what they need.

Native adapters for the leading providers — plus any model via LiteLLM or LM Studio

Anthropic OpenAI Google DeepSeek Ollama

© 2026 LazyBridge Labs