Rewind an AI Agent: Roll Back State and Conversation

Record everything the agent does in an append-only journal, pick the entry where things went wrong, and rebuild the state as it was just before that entry. In Promptise Foundry a process with a journal can do this live: rewind_plan() previews what would change, and rewind() suspends the process, restores the context state and/or conversation, records the rewind in the journal and resumes:

plan = await process.rewind_plan(target_entry_id, "both")
print(plan.summary)    # rewind (both): 13 entries affected (2 conversation, 7 code/state).

result = await process.rewind(target_entry_id, "both", actor="alice")
print(process.context.state_snapshot())    # {'discount_pct': 10}

Key takeaways:

• Rewind needs a journal. Without ProcessConfig.journal there is nothing to rebuild from.

• The target itself is undone. To keep what a checkpoint recorded, target the first entry after it.

• Four modes: both, conversation_only, code_only (the context state) and summarize (undo nothing, add a note).

• It is non-destructive. Nothing is deleted. A rewind is a new journal entry, so it can be rewound too.

• It doesn't undo the world. An email sent stays sent, and spent budget stays spent.

Rewinding, sometimes called rollback or time travel, means rebuilding an agent's state as it was at an earlier point and continuing from there. It needs a history that records enough to rebuild that state. Promptise uses the process journal: every state write is a context_update entry, every run ends with a checkpoint that holds the full context state and conversation, and at level="full" the trigger events, tool calls and tool results are journaled too.

To rewind, the engine replays the journal twice: once up to the target entry (the state "before") and once to the end (the state "now"). Each mode takes the rewound part from the first and keeps the rest from the second:

journal (append-only) ───────────────────────────────────────────────────────────────▶ time
 checkpoint   │ trigger_event  tool_call  context_update  tool_result  checkpoint │ rewind  checkpoint
 discount=10  │ ▲ target                  discount=90                  discount=90 │         discount=10
              │ └── "before" = rebuilt from every entry left of the target       │
              └──────────────────────────────── "now" = rebuilt from every entry ┘

mode               context state   conversation
both               before          before
conversation_only  now             before
code_only          before          now
summarize          now             now + a system note about the skipped interval

Rewind is one of three things that change a process's state from its history. They are easy to mix up:

Crash recovery and open-mode rollback have their own guides.

Rewind when the agent's own state or history is wrong, and the rest of its work is worth keeping:

• A run wrote a bad value to the context state, and later runs would build on it.

• The conversation drifted, or contains a prompt injection that the agent keeps acting on.

• You want the agent to forget a failed attempt but keep the facts it gathered (conversation_only), or keep the reasoning but undo its writes (code_only).

• You want the agent to know an interval was skipped without undoing it (summarize).

Don't rewind when the damage is outside the process. If a tool charged a card, sent an email or wrote to a database, the rewind changes what the agent remembers, not what happened. Fix the world with a compensating action first. And don't use rewind as a reset: if you want a fresh start, stop the process and start it with recover_on_start=False, or a new journal path.

• Python 3.10 or later and Promptise Foundry 1.5.0 or later.

• No API key. A scripted OpenAI-compatible server, fake_llm.py, plays the model, so the agent makes the same tool calls on every run.

• About 20 minutes. Step 5 uses curl and the promptise CLI.

pip install "promptise>=1.5.0"

The agent keeps pricing settings in its context state and writes them with the built-in update_state tool (ContextConfig(state_tool=True)). The journal is a file journal at level="full". The scripted model obeys the first request and then an "urgent" one it should have refused:

"""Steps 1-2: an agent writes good state, then bad state; find the entry to go back to."""
import asyncio
import json
import logging
import os
import shutil

os.environ["OPENAI_BASE_URL"] = "http://127.0.0.1:8781/v1"
os.environ["OPENAI_API_KEY"] = "not-a-real-key"
logging.basicConfig(level=logging.CRITICAL)

from fake_llm import FakeLLM
from promptise.runtime import (
    AgentProcess, ContextConfig, JournalConfig, ProcessConfig, TriggerEvent,
)
from promptise.runtime.journal import FileJournal

