MIT monorepo (extension, instrument, monitors, remote, CLI). No CLA found. Community project under the reduxjs org; no company owner.
language
TypeScript
backing
Community (reduxjs org). Recent work is almost entirely one maintainer: markerikson authored 79 of the ~96 commits in the last 90 days, the rest mostly renovate[bot]. Originally by Dan Abramov (2015) and Mihail Diordiev (extension). GitHub Sponsors; no company funding.
It is the reference design for message-log time travel, but it is a browser-extension debugger for JS stores, not something a Rust terminal UI can use.
Borrow from it: take a specific idea, API or format.
the steelman: the best honest case for it
Redux DevTools proved, at ecosystem scale, that time travel is cheap when state changes only through serializable messages and a pure reducer: the whole debugger is just another reducer whose state is {actions, skipped ids, committed state, cursor, cached states}, so jump, skip, reorder, commit, import/export and persist all fall out of a few dozen lines rather than bespoke recorder machinery. It is the lingua franca other stores (Zustand, NgRx, MobX bridges) adopt rather than reinvent, it carries over a socket for remote and React Native apps, it can generate regression tests from a recorded action, and its 'features' flags let a production build ship export-only bug reports. A fan would say thc-scene's time travel should simply be 'Redux DevTools' lifted reducer, for a terminal UI, exposed to agents' — and that the hard design questions (bounded history, committing old actions, locking side effects while travelling, reviving custom types on import) were answered here a decade ago.
scores
UI as data
1 scene 5
App state and action log are JSON; the UI itself is React code outside the tool's model.
Agent can drive it
2 scene 5
Remote socket protocol + third-party redux-mcp (read/dispatch/reset) — real but thin and unofficial.
Agent can see it
3 scene 5
Structured app state/action history readable; no rendered view.
Small, targeted edits
2 scene 5
Time travel
3 scene 0
Full human time travel; the ops are messages an agent could send, but no agent tool exposes seek/skip/fork today.
Live data rate
2 scene 5
Default 500 ms batching and 50-action window; built for human pace.
Terminal native
0 scene 5
Pixel graphics
0 scene 4
Teaching
2 scene 3
Watching actions flow is a classic way to teach Redux, but no tour/narration features.
Maturity
5 scene 1
Openness
5 scene 4
MIT, community org, no company or CLA.
Redux DevTools scene now scene planned
how agents use it
How
No first-party agent surface. Programmatically, any client of the extension (window.__REDUX_DEVTOOLS_EXTENSION__.connect: init/send/subscribe) or of the remote socket protocol (@redux-devtools/remote / redux-devtools-cli) can receive the lifted state and send DISPATCH messages carrying lifted actions (JUMP_TO_ACTION, TOGGLE_ACTION, IMPORT_STATE…). Third-party redux-mcp (3 stars, 2026-06) exposes MCP tools to read state, list observed actions, dispatch actions and reset history over a WebSocket runtime; it does not expose jump/skip. Replay.io's ReduxActions MCP tool reads actions and per-dispatch state from a recording, post hoc.
Wiring it in
Moderate: register the store with redux-mcp (one import + registerStoresForMCP) for read/dispatch; for real time travel an agent would need a custom bridge that speaks the remote protocol and sends lifted actions. Nothing off the shelf.
Seeing the result
App state (JSON) and the action list are readable via the extension/remote message stream or redux-mcp. The rendered UI is not; that needs a browser tool.
Small edits
Dispatch arbitrary actions (the app's own update messages). No UI patching; state edits only through the app's reducer or IMPORT_STATE of a whole lifted state.
History
Model supports jump, skip (toggle), reorder, sweep, commit, rollback, import/export, lock, pause. These are reachable by protocol messages, but no maintained agent tool calls them; redux-mcp offers only 'reset history'. No fork: there is one linear staged action list.
In short
The best-documented human time-travel model in frontend, with history ops already expressed as serializable messages; agent access exists only as thin third-party read/dispatch bridges.
architecture
A store enhancer 'lifts' the app's reducer: every app action is wrapped as PERFORM_ACTION in a lifted store whose state is {actionsById, stagedActionIds, skippedActionIds, committedState, currentStateIndex, computedStates, isLocked, isPaused}. Time travel is just more actions on the lifted store (JUMP_TO_STATE, JUMP_TO_ACTION, TOGGLE_ACTION, SET_ACTIONS_ACTIVE, REORDER_ACTION, SWEEP, COMMIT, ROLLBACK, RESET, IMPORT_STATE, LOCK_CHANGES, PAUSE_RECORDING); skipping or reordering recomputes computedStates from the first invalidated index by re-running the pure reducer. The browser extension relays the lifted state to monitors (inspector, log, chart, slider, RTK Query, trace, test tab) over postMessage; @redux-devtools/remote + redux-devtools-cli carry the same messages over a socket for React Native or remote apps.
History is itself a reducer over a serializable lifted state: devtools commands are messages, not side channels.
computedStates caches every state; maxAge (default 50) bounds the window and COMMIT folds old actions into committedState.
skip/reorder = recompute from minInvalidatedStateIndex with the pure reducer (requires reducer purity).
lock blocks non-monitor dispatches and side effects while travelling; persist keeps history across reloads (debug_session URL key).
Import/export of the whole lifted state as JSON; serialize options plus __serializedType__ revive custom types.
Test tab generates Jest/Mocha/Ava/Tape test code from a selected action and the states around it.
trace: optional stack trace per action, opened in the editor via the Trace tab.
features{} flag set can restrict a production build to e.g. export-only.
performance
No published throughput numbers. The documented knobs (500 ms batching, 50-action window) show the design budget: a human-paced inspector, not a high-rate recorder. Large states cost serialization on every relay; Sept 2026 fixes added size-based message chunking.
latency (default 500 ms): actions dispatched within the interval are batched and sent at once; set 0 to send instantly, raise it (and lower maxAge) for perf issues. github.com ↗
maxAge (default 50): maximum actions stored in the history; oldest removed. 'It's critical for performance.' github.com ↗
adoption and upkeep
Adoption
The de facto devtools protocol for Redux and many non-Redux stores (Zustand, NgRx, MobX bridges speak to it). ~1.5M weekly npm downloads across its packages, plus the Chrome/Firefox extension.
Used by: Redux Toolkit (configureStore enables it by default), NgRx Store DevTools, Zustand devtools middleware, Replay.io (ReduxActions MCP tool reads the same action/state model)
Maintainability
Mature and recently revived (Sept 2026 fix wave for Manifest V3), but effectively single-maintainer; features have been stable for years.
Releases: Irregular, bursty. Browser extension 3.2.4 (2024-09-04), 3.2.5 (2024-09-16), 3.2.6 (2024-09-20), 3.2.7 (2024-09-21), 3.2.10 (2025-04-03); npm @redux-devtools/extension 4.0.0 (2026-03-17, ESM-only). A fix wave merged 2026-09-18..20 (MV3 service-worker reconnect, message chunking, import errors) is not yet tagged. · Contributors: 126 (GitHub contributors API, incl. anonymous) · Recent: ~96 commits in the last 90 days (79 by markerikson, 14 renovate[bot]); several PRs merged 2026-09-19/20; 143 open issues. · Bus factor: low: one active human maintainer does nearly all current work
weaknesses
History window is small by default (maxAge 50) and states are cached whole, so long sessions need tuning (Arguments.md).
Time travel re-renders but cannot undo side effects; components re-dispatching on rewind is a known pitfall (zalmoxisus/redux-devtools-extension#685; 'time travel sends wrong state' reduxjs/redux-devtools#712).
Requires serializable state and pure reducers; non-serializable values need custom serialize/replacer config.
No first-party agent/MCP surface; the only MCP bridge (n1snt/redux-mcp, 3 stars) reads/dispatches and resets but cannot jump or skip.
Bus factor of one: ~80% of the last 90 days of commits are a single maintainer; the browser extension's last tagged release is 3.2.10 (2025-04-03).
Linear history only: no named branches/forks; reorder/skip mutate the one timeline.
and thc-scene
Overlap
Same Elm/Redux premise as thc-scene: serializable State, explicit messages, pure update. Its lifted-state history is exactly the record thc-scene plans (message log + cursor + cached states) and its import/export is the planned export/import.
What scene would be reinventing
The history data model and its ops (jump, skip/toggle, commit with a bounded window, import/export, lock while travelling, pause recording). If scene builds a message log with seek, it is re-deriving instrument.ts; it should copy the shape deliberately rather than rediscover it.
The gap it leaves
No agent-callable history API (seek/diff/fork/screen_at), no rendered-frame readback at a past point, no fork/branch, no terminal or pixel output, and no teaching/narration layer.
What to borrow
Model history as a lifted reducer: history ops are messages (JUMP_TO_ACTION, TOGGLE_ACTION, COMMIT, IMPORT_STATE…) applied by a pure function, so they replay and test like everything else.
stagedActionIds + skippedActionIds + minInvalidatedStateIndex: skip/reorder by recomputing from the first invalidated index.
maxAge + COMMIT: bounded window with old messages folded into a committed base state.
lock: suppress effects (data-source commands, exec) while the cursor is in the past.
features flags per surface (e.g. export-only for untrusted agents).
Test generation from a selected message range (scene: emit a replay test from a history slice).