LazyBridge

A zero-boilerplate, multi-provider Python framework for composing LLMs, plain functions, deterministic plans, humans, and external tools under one uniform model: everything is a tool.

from lazybridge import Agent

# Tier alias works across all 4 providers: anthropic / openai / google / deepseek.
agent = Agent.from_provider("anthropic", tier="cheap")
result = agent("What's the capital of France?")
print(result.text())

That's the whole framework's surface area when you start. It grows only when your problem grows.

What LazyBridge gives you

An agent in LazyBridge is the composition of three things — and only these three:

• Engine — the decision-making layer (an LLM, a deterministic Plan, a human-in-the-loop, or your own).
• Tools — every capability the agent can use. Plain Python functions, other agents, MCP servers, and full pipelines all behave the same way.
• State — Memory, Session, and Store: continuity, traceability, and shared blackboard between steps.

That's it. Whether you're writing a one-shot helper or a checkpointed multi-region pipeline with human approvals and OpenTelemetry traces, the mental model is the same.

Where to go next

• Quickstart — install LazyBridge and run your first agent in five minutes.
• Ecosystem — the three packages (lazybridge core, lazytools capabilities, lazypulse always-on) and which one you need.
• Concepts → Mental model — Agent = Engine + Tools + State, the only decomposition you need.
• Concepts → Everything is a tool — the composition rule that holds the framework together.
• Concepts → Progressive complexity — the twelve rungs from one-line agent to checkpointed pipeline.
• Concepts → Canonical vs sugar — every factory function and shortcut LazyBridge ships, with its canonical equivalent and any subtle differences.
• Guides → Basic — one focused page per Day-1 concept: Agent, Tool, Envelope, Native tools.
• Guides → Mid — twelve pages on real-app concerns: Memory, Store, Session, Guards, verify=, Chain, Parallel, As tool, HumanEngine, MCP, Multimodal, Evals.
• Guides → Full — nine pages on production pipelines: Plan, Step, Sentinels, Routing, Parallel plan steps, Checkpoint & resume, Exporters, GraphSchema, SupervisorEngine.
• Guides → Advanced — seven pages on the extension surface: Engine protocol, BaseProvider, Providers catalogue, External tool gateway, Plan serialization, OpenTelemetry, Visualizer.
• Recipes — runnable examples from the examples/ directory, embedded verbatim.
• Decisions — nine "which one do I use?" decision trees with quick-reference tables.
• Reference — auto-generated API surface for every public symbol, organised by category.
• Errors — cause → diagnosis → fix table for every framework exception and Envelope.error.type value.
• For LLM assistants — Claude Skill install, /llms.txt index, and /llms-full.txt corpus dump.

Design principles

• Provider freedom. Switch models or providers without rewriting your architecture.
• Everything is a tool. Functions, agents, plans, pipelines, MCP servers, and external systems all compose through the same primitive.
• Zero boilerplate. No duplicated function definitions, no manual JSON schema translation, no orchestration glue you have to maintain.
• Progressive complexity. Simple use cases stay simple. Complex workflows are possible without changing the core mental model.
• Designed for humans and LLMs. Code that's readable to a reviewer is also learnable to an assistant that writes the next patch.
• Determinism when you need it. Drop down from autonomous LLM loops to a typed, validated Plan whenever auditability or repeat cost matters.
• Composability over monoliths. Large systems emerge from small, specialised components — not one overloaded prompt.
• Observable and debuggable. Sessions, exporters, the Visualizer, and OpenTelemetry mean you can always see what happened and why.

LazyBridge is meant to feel like a bridge, not a cage.

Maturity

LazyBridge is on PyPI as Stable starting at 1.0.1 (Development Status :: 5 in PyPI metadata, lazybridge.__stability__ = "stable"). The version starts at 1.0.1, not 1.0.0 — an earlier, incompatible 1.0.0 was published in April 2026 under the old LazyAgent/LazyTool namespace and rolled back; see Migrating from 1.0.0 for that history. "Stable" means the core public API contract — Agent, Plan, Tool, Envelope, and the rows marked Stable below — will not break without a major version bump. It does not mean every subsystem is finished: a handful of peripheral areas remain Alpha/Experimental/Planned, called out explicitly below rather than glossed over. Breaking changes go through the migration guides under docs/migrations/.

Subsystem	Status	Notes
Agent, LLMEngine, Tool, Envelope	Stable	Public surface, exercised by every test path.
Plan, Step, sentinels, routing	Stable	Compiler validates at construction; serialisation supported.
Memory, Store (in-memory + SQLite)	Stable	API frozen; encrypted store adapter is also stable.
Session, EventLog, exporters, GraphSchema	Stable	Default secret redaction enabled (redact_secrets).
Provider adapters (Anthropic / OpenAI / Google / DeepSeek / LiteLLM / LM Studio)	Stable	Adapters are stable; model/price tables drift with provider releases.
Checkpoint / resume	Stable	Verified under live adversarial/load testing (forced step failures, resume correctness, no re-billed steps). External side-effect rollback is still not implemented (see Parallel plan steps) — that limitation is unchanged, only the internal-state contract is now Stable.
Guardrails (Guard, ContentGuard, LLMGuard, GuardChain)	Stable	Verified under live adversarial testing, including a prompt-injection / tag-smuggling attempt against LLMGuard. Default rule libraries are still growing, but the behavior contract is settled.
MCP / external tool gateway	Moved	Migrated to the lazytoolkit package in 0.8 (lazytools.connectors.{mcp,gateway}) — see tools.lazybridge.com. The old lazybridge.ext.{mcp,gateway} deprecation shims were removed in 0.9.
Native tools (NativeTool)	Alpha	Provider-hosted capabilities (web search, code interpreter). Surface area changes when providers add new tools.
HumanEngine, SupervisorEngine	Alpha	Public API stable; UX polish continues.
Evals (lazybridge.ext.evals)	Experimental	Scoring helpers are stable; the runner API may consolidate.
Visualizer (lazybridge.ext.viz)	Experimental	Useful for debugging; not part of the runtime path.
Provider model fallback chains (_FALLBACKS)	Planned	Data tables exist; the retry path that consumes them is not implemented yet.
Automatic PII redaction	Planned	Default redactor masks credential shapes only. Compose your own for emails / phone numbers / SSNs.

Post-1.0, the plan is to lift the remaining Alpha rows to Stable, ship the Planned items once their design is settled, and either implement or remove the Experimental modules based on user feedback — all as 1.x releases under the same stability contract, not as breaking changes.