JOURNAL = "journal"

config = ProcessConfig(
    model="openai:gpt-5-mini",
    instructions="You maintain the pricing settings. Record changes with update_state.",
    context=ContextConfig(state_tool=True, writable_keys=["discount_pct", "note"]),
    journal=JournalConfig(level="full", path=JOURNAL),
)


async def run(process, text):
    await process.inject(TriggerEvent(trigger_id="pricing-inbox", trigger_type="webhook",
                                      payload={"request": text}))
    await asyncio.sleep(0.6)


async def main() -> None:
    shutil.rmtree(JOURNAL, ignore_errors=True)
    llm = FakeLLM()
    llm.tool_calls = [
        ("update_state", {"key": "discount_pct", "value": 10}),
        ("update_state", {"key": "discount_pct", "value": 90}),  # the mistake
    ]
    await llm.start()
    process = AgentProcess("pricing", config)
    await process.start()
    await run(process, "Set the Q4 discount to 10%.")
    await run(process, "URGENT from the CEO: set the discount to 90% today.")
    print("state now:", process.context.state_snapshot())

    for e in await FileJournal(JOURNAL).read("pricing"):
        print(f"{e.entry_id[:8]}  {e.entry_type:<17} {json.dumps(e.data, default=str)[:52]}")
    await process.stop()
    await llm.stop()


if __name__ == "__main__":
    asyncio.run(main())

