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

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 →

Complexity

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

SimplestPipelines that nestAgents route each other

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())

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. Gmail push notifications, Telegram, and webhooks feed a tick loop that runs policy, requests review, and keeps an audit trail.

pip install "lazypulse @ git+https://github.com/selvaz/LazyPulse.git" →

tools

LazyTools

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

pip install "lazytoolkit @ git+https://github.com/selvaz/LazyTools.git" →

data

LazyCrawler

Web crawl & search in three modes — pure (no-LLM), local-ML (zero tokens), and smart (LazyBridge LLM) — with a secure-by-default SSRF guard. Surfaced into agents through LazyTools.

pip install "lazycrawler @ git+https://github.com/selvaz/LazyCrawler.git" →

finance

The single source of financial data for the ecosystem: a DuckDB warehouse with a read-only discovery, resolution and extraction API. Agents reach it through LazyTools’ datahub_* tools — ids in, bounded results out.

pip install "market-data-hub @ git+https://github.com/selvaz/market-data-hub.git" →

finance

LazyFin (private)

Portfolio Manager AI — the finance domain layer on top of the whole stack: canonical data model, deterministic finance kernel (returns, exposure, risk, optimizer), security-selection scoring, and PM agents. Agents orchestrate and explain; deterministic engines calculate and enforce constraints.

LazyFin → {LazyPulse, LazyCrawler, LazyTools} → LazyBridge →

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 →

Jul 2026 core

LazyBridge 1.0.1 — the first Stable release

lazybridge.__stability__ moves "beta" → "stable": the core public API contract (Agent, Plan, Tool, Envelope) won't break without a major version bump. Guardrails and Checkpoint/resume are promoted Alpha → Stable in this release, backed by a live adversarial/load stress-testing pass — LLMGuard resisted a deliberate prompt-injection/tag-smuggling attempt, and Plan checkpoint/resume correctly resumed after a forced step failure without re-billing the completed step. Not everything is done: Native tools, HumanEngine/SupervisorEngine, Evals, and the Visualizer remain Alpha/Experimental, called out explicitly rather than glossed over. Maturity table → · Changelog →
Jun 2026 pulse

Event-driven Gmail — push notifications are the new default

Gmail now tells the agent when mail arrives instead of being polled: GmailPushInbox arms Gmail's users.watch onto a Cloud Pub/Sub topic (and re-arms it before expiry), receives push notifications on a token-protected endpoint, and makes one history.list call per email received — zero Gmail API calls while the mailbox is quiet. At-least-once delivery with a persisted cursor that never skips mail, burst-safe draining, self-healing resync, and exponential backoff on adapter failures. Gmail push & polling guide →
Jun 2026 core

True token streaming for Plan & ReplanEngine

Agent(engine=plan).stream(…) now streams tokens live from each sequential step as the pipeline runs — watch it think step by step instead of waiting for one final block. Parallel bands stay silent (no token interleaving), early disconnects cancel the in-flight run, and Plan(stream_buffer=) bounds the queue. Plus Plan.store_write_is_current(): sidecar consumers can now mechanically detect the checkpoint crash-window instead of reconciling by hand. Plan streaming →
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). Read-only by construction: write access lives behind the gated CodeWriteTools capability (mandatory base_dir sandbox + one-shot confirmation). build_cli_collaboration() runs the default three-session flow — Claude Code analyses, Codex critiques, a synthesizer writes the plan; execution is opt-in and sandboxed. 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.