Mock — open in browser to preview. To wire in for real: drop the CSS into docs/stylesheets/extra.css and reference via extra_css: in mkdocs.yml.
Search the docs… ⌘K
GitHub ↗
v0.7.9 · alpha

Zero-boilerplate LLM agents in Python.

One Agent class, swappable engines, and one tool contract — Python functions, other agents, MCP servers, and full pipelines all compose through tools=[…].

Quickstart → View on GitHub
5 providers MCP first-class OTel out of the box
Python Copy 
from lazybridge import Agent, LLMEngine

agent = Agent(
    engine=LLMEngine("claude-opus-4-7"),
)
result = agent("hello")
print(result.text())

# That's the whole surface when you start.
# It grows only when your problem grows.
Progressive complexity

Pick your tier — every level is additive.

LazyBridge grows with you. Start with a one-shot agent on the Basic tier; add Memory, MCP, and human-in-the-loop on Mid; reach for typed Plans and checkpoints on Full. Same Agent shape throughout.

Basic

Get an agent calling tools

One-shot agents, tool-calling, native provider tools.

Agent · LLMEngine · Tool · NativeTool · Envelope
Mid

Real apps with state & control

Memory, tracing, guardrails, composition, MCP servers, evals.

Memory · Store · Session · Guard* · verify= · MCP
Full

Production pipelines

Typed hand-offs, routing, crash resume, OTel exporters.

Plan · Step · sentinels · SupervisorEngine · checkpoint
Advanced

Extend the framework

Custom providers, custom engines, OTel internals, visualizer.

BaseProvider · Plan.to_dict · custom engines · OpenTelemetry
Worked example

Function becomes a tool, auto-schema.

No decorators, no JSON schemas. Type hints + docstring become the tool's LLM-facing schema automatically. The explicit factory pins the LLM-visible name so refactors don't break tool-maps.

What's happening

The Tool.wrap(fn, name=…) factory introspects the Python callable to produce a JSON schema the LLM understands. The bare-callable form tools=[get_weather] works too — backward-compatible auto-wrap.

  • Tool name is pinned, so refactors don't break tool-maps.
  • Schema is generated from type hints — no hand-written JSON.
  • Docstring becomes the tool description for the LLM.
  • Async detection is automatic; both sync and async functions wrap.
Python Copy 
from lazybridge import Agent, LLMEngine, Tool


def get_weather(city: str) -> str:
    """Return current temperature and conditions for ``city``."""
    return f"{city}: 22°C, sunny"


agent = Agent(
    engine=LLMEngine("claude-opus-4-7"),
    tools=[Tool.wrap(get_weather, name="get_weather")],
)
result = agent("what's the weather in Rome and Paris?")
print(result.text())

# Parallelism is emergent: when the model emits two tool
# calls in one turn they run via asyncio.gather.
Reference

Core primitives at a glance.

Every LazyBridge program is built from three categories of object. Stable across tiers — only the engine changes.

Kind Symbol What it is
ENGINE LLMEngine An LLM call loop. Tool-aware, optionally streaming, retries on transient errors.
ENGINE Plan Deterministic DAG of Steps. Validates at construction, resumes on crash.
TOOL Tool.wrap(fn) Lift any Python callable into a tool. Schema inferred from type hints.
TOOL MCP.stdio / MCP.http Mount an MCP server as a tool catalogue. Deny-by-default since 0.7.9.
STATE Memory · Store · Session In-prompt history, durable blackboard, and event bus + observability.