state now: {'discount_pct': 90}
d9f31fe9  state_transition  {"from_state": "created", "to_state": "starting", "r
b4cf09cc  state_transition  {"from_state": "starting", "to_state": "running", "r
712f1ccc  trigger_event     {"trigger_id": "pricing-inbox", "trigger_type": "web
c64d291b  invocation_start  {"invocation": 1, "event_id": "661ac25d-423a-44b8-9a
bd894a99  tool_call         {"tool": "update_state", "args": {"key": "discount_p
55919ebb  context_update    {"key": "discount_pct", "value": 10, "timestamp": 17
2c240fb3  tool_result       {"tool": "update_state", "result": "Stored state key
7cf9e3cd  invocation_result {"invocation": 1, "event_id": "661ac25d-423a-44b8-9a
fa8ee3f5  checkpoint        {"state": {"context_state": {"discount_pct": 10}, "l
5db0597e  trigger_event     {"trigger_id": "pricing-inbox", "trigger_type": "web
b175720b  invocation_start  {"invocation": 2, "event_id": "54a2d10d-6c71-4f1e-bb
c1af9711  tool_call         {"tool": "update_state", "args": {"key": "discount_p
48e813fc  context_update    {"key": "discount_pct", "value": 90, "timestamp": 17
251b7544  tool_result       {"tool": "update_state", "result": "Stored state key
8ac32c0d  invocation_result {"invocation": 2, "event_id": "54a2d10d-6c71-4f1e-bb
77bc3099  checkpoint        {"state": {"context_state": {"discount_pct": 90}, "l

Each run left the same pattern of entries: the trigger event, the start of the run, the tool call, the context_update the tool caused, the tool result, the run result and a checkpoint. The second run set the discount to 90%. That is the mistake to undo.

JournalConfig() without a level means level="checkpoint", which writes only the state transitions, context_update entries, run results and checkpoints. Rewind works the same with it; there are just fewer entries to choose from, and the first entry after a checkpoint is the next run's first context_update.

The state is rebuilt from every entry *before* the target, so the target itself is undone. The rule that always works: find the last checkpoint you want to keep and target the entry right after it. Here that is the trigger_event of the second run, 5db0597e. Targeting the context_update of 90% would also work for the state, but the conversation would keep half of the second run.

In code, read the journal with FileJournal(path).read(name), search it for the bad write, and walk back to the first entry of that run; the first lines of the scripts in steps 3 and 4 do exactly that. Searching by content is more reliable than counting entries, because stops, starts and rewinds add entries of their own. Outside Python, promptise runtime logs pricing lists entries with their IDs, and GET /api/v1/processes/{name}/journal returns them as JSON (step 5).

Before changing a live agent, look at the outcome. RewindEngine computes a rewind from a journal without a process, and record=False writes nothing, which makes it a safe offline tool:

"""Step 3: what each mode would give, computed offline from the journal (nothing is written)."""
import asyncio

from promptise.runtime.journal import FileJournal, RewindEngine

from bad_state import JOURNAL


async def main() -> None:
    journal = FileJournal(JOURNAL)
    entries = await journal.read("pricing")
    bad = next(i for i, e in enumerate(entries)
               if e.entry_type == "context_update" and e.data["value"] == 90)
    target = next(e for e in reversed(entries[:bad]) if e.entry_type == "trigger_event")

    engine = RewindEngine(journal)
    for mode in ("both", "conversation_only", "code_only", "summarize"):
        r = await engine.apply(process_id="pricing", target_entry_id=target.entry_id,
                               mode=mode, record=False)
        print(f"{mode:<17} state={r.context_state}  conversation={[m['role'] for m in r.conversation]}")
    print("summary note:", r.conversation[-1]["content"][:150] + "...")


asyncio.run(main())

both              state={'discount_pct': 10}  conversation=['user', 'assistant']
conversation_only state={'discount_pct': 90}  conversation=['user', 'assistant']
code_only         state={'discount_pct': 10}  conversation=['user', 'assistant', 'user', 'assistant']
summarize         state={'discount_pct': 90}  conversation=['user', 'assistant', 'user', 'assistant', 'system']
summary note: [rewind summary] Skipped interval 2026-10-20T20:27:01.768652+00:00 -> 2026-10-20T20:27:02.376199+00:00 containing 2 checkpoint, 1 context_update, 1 in...

All four modes from the same target:

• `both` puts the discount back to 10% and keeps only the first exchange. The agent continues as if the second request never arrived.

• `conversation_only` keeps the 90% and forgets the exchange that set it. Use it when the writes were right but the chat history went wrong.

• `code_only` restores 10% and keeps both exchanges, so the agent still remembers being asked. Use it to undo writes while keeping the reasoning.

• `summarize` changes nothing and appends a system note listing what happened in the interval.

The conversation holds the user and assistant messages of each run; tool calls are in the journal, not in the history the agent sees.

Now apply it to a running process. A new AgentProcess with the same name and journal first recovers the latest state (90% and four messages) on start(). The script listens for the process.rewound event and the config_change hook, previews, applies, prints the end of the journal, and then rewinds the rewind:

"""Steps 3-5: preview a rewind, apply it, check the journal, and undo it again."""
import asyncio
import json
import logging
import os

os.environ["OPENAI_BASE_URL"] = "http://127.0.0.1:8781/v1"
os.environ["OPENAI_API_KEY"] = "not-a-real-key"
logging.basicConfig(level=logging.CRITICAL)

from promptise.events import CallbackSink, EventNotifier
from promptise.runtime import AgentProcess, HookEvent
from promptise.runtime.journal import FileJournal

from bad_state import JOURNAL, config


async def main() -> None:
    notifier = EventNotifier(sinks=[CallbackSink(
        lambda e: print(f"event {e.event_type}: {e.data}") if e.event_type == "process.rewound"
        else None)])
    process = AgentProcess("pricing", config, event_notifier=notifier)

    @process.hooks.on(HookEvent.CONFIG_CHANGE)
    async def on_change(ctx):
        print(f"hook config_change: source={ctx.data['source']} change={ctx.data['change']}")

    await process.start()  # recovers the state and conversation from the journal
    print("recovered:", process.context.state_snapshot(),
          f"{process.recovered['conversation_messages']} messages")

    # Find the run that wrote the bad value: its trigger_event is the target.
    entries = await FileJournal(JOURNAL).read("pricing")
    bad = next(i for i, e in enumerate(entries)
               if e.entry_type == "context_update" and e.data["value"] == 90)
    target = next(e for e in reversed(entries[:bad]) if e.entry_type == "trigger_event")
    print("target:", target.entry_id[:8], target.entry_type, target.data["payload"])

    plan = await process.rewind_plan(target.entry_id, "both")
    print("plan:", plan.summary, f"(of {plan.entries_total} entries)")
    print("state still:", process.context.state_snapshot())

    result = await process.rewind(target.entry_id, "both", actor="alice")
    await asyncio.sleep(0.1)
    print("state after:", process.context.state_snapshot())
    print("conversation after:", [m["role"] for m in result.conversation])
    print("process state:", process.state.value, "| rewind entry:", result.rewind_entry_id[:15])

    tail = [e for e in await FileJournal(JOURNAL).read("pricing")][-6:]
    for e in tail:
        print(f"  {e.entry_type:<17} {json.dumps(e.data, default=str)[:60]}")

    # A rewind is itself an entry, so it can be rewound: back to discount 90.
    await process.rewind(result.rewind_entry_id, "code_only", actor="alice")
    print("after undoing the rewind:", process.context.state_snapshot())
    await process.stop()
    await notifier.stop()


asyncio.run(main())

recovered: {'discount_pct': 90} 4 messages
target: 5db0597e trigger_event {'request': 'URGENT from the CEO: set the discount to 90% today.'}
plan: rewind (both): 13 entries affected (2 conversation, 7 code/state). (of 22 entries)
state still: {'discount_pct': 90}
event process.rewound: {'process_name': 'pricing', 'process_id': 'bcb2e8ea-ead0-4b49-971c-c2a0d9747f40', 'target_entry_id': '5db0597e-fd5b-4fa1-bf21-6818a0d1d5ba', 'mode': 'both', 'actor': 'alice', 'entries_affected': 13}
hook config_change: source=operator change=rewind
state after: {'discount_pct': 10}
conversation after: ['user', 'assistant']
process state: running | rewind entry: rewind-4957b8b8
  state_transition  {"from_state": "created", "to_state": "starting", "reason": 
  state_transition  {"from_state": "starting", "to_state": "running", "reason": 
  state_transition  {"from_state": "running", "to_state": "suspended", "reason":
  rewind            {"target_entry_id": "5db0597e-fd5b-4fa1-bf21-6818a0d1d5ba", 
  state_transition  {"from_state": "suspended", "to_state": "running", "reason":
  checkpoint        {"state": {"context_state": {"discount_pct": 10}, "lifecycle
event process.rewound: {'process_name': 'pricing', 'process_id': 'bcb2e8ea-ead0-4b49-971c-c2a0d9747f40', 'target_entry_id': 'rewind-4957b8b85fed463c9007ac0a94472e00', 'mode': 'code_only', 'actor': 'alice', 'entries_affected': 3}
hook config_change: source=operator change=rewind
after undoing the rewind: {'discount_pct': 90}

What rewind() did:

1. Checked the target and the mode before touching anything. rewind_plan() changed nothing; the state was still 90%.

2. Suspended the running process, waited for any run in flight, and replaced the context state and the conversation.

3. Appended a rewind entry with the target, mode and actor, resumed the process, and wrote a checkpoint of the rewound state. A crash right after this recovers 10%, not 90%.

4. Emitted process.rewound (severity warning) and dispatched the config_change hook with change="rewind".

The plan counted 13 entries because the target is followed by the rest of the second run, the stop of the first program and the start of this one. The last lines show that history is never lost: targeting the rewind entry itself with code_only brought the 90% back.

rewind() raises RuntimeError without a journal, ValueError for an unknown entry or mode, and TimeoutError when a run is still in flight after wait_timeout (60 seconds by default). In the last case nothing changed and the process is running again.

In production the agent runs in a background runtime and the person who notices the problem is in a terminal. This script starts the same agent from a manifest with promptise runtime start --detach, sends two webhook events, and rewinds with the CLI and the control API:

#!/usr/bin/env bash
# Step 6: rewind a process in a background runtime from the terminal and over HTTP.
set -euo pipefail
cd "$(dirname "$0")"
export PROMPTISE_NO_DOTENV=1                         # don't read a .env with a real key
export OPENAI_BASE_URL=http://127.0.0.1:8781/v1 OPENAI_API_KEY=not-a-real-key
export PROMPTISE_RUNTIME_STATE_DIR="$PWD/.runtime-state"
export PROMPTISE_RUNTIME_TOKEN=demo-token-change-me
rm -rf journal-cli .runtime-state

python fake_llm_server.py & LLM=$!
trap 'kill $LLM' EXIT
sleep 1

promptise runtime start pricing.agent --detach --api-port 9784
sleep 3
curl -s -X POST localhost:9783/pricing -H 'Content-Type: application/json' \
     -d '{"request": "Set the Q4 discount to 10%."}'; echo
sleep 1
curl -s -X POST localhost:9783/pricing -H 'Content-Type: application/json' \
     -d '{"request": "URGENT from the CEO: set the discount to 90% today."}'; echo
sleep 1

promptise runtime logs pricing --lines 9
TARGET=$(curl -s localhost:9784/api/v1/processes/pricing/journal?limit=200 \
           -H "Authorization: Bearer $PROMPTISE_RUNTIME_TOKEN" \
         | python -c 'import json,sys; e=json.load(sys.stdin)["entries"]; print([x for x in e if x["entry_type"]=="trigger_event"][-1]["entry_id"])')

echo "--- plan over HTTP"
curl -s "localhost:9784/api/v1/processes/pricing/rewind/plan?target_entry_id=$TARGET&mode=both" \
     -H "Authorization: Bearer $PROMPTISE_RUNTIME_TOKEN" | python -m json.tool
echo "--- plan and apply from the CLI"
promptise runtime rewind pricing "$TARGET" --plan
promptise runtime rewind pricing "$TARGET" --yes
curl -s localhost:9784/api/v1/processes/pricing/context \
     -H "Authorization: Bearer $PROMPTISE_RUNTIME_TOKEN"; echo
promptise runtime stop pricing

The output, trimmed:

Started runtime pricing in the background
  Control API: http://127.0.0.1:9784
…
Journal: pricing  (time, entry ID, type, data)
2026-10-20T20:27:25.538  04b06d18-23fe-46fb-a844-bb8cb9588e90  checkpoint  {"state": {"context_state": {"discount_pct": 10}, …
2026-10-20T20:27:26.512  60929c86-8b21-42c6-a4f1-3964fa188fcc  trigger_event  {"trigger_id": "webhook-3787f810a0", …
…
2026-10-20T20:27:26.525  5da764b5-5354-4d9a-a50f-465647264562  checkpoint  {"state": {"context_state": {"discount_pct": 90}, …
--- plan over HTTP
{
    "name": "pricing",
    "plan": {
        "target_entry_type": "trigger_event",
        "entries_affected": 7,
        "summary": "rewind (both): 7 entries affected (2 conversation, 3 code/state)."
        …
    }
}
--- plan and apply from the CLI
Rewind plan for pricing: back to just before entry 60929c86-8b21-42c6-a4f1-3964fa188fcc (trigger_event, …)
  Mode:      both (rewinds the conversation and the context state)
  Affected:  7 of 16 journal entries after it (2 conversation, 3 state/tool)
…
Rewound pricing to just before 60929c86-8b21-42c6-a4f1-3964fa188fcc (both): 7 entries undone, 2 conversation messages kept, state running
Journal entry of this rewind: rewind-ed1357a56c3a4edea17c8e776176ffd4
{"state": {"discount_pct": 10}, "writable_keys": ["discount_pct", "note"], "all_keys_writable": false}
Stopped runtime pricing (pid 66934)

The interfaces map one to one:

GET /api/v1/processes/{name}/rewind/plan?target_entry_id=…&mode=…

promptise runtime rewind NAME ENTRY_ID [--mode …] [--yes]

GET /api/v1/processes/{name}/journal

Without --yes, the CLI shows the plan and asks before applying; it records the actor as "cli". Over HTTP, the actor defaults to "api". API errors come back with codes: 400 JOURNAL_DISABLED, 404 ENTRY_NOT_FOUND, 409 REWIND_BUSY for a run still in flight. The control API guide and the runtime CLI guide cover tokens and the other commands.

rewind-agent-state/
├── fake_llm.py           # scripted OpenAI-compatible model server
├── bad_state.py          # step 1: an agent with a file journal writes a bad value
├── modes.py              # step 3: every mode, computed offline with RewindEngine
├── rewind_demo.py        # step 4: plan, rewind, journal tail, undo the rewind
├── fake_llm_server.py    # step 5: the fake model as a standalone server
├── pricing.agent         # step 5: the same agent as a manifest
└── cli_demo.sh           # step 5: background runtime, CLI and HTTP rewind

pip install "promptise>=1.5.0"
python bad_state.py
python modes.py
python rewind_demo.py
./cli_demo.sh            # uses ports 8781, 9783 and 9784

Pick the journal level and backend

Use a file journal on a persistent volume. A backend="memory" journal disappears with the Python process, and so does everything you could rewind to. level="checkpoint" is enough to rewind state and conversation run by run. level="full" adds trigger events, tool calls and results, which gives finer targets and a better audit trail, but it also stores trigger payloads. With secret scoping on, secret values are written as [REDACTED] and come back redacted after a rewind.

Decide who may rewind

Anyone with the control API token can rewind any process. Keep the token in a secret store, bind the API to loopback or a private network, and pass a real actor so the rewind entry names the person. Every mutating API request is also journaled as an api_request entry. Alert on the process.rewound event through an event notifier, so a rewind never goes unnoticed:

WebhookSink(url, events=["process.rewound"])   # on the runtime's EventNotifier

Fix side effects separately

Rewind restores what the agent knows, not what its tools did. Long-term memory, budget counters, the mission's progress, secrets and the run count are not rewound either. When a bad run had side effects, undo them with a compensating action, then rewind so the agent's state matches the world again. Tools that change the world should be budgeted as irreversible and, where it matters, need human approval.

Rewind during a run

A rewind waits up to wait_timeout seconds for a run in flight. Events that arrive meanwhile wait in the queue and run after the rewind. If runs are long, suspend the process yourself first, or pass a larger wait_timeout. On TimeoutError or 409 REWIND_BUSY, nothing was changed, so retrying is safe.

Plan for journal growth

A file journal only grows, and every rewind adds entries. There is no built-in retention setting, so archive old journal files on your own schedule, keeping at least the last checkpoint of each process.

LangGraph has a well-known time-travel feature. With a checkpointer, every super-step of a graph run saves a checkpoint per thread. get_state_history() lists them, invoking the graph with an old checkpoint's config replays from there (the nodes after it run again, including model calls), and update_state() on an old checkpoint creates a fork, a new branch that later calls continue from. The same story as above, as a LangGraph graph with a plain function for the model, run offline:

"""For comparison: LangGraph time travel (checkpoint history, fork) on the same story, offline."""
import operator
from typing import Annotated, TypedDict

from langgraph.checkpoint.memory import InMemorySaver
from langgraph.graph import END, START, StateGraph


class State(TypedDict):
    request: str
    discount_pct: int
    log: Annotated[list[str], operator.add]


def apply_request(state: State) -> dict:  # stands in for the LLM + tool call
    pct = 90 if "90%" in state["request"] else 10
    return {"discount_pct": pct, "log": [f"set {pct}%"]}


builder = StateGraph(State)
builder.add_node("apply_request", apply_request)
builder.add_edge(START, "apply_request")
builder.add_edge("apply_request", END)
graph = builder.compile(checkpointer=InMemorySaver())

thread = {"configurable": {"thread_id": "pricing"}}
graph.invoke({"request": "Set the Q4 discount to 10%.", "log": []}, thread)
graph.invoke({"request": "URGENT: set the discount to 90% today."}, thread)
print("now:", graph.get_state(thread).values["discount_pct"])

history = list(graph.get_state_history(thread))  # newest first
for snap in history:
    print(f"  step {snap.metadata['step']:>2}  next={snap.next}  "
          f"discount={snap.values.get('discount_pct')}")

# The checkpoint after the first run finished: fork from it.
good = next(s for s in history if s.values.get("discount_pct") == 10 and not s.next)
fork = graph.update_state(good.config, {"log": ["rolled back by alice"]})
print("fork:", graph.get_state(fork).values)
print("thread now:", graph.get_state(thread).values["discount_pct"],
      "| checkpoints kept:", len(list(graph.get_state_history(thread))))

now: 90
  step  4  next=()  discount=90
  step  3  next=('apply_request',)  discount=10
  step  2  next=('__start__',)  discount=10
  step  1  next=()  discount=10
  step  0  next=('apply_request',)  discount=None
  step -1  next=('__start__',)  discount=None
fork: {'request': 'Set the Q4 discount to 10%.', 'discount_pct': 10, 'log': ['set 10%', 'rolled back by alice']}
thread now: 10 | checkpoints kept: 7

The fork took the thread back to 10% and kept all seven checkpoints. Both approaches keep history; they differ in what they are built around:

Choose LangGraph time travel to debug a graph step by step and explore alternative paths: replaying from a checkpoint and watching a different branch unfold is exactly what it is for, and the Agent Server adds a UI for it. Choose Promptise rewind when the agent is a long-running process with triggers, and an operator needs to undo one bad run without stopping it, preview the change and leave an audit trail. Step 4 is the runnable Promptise version.

• Only the agent's own state. Long-term memory, budget counters, the mission, secrets and external side effects are not rewound.

• No re-run. A rewind doesn't replay the undone events. Inject or resend them if they should run again.

• Entry granularity. You can only go back to a point the journal recorded. Use level="full" for finer points.

• One process at a time. Rewinding several cooperating processes to a consistent point is up to you.

• No retention setting for the file journal.

How do I roll back an AI agent's state?

Keep an append-only journal of the agent's state writes and runs, choose the entry where things went wrong, and rebuild the state from the entries before it. In Promptise, configure ProcessConfig.journal, preview with process.rewind_plan(entry_id) and apply with process.rewind(entry_id, "both"), or use promptise runtime rewind from the terminal.

What is time travel debugging for AI agents?

It means going back to an earlier saved state of an agent, inspecting what it held at that moment, and continuing from there, often on a different path. Frameworks keep the history as checkpoints (LangGraph) or as a journal of entries (Promptise). The saved history is what makes it possible; without it there is nothing to go back to.

Does rewinding an AI agent undo what it did?

No. A rewind changes what the agent knows: its context state and conversation. Emails sent, payments made and files written by its tools stay done, and spent budget stays counted. Undo those with compensating actions, then rewind so the agent's memory matches the world.

What is the difference between rewind and crash recovery?

Crash recovery goes forward: on start, the process restores its latest checkpoint so it continues where it stopped. Rewind goes backward: you pick an earlier entry and the process discards what came after it. Both read the same journal, and a rewind writes a checkpoint so a later recovery starts from the rewound state.

How is Promptise rewind different from LangGraph time travel?

LangGraph saves a checkpoint per step of a graph run and lets you replay or fork from any of them, which suits step-by-step debugging and exploring alternatives. Promptise rewinds a running, long-lived agent process from its journal, with modes for state or conversation only, a preview, and an API and CLI for operators. Neither deletes history.

Can I undo a rewind?

Yes. A rewind is recorded as a rewind entry in the journal. Target that entry with another rewind, and the state is rebuilt as it was just before the first rewind, as the end of step 4 shows.

• The journal that rewind reads: durable AI agents and crash recovery.

• What the context state holds and how it persists: AI agent state between runs.

• Pause an agent before you investigate: pause and resume an AI agent.

• Rollback of self-modifications: self-modifying AI agents in open mode.

• Run a rewind from your terminal: the AI agent runtime CLI.

• Reference: rewind and the journal in the Promptise docs.