Rewyn

Start where you are.

You already have an agent. Keep it. instrument wraps any callable so each invocation becomes a recorded run. Your framework does not need to know Rewyn exists, and Rewyn does not import it.

That records the boundary — input, output, duration, failure, and the version of what ran. Rewyn sees the edges of a foreign agent, not its internals, and does not pretend otherwise.

You are building one. Then every primitive is recorded and the detail is complete: swap the model string for "openai:gpt-5" and nothing else changes.

from rewyn.integrations.frameworks import instrument

# A LangChain, LlamaIndex, CrewAI or plain-SDK agent.
agent = instrument(langgraph_app.invoke,
                   framework="langgraph", version="3")

answer = agent(question)   # now a recorded run

from rewyn import Agent, tool

@tool(risk_level="low")
def ev_market_share(region: str) -> dict[str, float]:
    """EV share of new car sales, by region."""
    return {"region": {"europe": 24.5}.get(region.lower(), 0.0)}

agent = Agent(model="anthropic:claude-opus-5",
              tools=[ev_market_share])
result = agent.run("Compare EV adoption in Europe and China")

Read back exactly what happened.

Every event in order, with its timing, its payload and the version of every dependency the run touched — which agent, which model, which tool, at which version. Cost is attributed per call, not just totalled.

run       run_01M2SG0RJYWGRPGA77KAEM6D40
name      ev-researcher
status    succeeded
usage     27 in / 29 out tokens, 3 model calls, 2 tool calls
cost      0.000085 USD

dependencies
  - agent: ev-researcher (v1)
  - model: anthropic:claude-opus-5
  - tool:  ev_market_share (v1)

events
   1 RUN_STARTED            input: Compare EV adoption…
   2 AGENT_LOOP_STARTED     strategy: react
   3 MODEL_CALLED           …
   5 TOOL_CALLED            ev_market_share(region="europe")
   6 TOOL_RETURNED          {"region": 24.5}

Run it again without calling the provider.

Replay reconstructs the run from its recording: the recorded responses are served back in order, so you can step through a production failure on a plane, with no key and no spend.

It tells you whether the reconstruction was faithful, rather than quietly diverging — and diffing a replay against a live run is how you see what a provider changed underneath you.

replay    run_01M2SFSB5BAMW6HZPMCWJJ6XH4
of        run_01M2SG0RJYWGRPGA77KAEM6D40
mode      reconstruct
model     recorded   tools recorded
identical True   faithful True
swapped   5 recorded response(s)

Turn the production run into a regression test.

The run that broke becomes a case in a dataset. Change the prompt, the model or the tool, re-run the set, and get a report of what moved — with the old behaviour on record to compare against.

This is the loop the whole SDK exists for: the incident you fixed last month cannot come back without a test failing.

from rewyn.evaluation.dataset import Dataset
from rewyn.evaluation.metrics import exact_match
from rewyn.evaluation.regression import run_regression

# A production run becomes a regression case.
dataset = Dataset(name="critical")
dataset.add_run(result.run_id)

report = run_regression(dataset, agent,
                        evaluators=[exact_match()])
print(report.render())