Skip to content

Step 13: Where to go next

You did it. Twelve steps in, you've seen every basic LazyBridge primitive a developer hits in the wild:

  • The single agent — Agent, LLMEngine, Envelope, output=, verify=, verbose=
  • Tools — type-hinted Python functions, Tool.wrap, the implicit loop
  • The four composition patterns — sub-agent-as-tool, Agent.chain, Agent.parallel, Plan + sentinels
  • Conditional flow — routes= / routes_by= / after_branches= / when DSL
  • Cross-model verification — verify=judge_agent with a different LLM family
  • Human-in-the-loop — HumanEngine / human_agent
  • Honest comparison — when to reach for LazyBridge, LangGraph, or CrewAI

That's enough to build real production agents. Everything from here is either deeper (the same primitives, with more knobs) or further out (production concerns: observability, evaluation, persistence, distributed runs).

This page is your map.

A short suggested first project

If you want to consolidate what you learned before opening the deeper docs, build something like this end-to-end:

A "pull request reviewer" agent. Given a PR URL, fetch the diff, classify it (docs / bugfix / feature / risky), run different reviewers for each category, ask a human for sign-off on risky PRs, and post a final summary comment.

It exercises: tools (fetch_diff, post_comment), structured output (Classification model), routes_by= (category branching), HumanEngine (the risky gate), verify= (a second-pass quality judge), and observability (you want to see every decision in the trace).

Skim the recipes for similar patterns to crib from.

The four tiers of LazyBridge docs

After this beginner section, the rest of the documentation is organised by how much capability you need. Each tier reuses everything from the previous one — no surprises.

Basic — primitives reference

Guides → Basic — formal reference for what you saw in Steps 3–4:

  • Agent — full constructor signature, every parameter, with examples
  • Tool — Tool.wrap, mode="signature" / "llm" / "hybrid", schema introspection edge cases
  • Envelope — every field, error envelopes, payload shapes, metadata semantics
  • Native tools — NativeTool.WEB_SEARCH, CODE_EXECUTION, COMPUTER_USE and the safety opt-in

Read these when you want the exhaustive surface of what you already roughly know.

Mid — common production needs

Guides → Mid — features most apps end up needing:

  • Memory — conversation continuity across calls
  • Store — cross-run / cross-agent state persistence (the same from_agent("name") sentinel from Step 9 reads this)
  • Session — event tracking and observability hooks for the whole run
  • Guards — hard policy gates (the sibling of verify= from Step 6)
  • verify= — the deep reference for Step 6, including the three placement variants
  • Chain, Parallel, As tool — formal docs for Step 5/7/8
  • HumanEngine — the deep reference for Step 11, including the custom UI protocol
  • MCP — Model Context Protocol servers as tools
  • Multimodal — images and audio as inputs
  • Evals — evaluation harness for agent quality

Full — the deep composition layer

Guides → Full — everything Plan and routing can do beyond what Steps 9–10 covered:

  • Plan — full Plan semantics, including per-step writes=, input=, output=, sources=
  • Step — all Step parameters in detail
  • Sentinels — from_prev, from_step, from_start, from_agent, from_memory, from_parallel, from_parallel_all
  • Routing — beyond routes_by=: multi-predicate routing, nested branches, loop control
  • Parallel plan steps — bands, fan-in via from_parallel, concurrency limits
  • Checkpoint & resume — persisted Plan state, multi-day workflows, on_concurrent policy
  • Exporters — EventExporter, JsonFileExporter, OTelExporter, custom callback exporters
  • GraphSchema — typed payload contracts between steps
  • SupervisorEngine — the REPL-style HIL engine teased at the end of Step 11

Advanced — when you're building infrastructure

Guides → Advanced — for contributors, integrators, and people running LazyBridge at scale:

Recipes — patterns to crib from

Recipes is the "tested code, copy and adapt" section:

Most recipes are also runnable scripts in the examples/ directory.

Decision pages — "should I use X or Y?"

When the choice between two LazyBridge features isn't obvious, the Decisions section has short opinionated answers:

Reference — when you need the exact signature

Reference is auto-generated from the source docstrings. Use it as a search target:

For LLM assistants (Claude / Cursor / Copilot)

If you generate LazyBridge code with an LLM, point it at:

These pages exist so an LLM writing your LazyBridge code produces canonical, current-version code instead of an 0.4-era pastiche of LazyAgent and mode="auto".

Stay current

A final word

This tutorial deliberately stayed in the basic tier. There's a real risk of "tutorial-fatigue", where a beginner section keeps adding edge-case features instead of stopping when the foundation is solid. The foundation is solid now — every step's content stays unchanged when you graduate to the mid/full/advanced guides; the deeper docs add knobs, they don't change the surface.

Build something with what you have. Come back to the guides when a specific feature seems missing — and most of the time, it'll already be there, just under a name you hadn't met yet.

Good luck, and welcome to LazyBridge.

← LazyBridge vs LangGraph vs CrewAI Start over →