
Rerun
WebsiteNo-Code & Low-Code
Rerun is a no-code platform to build, run, and monitor AI agents with always-on automation, human-in-the-loop approvals, and a live dashboard for full visibility across runs, logs, and metrics.
https://rerun.build/?ref=producthunt

Product Information
Updated:Jul 23, 2026
What is Rerun
Rerun (rerun.build) is an AI agent product designed to make autonomous automation approachable for non-engineers and teams. Instead of managing prompts, servers, and fragile integrations, you describe what you want done, connect the tools and models you prefer (or use Rerun-hosted models), and then monitor everything from a clear dashboard. The platform emphasizes simplicity ("no code"), transparency (nothing is a black box), and control (agents pause for approvals before sensitive actions).
Key Features of Rerun
Rerun is a no-code platform for building and operating always-on AI agents that you can monitor in real time. You describe the task, connect tools and models, and the agents run autonomously on triggers (time, email, changes), hand work off to other agents, and pause for human approval before sensitive actions. It provides a readable dashboard with run logs, metrics, token usage, and handoffs, supports many LLM providers (or your own keys/local models), and runs each workspace in a dedicated, isolated “private space” server in the cloud (with self-hosting planned).
No-code agent creation: Build agents by describing the job—no prompts, command lines, or engineering-heavy setup required.
Always-on, event-driven automation: Agents “wake up” automatically on schedules, incoming emails, or detected changes—no manual run button needed.
Human-in-the-loop approvals: For sensitive actions (e.g., payments, client emails), agents pause and request approval (in-app or via Slack) before proceeding.
Live monitoring & observability: Real-time dashboards show every run, step, token usage, status, and logs so agent behavior isn’t a black box.
Bring-your-own or included models: Use Rerun-hosted models included in plans, or connect your own subscriptions/API keys (and potentially local models) across multiple providers.
Dedicated private workspace server: Each workspace runs on its own isolated cloud machine with dedicated CPU/RAM; self-hosting is indicated as “soon.”
Use Cases of Rerun
Inbox triage & daily email operations: Draft replies in your tone, archive low-value threads, and flag the few emails that truly need attention each morning.
Inbound sales follow-up: Respond to new leads, draft outreach, and track handoffs—escalating to a human when messaging or offers are sensitive.
Finance & ops: invoice chasing and approvals: Monitor failed payments, follow up on overdue invoices, and route refunds/adjustments for explicit approval before execution.
Customer support automation: Handle common support requests, gather context, and draft responses while escalating edge cases or risky actions for review.
Agency reporting & client updates: Compile recurring reports and updates on a schedule, then request approval before sending externally to clients.
E-commerce back-office workflows: Process routine order/admin tasks, flag low stock or anomalies, and pause for human confirmation on high-impact changes.
Pros
Low barrier to entry: no-code setup aimed at non-engineers.
Strong visibility/control: live dashboards plus human approvals for sensitive steps.
Flexible model strategy: supports multiple LLMs and lets you bring your own subscriptions/keys.
Isolation by default: dedicated private server per workspace reduces noisy-neighbor and data-mixing concerns.
Cons
Self-hosting is not yet available (listed as “soon”), which may limit deployment options for some teams.
Autonomous agents still require oversight and good rules; misconfiguration can lead to incorrect actions despite approval gates.
Pricing includes limits by plan (agents, seats, included servers/model usage), which may constrain scaling without upgrades.
How to Use Rerun
1) Install the Rerun Viewer (rerun-cli): Pick one install method: (a) Download the rerun-cli binary for your platform from the GitHub Release artifacts, (b) via Cargo: `cargo binstall rerun-cli` (recommended for binaries) or `cargo install rerun-cli --locked` (build from source; requires Rust 1.92+), or (c) via Snap (community maintained): `snap install rerun`. After installation, run `rerun` to start the Viewer.
2) Install an SDK for your language (Python/C++/Rust): After installing the SDK for your language, set up a project that depends on Rerun. Choose the language SDK you want (Python includes the Viewer; C++ and Rust are also available). Ensure your SDK version matches the Viewer version because the data format is not stable across different versions.
3) Create a recording and save it to an .rrd file (example: Python): Log data into a recording stream and save it as an `.rrd` file. Example pattern from the docs: create a `RecordingStream`, call `save("run-1.rrd")`, set time (e.g., `set_time("step", sequence=t)`), and `log(...)` data each step.
4) Open a recording in the Viewer: Launch the Viewer with `rerun` and open the `.rrd` you created. You can also pass a file path to open it directly (the docs note: “rerun launches the Viewer. Pass a file to open it directly”).
5) Load an existing blueprint layout from a file (useful for Rust/C++ users): If you have a blueprint file created earlier (e.g., saved from the Viewer or created with the Python SDK), you can load it programmatically using `log_file_from_path`. Example from the docs: initialize/spawn the viewer, then `rr.log_file_from_path(path_to_rrd)` and `rr.log_file_from_path(path_to_rbl)` to apply the blueprint.
6) (Optional) Use a Catalog workflow for multi-recording query/training: Rerun’s catalog organizes recordings as queryable segments. Workflow described in the docs: (1) log/convert data to `.rrd`, (2) start a catalog server (or connect to Rerun Hub), (3) register the `.rrd` as a segment, then (4) visualize and query across recordings, and (5) connect a Dataloader to generate training batches.
7) Build from source using Pixi (if you need a dev build): If you want to build from source, do it inside the Pixi environment (the sources mention this as the easy path). Nightly dev wheels from the head of `main` are also available via the GitHub prerelease tag.
8) Build C++ API docs locally (contributors): C++ API docs are built with Doxygen and hosted on GitHub. To build them locally, run: `pixi run -e cpp cpp-docs`.
9) Troubleshoot common PyO3 build config issue (Rust/Python builds): If you see an error like “failed to parse contents of PYO3_CONFIG_FILE… failed to open PyO3 config file …/rerun_py/pyo3-build.cfg: No such file or directory”, it indicates the expected PyO3 config file is missing at that path. Ensure the file exists or your environment points `PYO3_CONFIG_FILE` to the correct location.
Rerun FAQs
Rerun is a platform for building, running, monitoring, and sharing autonomous AI agents. You describe the task, connect tools/models, and the agents run the work while you can watch runs, logs, and metrics from a dashboard.
Rerun Video
Popular Articles

Atoms: A Multi-Agent AI Platform That Transforms Ideas into Launch-Ready Products
May 22, 2026

Nano Banana SBTI: What It Is, How It Works, and How to Use It in 2026
Apr 15, 2026

Atoms Review — The AI Product Builder Redefining Digital Creation in 2026
Apr 10, 2026

Kilo Claw: How to Deploy and Use a True "Do‑It‑For‑You" AI Agent(2026 Update)
Apr 3, 2026







