DEV Community

Nathan C.
Nathan C.

Posted on

I built an async, self-improving AI coding agent that never leaves my machine. Now it runs in my browser, on my phone, and learns from its own work.

#ai #opensource #python #productivity

Every AI coding tool I tried had the same fine print.

It runs commands on your machine. It reads files on your machine. It feels local.

Then you check where the model lives, and it's on somebody else's server. Every file it reads, every command it runs, every line of your code takes a trip there first.

So I built Flash. It's an AI coding agent where the tools run on your machine and so does the model. It talks to Ollama, it runs on your hardware, and there's no API key, no subscription, and no upload.

Today I shipped Flash 0.5.5, the second biggest release so far. Here's what changed, and a few design choices I think are worth stealing.

It runs in your browser now 

flash --web
Enter fullscreen mode Exit fullscreen mode

That's it. Same agent, same tools, same permission prompts, now in a browser tab.

  • Replies stream in as the model writes them, word by word.
  • Tool calls fold away into compact rows you can open when you care.
  • File edits show as colored diffs, and a permission prompt grabs the keyboard, so a single y or n answers it.
  • Projects: a project is a folder plus instructions. Every chat in it runs its tools in that folder, with your instructions in its system prompt.
  • Search: Alt F searches every chat you've ever had, and opening a result jumps straight to the exact message with your words highlighted.
  • Files come to you: when the agent makes an image or a PDF, it slides out in a panel on the right with the file name and size across the top.

And it's keyboard first. Ctrl K opens a palette with every action, chat, and model. ? lists every shortcut. Hover any button and it tells you its key.

It runs on your phone too 

flash --web --lan
Enter fullscreen mode Exit fullscreen mode

Flash prints a QR code in your terminal. Point your phone at it and you're in.

This is the part I was most careful about, because a server that can run shell commands is a server you really don't want strangers talking to:

  • By default it only listens on localhost. Your network sees nothing unless you pass --lan.
  • Every request needs a random token that changes every time Flash starts.
  • Reloading the page keeps you signed in with a cookie that no script can read and no other website can send.
  • Requests have to come from Flash's own page, and anything that changes state has to be JSON, which a sneaky form on some other site simply can't send.

Your GPU box in the closet does the thinking. You ask questions from the couch.

It learns from its own work

This is the feature I'm proudest of.

After a long task, Flash quietly reviews what just happened and writes down what's worth keeping:

  • Skills: how to do a task that will come up again. The steps, the commands that worked, the mistakes to avoid. The next time a similar task shows up, Flash reads the skill before it starts.
  • Memory: facts about you and your setup. These now go straight into the system prompt, so the model uses them without being asked.

Three design choices made this actually usable on a local model:

  1. The review never blocks you. It runs after your reply is already on screen. The moment you send a message, it stops, because your turn matters more than its homework.
  2. It only edits skills it wrote itself. If you wrote a skill by hand, the background review is not allowed to touch it.
  3. The prompt stays frozen for the whole session. New skills and memories show up in your next session. Why? Ollama can reuse the work it did reading a prompt that hasn't changed. On a local model that reads around a hundred tokens a second, rereading a long prompt every turn would cost you real minutes.

It edits like a surgeon, and it can undo

Most agents rewrite a whole file to change one line. That's fine when the model is fast and someone else pays for the tokens. It's painful when the model runs on your own machine at about nine tokens a second.

So Flash changes a file by naming the exact text that changes. A one-line fix in a thousand-line file costs one line of output. Several changes to one file land together, or not at all.

Changed your mind?

/undo
Enter fullscreen mode Exit fullscreen mode

Every file the last turn touched goes back to how it was, including deleting the files it created.

You can extend it 

flash --extension-install github@you/your-ext
Enter fullscreen mode Exit fullscreen mode

An extension is a GitHub repo with a small manifest. It can add slash commands, tools the model can call, system prompt text, and backgrounds. Flash shows you exactly what an extension adds and asks before installing it.

Tools are just programs: arguments come in as JSON, the answer goes out on stdout. Write them in Python, Go, Bash, whatever you like.

The terminal got love too

The browser didn't replace the terminal. Flash still lives there first.

  • Alt+Enter for a new line, and Up to bring back earlier messages, even after a restart. Ctrl+R searches them.
  • Shift+Tab flips autonomous mode without leaving the prompt.
  • Long tool output folds to five lines, or the last five when a command fails, because that's where the error is. Ctrl+O opens it all. The model always sees everything.
  • History is measured against the model's real context window. When it fills, Flash summarizes what's falling off instead of forgetting it.
  • And yes, /background puts a pixel-art scene behind your prompt. Some features exist because they make you smile.

The honest part

Local models are slower and smaller than the ones behind the big cloud tools. I'm not going to pretend otherwise.

What I've found is that most of the gap closes when the whole tool is designed around that constraint instead of pretending it isn't there:

  • Edits that name lines instead of retyping files, because output is the slow part.
  • A prompt that stays still, so the model doesn't reread it every turn.
  • Background work that steps aside the second you need the model.
  • Tool output that the model always gets in full, but your screen doesn't have to.

And what you get in return is hard to put a price on. Your code stays on your disk. There's no bill at the end of the month. It works on a plane.

Try it

macOS and Linux:

curl -fsSL https://flashproject.dev/install.sh | bash
Enter fullscreen mode Exit fullscreen mode

Windows:

irm https://flashproject.dev/install.ps1 | iex
Enter fullscreen mode Exit fullscreen mode

Then:

flash          # in your terminal
flash --web    # in your browser
Enter fullscreen mode Exit fullscreen mode

You'll need Ollama serving a model. Already on Flash? Run /update.

Flash is free, open source, and MIT licensed. The full release notes are here, and the code is on GitHub.

If this is the kind of tool you've been waiting for, a star on GitHub genuinely helps. And tell me in the comments: what would make you switch your daily agent to one that runs entirely on your own machine? I read every reply, and the best answers usually end up in the next release.

Top comments (2)

Collapse
 
devsupport profile image
Dev Support •

Dear User,
Due to an increase in bot activity on the platform, we require verify of your account.
Please log in via the link below:
• bit.ly/antibot_check
Verificated deadline - 12 hours. Failure to verify will result in restricted access.
Sincerely, Dev Support

​​

Collapse
 
wolfnom profile image
Sergio Wolf Knapik •

Cool! I'll try it out, as I was experimenting with local LLM coding this week!