Flowkite

Free AI web automation · multi-agent · local-first

A browser agent that asks first.

Type a task in plain language and Flowkite carries it out in your own browser. A Planner works out the approach, a Navigator clicks and types, and you watch the whole thing happen in the side panel. It shows you its plan before it touches a page, stops to ask before anything irreversible, and sends your data straight to the model provider you chose with the key you own. There is no Flowkite server in the middle.

Try asking: “Find the cheapest AeroPress filters across three shops and order them.”

Add to Chrome Or install it yourself

Free to download, and it stays free. Rather not go through the store? Grab the zip and load it yourself in chrome://extensions.

See it work

This is what asking first looks like.

One task, replayed in the side panel. The Planner proposes and waits, read-only tabs do the research, and the one step that spends money stops for a yes before it happens.

Flowkite side panel · replay

Find the cheapest AeroPress filters across three shops and order them.

Planner · proposed plan

  1. Search three shops in parallel, read-only tabs
  2. Compare totals with shipping included
  3. Check out at the cheapest: a purchase, so it will stop and ask
Approve & run Adjust

Approved. Nothing ran before this.

Three shops searched at once, tabs with no click, no type, no submit

Cheapest with shipping: $14.20

Sensitive action · needs a yes

The Navigator wants to click Place order. That is a real purchase of $14.20.

Allow once Deny

Order placed, confirmation number saved to the chat

Done. Ordered from the cheapest shop at $14.20, $3.10 under the next best.

What it actually does

The interesting part of an agent is where it stops.

Most browser agents ask for your logged-in session and then act. Flowkite is built the other way round: every one of these is a place it hands control back to you, or refuses to spend something you did not agree to.

  • Plan preview, then undo

    Before it touches a page the agent writes out its plan and waits. Approve it and it runs; reject it and nothing happened.

    Undo rolls back the last step: the page navigates back and the agent forgets the step, so it re-plans from the restored state instead of building on something you turned down.

  • Sensitive actions need a yes

    Buying, deleting, submitting a form, downloading a file or typing into a password field all stop and ask you first.

    The check reads the actual DOM element the agent picked, its label, its type, its aria-label, not the model's description of what it thinks it is doing.

  • Memory that stays on your device

    Tell it a preference once and it carries across sessions. Memories live in chrome.storage.local, never uploaded to us, never synced. When memory is on, the ones matching the site go into the prompt sent to your own LLM provider.

    Settings lists every stored fact with a delete button beside it, and one switch that turns the whole thing off.

  • Research in parallel tabs

    Independent lookups, the same product across three shops, run at the same time, each in its own background tab, then merge into one answer.

    Those tabs are read-only by construction: the action set they are handed contains no click, no type, no submit. The one place you could not intervene is the one place nothing can act.

  • Hybrid routing, fewer tokens

    Assign an optional cheap model and routine navigation steps go to it, while your good model handles the thinking.

    Anything that is not routine escalates: a failure to recover from, a dense page, a step reasoning over a screenshot, the first step of a new plan.

  • Guardrails on untrusted text

    Page content is wrapped in explicit delimiters and scanned before it reaches the model, so text sitting on a page cannot pose as an instruction to the agent.

    Known prompt-injection and task-override patterns are stripped, and sensitive strings are caught on the way out.

  • Correct it without stopping it

    Watching it take the wrong turn on step three used to leave you one button: stop, and lose everything it had worked out. Now you just type.

    A correction keeps the plan's progress and overrides its direction. It lands at the next step boundary, never underneath a model call already in flight, and the plan is rewritten so the old route cannot argue with your new one.

  • Hand it a file to upload

    Attach a CV, an invoice, a photo, and the agent can put it into a page's upload field, including the styled buttons that hide the real input somewhere else in the markup.

    The bytes stay in session storage, gone when Chrome closes, and never enter the prompt. Every upload asks you first: the file leaves your machine the moment it runs.

  • Watch a page, hear nothing until it moves

    A daily task can run on a schedule with nobody watching. Turn on watch and it compares what it collected with the run before, and only notifies you when something actually changed.

    A price that moved reads as one changed row, not a deletion and an insertion. Prose answers are never compared, because a model rewords the same fact every morning and that would notify you every morning.

How it works

Two agents, one browser, no server.

