Durable execution
for agents that
don't run deterministically.

use pragmatic::{Oracle, Runtime};

// Wrap the run. Every Oracle call is journaled once.
#[pragmatic::durable]
async fn research(task: Task, llm: &Oracle) -> Report {
    let plan = llm.call(plan(&task)).await;     // journaled
    let mut out = Vec::new();
    for step in plan.steps {
        out.push(llm.call(probe(step)).await); // journaled
    }
    synthesize(out)
}

// Crash anywhere. Resume exactly, no re-sampling.
let report = rt.resume(run_id).await;

// Replay the whole run, bit for bit, for audit.
let trace  = rt.replay(run_id).await;   // T1

from pragmatic import Oracle, runtime

# Wrap the run. Every Oracle call is journaled once.
@pragmatic.durable
async def research(task: Task, llm: Oracle) -> Report:
    plan = await llm.call(plan(task))     # journaled
    out = []
    for step in plan.steps:
        out.append(await llm.call(probe(step)))  # journaled
    return synthesize(out)

# Crash anywhere. Resume exactly, no re-sampling.
report = await rt.resume(run_id)

# Replay the whole run, bit for bit, for audit.
trace  = await rt.replay(run_id)   # T1

import pragmatic.Oracle;
import pragmatic.Runtime;

// Wrap the run. Every Oracle call is journaled once.
@Pragmatic.Durable
CompletableFuture<Report> research(Task task, Oracle llm) {
    Plan plan = llm.call(plan(task)).join();     // journaled
    List<Output> out = new ArrayList<>();
    for (Step step : plan.getSteps()) {
        out.add(llm.call(probe(step)).join());   // journaled
    }
    return synthesize(out);
}

// Crash anywhere. Resume exactly, no re-sampling.
Report report = rt.resume(runId).join();

// Replay the whole run, bit for bit, for audit.
Trace trace  = rt.replay(runId).join();   // T1

#include <pragmatic/oracle.hpp>
#include <pragmatic/runtime.hpp>

// Wrap the run. Every Oracle call is journaled once.
PRAGMATIC_DURABLE
auto research(Task task, Oracle& llm) -> Task::future<Report> {
    auto plan = co_await llm.call(plan(task));     // journaled
    std::vector<Output> out;
    for (auto& step : plan.steps) {
        out.push_back(co_await llm.call(probe(step)));  // journaled
    }
    co_return synthesize(out);
}

// Crash anywhere. Resume exactly, no re-sampling.
auto report = co_await rt.resume(run_id);

// Replay the whole run, bit for bit, for audit.
auto trace  = co_await rt.replay(run_id);   // T1