Build LLM agents the lazy way.

LazyBridge is a zero-boilerplate, multi-provider Python framework. One Agent class, swappable engines, and one tool contract — everything is a tool.

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. Parallelism is automatic when the engine emits multiple tool calls in a turn; deterministic when you declare it.

The mental model

Every Agent is the composition Engine + Tools + State. The same shape supports a one-shot helper, a hierarchical multi-agent system, and a checkpointed production pipeline — only the engine= argument changes.

• Engine. What decides next. LLMEngine is the common case; swap for Plan (deterministic DAG), HumanEngine (approval gate), or SupervisorEngine (REPL).
• Tools. Anything the agent can invoke. Functions, other Agents, Plan-backed pipelines, MCP servers, and provider-native tools live in the same tools=[…] list.
• State. Memory (in-prompt history), Store (durable blackboard), Session (event bus and observability).

Pick your tier

Every tier is additive. Lift the lid only when the problem requires it.

Function becomes a tool

No decorators. No hand-written JSON schemas. Type hints and the docstring become the tool's LLM-facing schema automatically.

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

Core primitives