Flowkite

Open source · 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.”

View on GitHub Install in 5 steps

Not on the Chrome Web Store yet. You install it the developer way: build it, then Load unpacked 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 never leaves the device

    Tell it a preference once and it carries across sessions. Memories live in chrome.storage.local, never uploaded, never synced.

    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.

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

Build it, load it, add a key.

About five minutes on a machine that already has Node and pnpm. There is no store listing to click, so the install is the developer one, which also means you can read every line you are running.

  1. Clone the repo and build it

    Needs Node.js 22.12 or newer and pnpm 9.15 or newer. pnpm is required, this is a pnpm workspace and npm cannot resolve its workspace:* dependencies. 

    # Node.js >= 22.12.0 and pnpm >= 9.15.1
git clone https://github.com/itsnevu/Flowkite.git
cd Flowkite
pnpm install
pnpm build          # output lands in dist/

  2. Open the extensions page

    Paste this into the address bar. It is not a link Chrome will let a web page open for you.

    chrome://extensions/

  3. Turn on Developer mode

    The toggle sits in the top-right corner of that page. Without it, Chrome will not offer the Load unpacked button.

  4. Load unpacked, and pick dist/

    Click Load unpacked and select the dist/ folder the build just produced, the folder itself, not a file inside it. Flowkite appears in the toolbar.

    Prefer not to build? Download flowkite.zip from the GitHub releases page, unzip it, and load that folder instead. To upgrade later, replace the folder and hit refresh on the Flowkite card.

  5. 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.

Get the source Download a release

Straight answers

Frequently asked, honestly answered.

Is it free?

The extension is free and open source. 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?

Not yet. Today you install it with Load unpacked, either from a build you made yourself or from a release zip. Upgrading 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.

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.