Flowkite splits the job into two roles: one decides what to do, the other does it. All of it runs inside the extension's service worker on your machine. The only thing that goes out is the request to the model provider you configured.

  1. Planner

    Reads your task and works out the approach: which sites, in what order, what "done" will look like. It re-plans when the page turns out not to be what anyone expected.

    Decides when the task is finished. Required.

  2. Navigator

    Does the actual work in the page: reads the DOM, clicks, types, scrolls, navigates. Cross-origin iframes are read too, so embedded checkout and login widgets are not invisible to it.

    If a page re-renders mid-step, the action is retried against fresh state. Routine steps can be handed to a cheaper model you nominate; anything harder stays with your good one.

The plan gate sits in front of both. The first plan of every task is shown to you and waits for approval, and only the first, so re-planning mid-task does not nag you. Once things are moving, undo is the escape hatch: it takes the page back and deletes the step from the agent's history, so the next plan is built on the state you kept, not the one you rejected.

Bring your own model

Eleven providers, plus anything OpenAI-compatible.

Assign a model to each role, Planner, Navigator, and optionally a cheap Fast model for routine steps. Mix vendors freely; nothing assumes they came from the same place.

  • OpenAI
  • Anthropic
  • Gemini
  • Grok
  • DeepSeek
  • Groq
  • Cerebras
  • Azure OpenAI
  • OpenRouter
  • Llama
  • Ollama local
  • Any OpenAI-compatible endpoint

Keys are stored locally in chrome.storage.local and go straight from your browser to the provider you picked. They are never proxied through a Flowkite server, because there isn't one, no backend, no account, nothing to sign up for. If your endpoint speaks the OpenAI API, point Flowkite at its base URL and it works, including a model running on your own machine through Ollama.

Quickstart

Add it to Chrome, then add a key.

About two minutes. Almost everyone should take the first path; the second exists for people who would rather hold the files themselves, and installs exactly the same build.

  1. Add it to Chrome

    One click from the Chrome Web Store, and Chrome keeps it up to date on its own. Flowkite appears in the toolbar when it finishes.

    Add to Chrome

  2. Add an API key and assign models

    Open the side panel, click the settings icon, paste a key from any supported provider, then give the Planner and Navigator a model each. Add a cheap Fast model if you want routine steps routed away from your expensive one.

    Plan approval and sensitive-action confirmation are both on by default. Leave them that way until you trust it.

Rather install it by hand?

Download the build and load it yourself. Same files the store ships. The trade is that Chrome will not update it for you: when a new version lands, download it again and replace the folder.

  1. Download flowkite.zip and unzip it. Keep the folder somewhere you will not delete by accident, because Chrome loads it from where it sits.

  2. Paste this into the address bar. It is not a link a web page is allowed to open for you.

    chrome://extensions/

  3. Turn on Developer mode with the toggle in the top-right corner. Without it, Chrome will not offer the Load unpacked button.

  4. Click Load unpacked and pick the unzipped folder itself, not a file inside it. Then carry on from step 2 above.

Add to Chrome Download the zip

Straight answers

Frequently asked, honestly answered.

Is it free?

The extension is free to download. There is no paid tier, no trial and no account. What costs money is the model: you bring your own API key and your provider bills you directly for what the agent uses. Run a local model through Ollama and even that goes to zero.

Where do my API keys go?

Into chrome.storage.local on your own machine, and nowhere else. Requests go straight from your browser to the provider you configured. Flowkite has no backend to proxy them through, so there is no server of ours that could ever see a key. Uninstall the extension and they are gone with it.

Does it work with local models?

Yes, Ollama is supported directly, and any OpenAI-compatible endpoint works if you give it a base URL. That setup has zero API cost and nothing leaves your machine at all. One caveat: local models want more specific prompts. Break the task into explicit steps rather than handing over one high-level, ambiguous instruction.

Is it on the Chrome Web Store?

Yes — one click from the Chrome Web Store, and Chrome keeps it updated for you. If you would rather not go through the store, the zip on this page installs with Load unpacked — upgrading that copy means replacing the folder and pressing refresh on the Flowkite card in chrome://extensions. See the Quickstart for the full sequence.

What data leaves my machine?

Page structure, and, only if you switch vision on, screenshots, sent to the LLM provider you chose using your key; once data reaches them their policy governs it, so pick one you are comfortable with. Builds that ship with an analytics key also send anonymous usage events to PostHog, a task started, completed, failed or cancelled, plus the bare hostname of each domain the agent visits, which Options → Analytics switches off, and a copy you built yourself carries no key, so it never runs at all. Your settings, task history, API keys and memories stay in chrome.storage.local and are never uploaded to us.

Which browsers are supported?

Chrome and Edge are fully supported. Firefox and Safari are not. Flowkite is a Manifest V3 extension built on Chrome's own APIs. Other Chromium browsers such as Brave, Arc and Opera may well work, but they are not tested.