ChainWeaver

Observe the tool paths your agent repeats. Compile them into typed, deterministic flows. Replace the LLM-in-the-loop with governed, auditable execution.

The moat — observe → compile → replace. Point ChainWeaver at the tool paths your agent already repeats. ChainAnalyzer maps every schema-compatible chain among your tools; you compile the ones worth keeping into typed Flow objects; and FlowExecutor replaces the per-step LLM round-trips with deterministic, schema-validated execution — no model in the loop. You compile the path the analyzer surfaces instead of hand-wiring it.

Governance for tool flows. Typed I/O at every step, file-serializable flows, schema-drift detection, determinism attestation, property fuzzing, and structured audit traces — disciplined, auditable, portable deterministic execution.

Quantified and reproducible. In the repo's benchmark report, compiled flows show 0% data corruption versus 61–96% for naive LLM-in-the-loop chaining, and avoid ~$0.06 of LLM spend per 10-step flow. Regenerate it yourself with python benchmarks/report.py. Saving LLM calls is a consequence — not the headline.

from chainweaver import Tool, Flow, FlowStep, FlowRegistry, FlowExecutor
# (NumberInput, ValueOutput, double_fn defined in full example below)

# 1. Wrap any function as a schema-validated Tool
double = Tool(name="double", description="Doubles a number.",
              input_schema=NumberInput, output_schema=ValueOutput, fn=double_fn)
# 2. Wire tools into a Flow
flow = Flow(name="calc", description="Double a number.",
            steps=[FlowStep(tool_name="double", input_mapping={"number": "number"})])
# 3. Register and execute — zero LLM calls
registry = FlowRegistry()
registry.register_flow(flow)
executor = FlowExecutor(registry=registry)
executor.register_tool(double)
result = executor.execute_flow("calc", {"number": 5})
# result.final_output → {"number": 5, "value": 10}

See the full example below or run python examples/simple_linear_flow.py

Installation · Why ChainWeaver? · Is this for me? · Quick Start · Playground · Architecture · Docs site · Roadmap

See it in 30 seconds

The problem. Your agent keeps doing the same path — search → extract → validate → format — but on every single turn it round-trips through the LLM between each tool call to "decide" what to do next. That's four model calls to execute one deterministic operation.

Before — naive agent loop, 4 model-mediated decisions:

turn 1   ─►  LLM("plan")    ─►  search(query)         ─► 12 results
turn 2   ─►  LLM("next?")   ─►  extract(results)      ─► 8 facts
turn 3   ─►  LLM("next?")   ─►  validate(facts)       ─► 7 facts
turn 4   ─►  LLM("next?")   ─►  format(facts)         ─► answer
                                                          ⏱  ~6 s, 4 LLM calls

After — same path, compiled once into a named ChainWeaver flow:

t

... [View full README on GitHub](https://github.com/dgenio/chainweaver#readme)