Using Fulminare

Open the app, describe the outcome you want, and press send. Fulminare plans the steps, spins up a machine, and works the task to done, showing you every move in a live timeline. You don't manage tools or steps; you describe the result.

1. 1Describe the job as an outcome, not a how-to.
2. 2Pick a model (or keep the default).
3. 3Watch the plan and tool calls stream in.
4. 4Review the result, or flip to Overnight and walk away.

The composer also takes a paperclip attachment (any file; it's copied straight into the sandbox for the agent to read) and, in browsers that support it, a mic button for dictating instead of typing.

The best prompts name the outcome and any constraints, and let the agent figure out the rest.

Interactive keeps you in the loop, great for quick tasks you want to watch and steer. Overnight hands the job off entirely: Fulminare keeps a sandbox alive, works unattended to completion, never blocks for input, and leaves a morning brief. Toggle it in the composer or queue one from the Overnight tab.

Route each session to the brain that fits the job. Switch anytime, even mid-session.

Both modes run Anthropic's Claude models through OpenRouter, and we move to newer ones as they ship. Deep thinks harder on each step than Fast and counts 2× against your monthly token budget.

Fulminare drives a real machine with the full agentic toolset. You never call these directly. It reaches for the right one on its own.

When the agent opens a page, a panel slides in on the right with two tabs. Browser shows the live page (real headless Chrome, not a description of one) plus the page's own console output (log/warn/error), so you can actually see what broke if something did. Cookies and logins persist across calls within a session, the same way they would in a normal browser tab.

Files is a read-only, live view of the sandbox filesystem: expand folders, open a file, and it's fetched straight from the running machine, not a cached snapshot. It's the same box the agent is working in, so what you see is exactly what it sees.

Autonomy with receipts. You see every tool call as it happens and can stop the run at any moment. You pick the model and its per-session token budget, and overnight runs flag decisions rather than guessing on anything irreversible.

Each chat gets its own sandbox, never shared with another chat or another user. It's paused the moment a turn ends, so nothing runs or bills between messages, and your next message resumes the same machine with its files and installed packages intact. A sandbox untouched for 14 days is deleted; files the agent delivered stay saved in the chat.

Fulminare works across the apps around the job, and reaches anything else through the browser.

Need something that isn't listed? The agent can request a custom integration mid-run. It asks for a name and an API token right there in the chat, and once you approve it, it's available to every future session the same way a built-in app is.

Fulminare remembers. Run the one-time setup in Settings to tell it who you are, what you work on, and how you like things done, and it recalls this automatically from message one in every future session, no re-explaining.

It also picks up context as you go: preferences, recurring projects, and decisions you've made stick around in a searchable memory store. You can review or forget anything it's remembered at any time from the same settings panel.

Every plan, including Free, has the same kinds of limits: concurrent live sandboxes, runs per day, a monthly token budget, and overnight runs per month. Exact numbers for Free, Lumen, Vivace and Maximus are on Pricing. Need more for a team? Reach us from the same page.

Track usage live from the meter in the app sidebar. Click it for a full breakdown with reset times. Limits are checked on the server before every run starts. The one exception is an outage of the usage check itself: if it can't be read, the run is allowed rather than blocked.