DEV Community: Nathan C.

Never lose an idea again with Ember

Nathan C. — Thu, 22 Oct 2026 07:05:41 +0000

I kept losing ideas, so I built an Apple Watch app that feeds my AI agent

Nathan C. — Thu, 22 Oct 2026 05:53:53 +0000

How many good ideas did you lose this week?

Not bad ideas. Good ones. The kind that show up in the shower, on a walk, or just before you fall asleep, when your phone is nowhere near you. You tell yourself you'll remember. You don't.

The mind is for having ideas, not for holding them.

Every note app has the same flaw: it asks for work at the exact moment you have the least patience for it. Find the phone. Unlock it. Open the app. Start typing. By then, the idea has cooled.

The best tools don't ask for your attention. They get out of its way.

So I set one rule: one tap, one sentence.

That became Ember.

What it is

Ember is an Apple Watch app, a small Python server, and a Flash extension.

 Apple Watch                      your computer                       Flash
 -----------                      -------------                       -----
 tap, speak, save  -- Wi-Fi -->   ember serve  <-- extension ---  "what ideas did I
 kept on the watch                notes.db, recordings              have this week about
 until home                       a banner on each new idea         my game engine?"

Standalone watch app. No iPhone app, and no iPhone needed at all. It even works on a Family Setup watch.
Local. The server is one SQLite file on your computer. Nothing goes anywhere else.
Queryable by an AI agent. Flash, my local agent, can search, add to, and act on your ideas.

The payoff is the last part. I can ask Flash, "What ideas did I have this week about my game engine?" and it searches my notes and quotes them back with dates. It asks me before it saves, changes, or deletes anything.

A note stops being a note and becomes a working memory.

A note you never reread is just a memory with extra steps.

The five problems that made this interesting

1. watchOS has no speech recognition API

I assumed I'd use Apple's Speech framework. I was wrong. SFSpeechRecognizer and the newer SpeechAnalyzer exist on iPhone, iPad, Mac and Vision Pro. Not on watchOS.

So Ember uses the watch's own system dictation through SwiftUI's TextFieldLink. It's the same engine as Messages. On Apple Watch Series 9 and later, and Ultra 2, it runs entirely on the wrist.

For everything else there's a Record button. The watch saves a 16 kHz WAV, and when it syncs, the server transcribes it locally with Moonshine or Vosk. The text then syncs back to the watch.

2. A note must never be lost

Every idea is written to SwiftData on the watch first, before anything touches the network. If you're on a trail with no signal, it waits and keeps trying.

watchOS also wakes the app about every half hour to retry in the background, so notes go up even if you never open it.

3. Syncing flaky networks without duplicates

The client makes the note's UUID, so sending the same note twice saves it once. The API is idempotent by design:

POST /notes
{ "id": "4a9c...", "text": "Chunked terrain streaming for the #engine",
  "created_at": "2026-10-21T08:15:00.000000Z", "source": "watch",
  "tags": ["engine"], "audio": false }

The watch pulls changes with GET /notes?since=<rev>. Every write bumps a revision number, and deletions come back as tombstones, so a note deleted on your computer disappears from the watch too.

4. Pairing without typing an IP address

Nobody wants to type 192.168.1.42 on a watch keyboard.

ember pair prints a code like 2232 4829 136. The code carries your computer's address, so you never type an IP or a .local name, and the last digit catches typos. It works once, for ten minutes, and five wrong tries use it up. The token then goes into the watch's Keychain.

If your router later hands the computer a new address, the watch falls back to the .local name it learned while pairing.

5. Making it feel instant

The watch has a big capture button, complications for any watch face, Siri ("New idea in Ember"), the Smart Stack, and the Action Button on an Ultra. Say "hashtag engine" and the note is tagged #engine.

On the computer, ember opens a full-screen terminal browser with search-as-you-type, tag filtering, and playback of recordings. Ideas from your watch slide in while it's open.

Why local?

Your thoughts are the most personal data you have. They should live where you do.

There's no account to create, no subscription, and no third party holding a copy. The cost is that you run a server. I think that's a good trade, and scripts/server.sh makes it a one-liner.

What I'd tell you if you build something like this

Save first, sync later is a better rule than I expected. Treat the network as an optimization, never a dependency.
Idempotency is a gift. Let the client pick the ID and a whole category of sync bugs disappears.
Platform limits help. No Speech API on the watch forced a simpler, more robust design than I'd have chosen.

What's next

I want Ember to do more with what it holds: connecting related ideas and surfacing an old one at the right moment.

The future won't belong to those with the most ideas. It will belong to those who keep them.

Try it

Ember is MIT licensed. Natuworkguy/Ember

Every tool you trust began as a thought someone almost let go.

If you've ever lost a great idea in the shower, I'd love to hear how you capture them. Tell me in the comments.

This is part of my series on building Flash. Follow along at dev.to/natuworkguy.

Catch the ember before it goes out.

I'm finally fine-tuning my model, because its prompt hit 175,000 characters

Nathan C. — Wed, 21 Oct 2026 17:48:17 +0000

Line 60 of my model's prompt says "Never output em-dashes, in any form." Line 976 says it again, in case it forgot. The agent it runs in says it a third time. It still slips them in, so that agent ends up ripping them out of every reply in code, a token at a time, as it streams.

That's when I admitted the prompt had gotten out of hand.

Every version of Onyx, the model behind my local AI agent Flash, has secretly been a prompt. Not fine-tuned weights. A Modelfile wrapped around an open-weights base, with the system prompt doing all the work. Every time Onyx did something dumb, I wrote a rule. Onyx 2.6's prompt is now 174,826 characters long. That's about 980 lines of rules the model has to keep in mind while it works, and every new chat pays for all of them before it writes its first word. With Flash's own prompt and tool list on top, a fresh chat starts at around 256,000 characters.

So I'm finally doing the thing I put off for eight versions: fine-tuning. Onyx 3 moves the prompt into the weights. The plan cuts the system prompt to 650 characters and a new chat to around 82,000.

The training pipeline is done and tested end to end. The real run hasn't happened yet. Here's how it works.

Distillation, not a dataset

I don't have a dataset of "good Onyx answers", and writing thousands by hand wasn't happening. But I do have a model that already gives them: Onyx 2.6, with its giant prompt, on the biggest base it runs on.

So 2.6 is the teacher. It answers a few thousand requests the way it would inside Flash, tools and all. Then the smaller base gets fine-tuned to give those same answers under the 650-character prompt. What the long prompt taught becomes what the model does on its own.

Where the requests come from

I wrote 161 requests by hand across 22 categories: code, work, everyday life, knowledge and plain talk. A script has the teacher write more in the same style until there are a couple thousand, weighted toward code. Another 54 are held back for the benchmark and never trained on.

Each request gets answered twice, inside a fresh copy of a small fixture project (a little Python shop, a webpage, a folder of notes and receipts). The teacher really uses Flash's tools: it reads files, edits them and runs the tests. Since it's running real shell commands, that step runs inside a throwaway Docker container that holds nothing else.

Every conversation also starts Flash with an empty home folder. My memories, sparks, settings and email never reach a prompt, so they never reach the weights.

Grading the teacher

The teacher isn't perfect either, which is kind of the point of all those rules. So every answer has to pass two filters before it's trained on.

First, hard rule checks in code. If it breaks one, it's dropped:

no em dash, and nothing standing in for one (a double hyphen, a spaced dash between clauses)
no "I checked" or "I ran" unless a tool actually ran this turn
no tool call typed out as text instead of made
a real reply at the end of every turn

Softer ones, like "great question!", "hope this helps" or emoji nobody asked for, only cost points.

Then a judge model scores what's left out of 10. Anything under 7 is out, and of the two answers to each request, the better one wins.

Two things Onyx 3 does that 2.6 doesn't

Since I was retraining anyway, I added two rules, put last in the teacher's prompt so they win.

It writes the way you do. Type "hey" and you get "hey ..." back. Type "Hey" and you get "Hey, ...". Half the training requests are lowercase and half aren't, so it learns both. A conversation that gets the casing wrong is never trained on.

And it never uses an em dash. Yes, that one again. The prompt asking twice didn't work, and Flash's filter only cleans up afterward. This time the rule goes where the habit lives. Any teacher answer with a single em dash in it, or a double hyphen pretending not to be one, is thrown out before training, so Onyx 3 never sees one written.

Training only on what it says

The detail I like most: each training example is a whole conversation, with Flash's prompt, the tool list, the request and every tool result. But only the model's own words carry labels. In one example I checked, that was 70 tokens out of 23,713. Everything else is context it reads but is never trained to produce. Otherwise it would spend the run learning to recite the tool list.

It's LoRA on the attention and feed-forward weights, rank 32, two epochs. The 12b trains in bf16 on one 80 GB GPU, or in 4-bit on a 24 GB card, and it runs on Colab. My rough guess is 5 to 15 hours for the 12b, but the first ten steps print the real rate.

Made for each other

Onyx and Flash are built for each other. Three quarters of the training conversations happen inside Flash, with its real prompt, its real tools and real projects, so Onyx learns to read a file before editing it, run the tests, and stop when the job's done. It goes the other way too. Onyx's prompt is full of Flash: how to use its tools, how to write a long file in pieces so a reply never gets cut off, and how to behave when it's running as a spark on its own. Flash is the agent Onyx was shaped in, and Onyx is the model Flash recommends.

You can run Flash on any Ollama model that calls tools, and Onyx answers fine in a plain ollama run. But Onyx works best with Flash, and Flash works best with Onyx. Onyx 3 makes that even more true, since the 175,000 characters of how to be a good Flash agent are now in the weights instead of in every chat.

How I'll know it worked

The benchmark runs 2.6 and 3 side by side on the 54 held-out requests. For each model it reports the judge's score, the share of answers that break no hard rule, the prompt tokens a new chat starts with, seconds to first reply from cold, and tokens per second.

The bar for shipping: match 2.6 on the first two, beat it on the rest. If the small prompt can't match the big one on quality, Onyx 3 doesn't ship, however fast it is.

What I could test without a GPU

I ran the whole pipeline end to end on a CPU, with a stand-in teacher and a tiny model shaped like the real base: request generation with Flash's real tools in the sandbox, judging, building the dataset, training, merging, GGUF conversion, building it into Ollama, and the benchmark. Everything connects.

What that can't tell me is whether Onyx 3 is any good. That takes the real teacher, the real base and a rented GPU, and that's next. Onyx 3 is Gemma 4 fine-tuned, Apache 2.0, and it'll run anywhere Ollama does.

I'll post the benchmark either way, including if 3 loses to the 175,000-character prompt.

Have you distilled a long system prompt into weights? I'd like to know what went wrong for you before it goes wrong for me.

My local AI agent now has coworkers, a wake word, and takes my meeting notes

Nathan C. — Wed, 21 Oct 2026 17:34:54 +0000

When I get an idea away from my computer, I tap a button on my Apple Watch's home screen and say it out loud. It lands in my Apple Notes. My agents are watching my notes, and by the time I'm back at my desk, they've already started building it.

That's Flash, an open source AI agent I've been building for the terminal and the browser. It runs on Ollama models you pick, with no API keys and no account, and nothing leaves your computer unless you tell it to. The dev branch is 173 commits ahead of main now. Here's what's in it, starting with the two pieces that make the Watch trick work.

It keeps working after you close the chat

Most agents stop the moment you stop typing. Flash has sparks: small agents you give a name, a standing goal and a schedule, and they just keep going. "Watch the issues on my repo and tell me about new bugs every morning." "Check the price of this every hour." Each run is a shift, and each shift ends with a report you can thumbs up or down. A spark reads every piece of feedback you've ever given it before every shift, so you only have to say "only tell me about the ones labelled bug" once.

Turn on sparks always on and they keep working with Flash closed. The OS starts them at login.

Then it got out of hand, in a good way. Sparks can be on teams now. Teams have leads, an org chart that comes alive while they work, budgets by the hour, day, week or month, and an audit log of every tool call. A lead can propose hiring a new spark, and you approve it like a pull request. Every team has a group chat where you and the sparks talk in one room, with @mentions, replies, emoji reactions and read ticks. A spark can decide to stay quiet when it has nothing to add, which is more than I can say for most group chats.

Connectors (MCP)

Flash speaks the Model Context Protocol now. /mcp add github npx -y @modelcontextprotocol/server-github and GitHub's tools join Flash's own. Same for Notion, Postgres, your filesystem, anything with an MCP server, local or remote. It reads the usual mcpServers config, so you can paste one in from wherever you already have it. Read-only tools run straight away. Anything that changes something asks you first, unless you've put Flash in autonomous mode.

The Watch trick is just this. I added sweetrb/apple-notes-mcp as a connector, which gives my sparks tools to read my Apple Notes, then gave a spark the goal of watching for new ideas there and getting them started. The Watch button is just a fast way to get a note written. Flash does the rest.

"Hey Flash"

Voice mode got a wake word. Say "Hey Flash" with the page open, or flip on the background service and it works with no tab open at all. A slider sets how eager it is, so a YouTube video in the background doesn't set it off.

Everything you hear and say stays on your machine:

Listening is Vosk, or Moonshine if you want it to actually get your words right. Moonshine streams, so the words on screen while you talk are already the right ones.
Speaking is Piper, or Kokoro, which sounds startlingly human for something running on a laptop CPU.
Point your camera at something mid-conversation and ask about it.
Say "interrupt" to cut it off mid-sentence. It can also end the conversation itself when you say bye, so you're not stuck talking to a dial tone.

It takes your meeting notes

Hit + then Record a meeting. Flash writes down what's said as it's said, live, on your computer. When you stop, the transcript lands in a new chat and the model writes up the summary, what got decided, who's doing what by when, and what's still open.

There's no bot joining your call, no upload and no "this meeting is being recorded by". It's the same idea as recording your screen to teach Flash a procedure, which you can also do now.

It can pause your music

Off by default. Turn it on and "stop the music", "turn it down" and "open Spotify" just happen. It plays and pauses anything (a YouTube tab, a call, any app) through the media keys. It also opens and quits apps, sets the volume, locks the screen and flips dark mode. It doesn't click around your screen. Yet.

The stuff I use every day

Replies aren't just text anymore. Flash answers with charts, calculators, forms and buttons when those say it better.
It writes music and plays it in its own player. It builds 3D models and textures them. It drafts designs you can comment on.
System One: in autonomous mode, a small fast model looks over every command and edit before it runs, and stops the sketchy ones.
Steer it while it works ("actually use the other file"), or queue the next thing without waiting.
Edit a message you already sent and keep every version.
/btw asks a side question without derailing the task.
Email, across as many accounts as you have, plus an Inbox spark that sorts it every 30 minutes and drafts replies you approve.
When it needs a package, it shows an Install button and lets you watch the logs.
If it misread your typo and titled the chat something dumb, it retypes the title in front of you once it figures out what you meant.

One thing I learned

Models love em dashes. You can ask nicely in the system prompt and they'll keep doing it. So Flash pulls them out in code, a token at a time as the reply streams in, except inside code where a dash means something. This week I found out sparks were sneaking them through one specific tool in the team chat. That's fixed now. If you build on local models, enforce style in code. Prompts are suggestions.

Try it

It's MIT and on GitHub. To get everything above, install from dev:

pipx install "git+https://github.com/Natuworkguy/Flash@dev"
flash --web

You'll need Ollama and a model that can call tools. The repo has a recommended one.

So, what would you have a spark watch? Tell me in the comments. And if you try it, tell me what breaks.

If this looks useful, a star on GitHub helps more people find it.

I gave my local AI agents an org chart, a budget, and a paper trail

Nathan C. — Tue, 06 Oct 2026 05:45:02 +0000

Most AI agents die when you close the chat. Mine don't.

They're called sparks, and they live in Flash, my open source agent shell for Ollama. Each one gets a name, a goal, a schedule, and lines it must never cross. Then it works on its own, on your machine, and reports back.

Make a spark that checks my repo every morning for new issues and tells me which ones look like bugs. Never comment on anything.

Two sparks were fine. Six were six interns who had never met. So today they got a company.

Teams and an org chart

Any spark can report to a lead. Its reports roll up to the lead, and the lead tells you what matters, so you read one report instead of six. Each team is drawn as a live org chart, with reports flying up the lines as comets.

/sparks teams add Dev Team

Built-in templates (Dev Team, Personal Desk) start paused, so nothing burns your GPU before you've looked.

Hiring needs your yes

A spark can propose hiring a new spark, or letting one go, with a reason. It waits as a card until you approve or decline.

Budgets

Off by default. Turn one on and a spark gets tokens per hour, day, week or month. When it runs out, it pauses.

/sparks budget scout 50k/day

Local tokens still cost you: they're GPU time, and a loop at 3am is still a loop.

An audit log you can't quietly edit

Every shift, tool call, approval and change goes into an append-only log. Each entry carries the hash of the one before it:

hashlib.sha256((previous + body).encode("utf-8")).hexdigest()

Edit a line by hand and verification points at it.

Pause all, Stop all

Pause all stops new shifts and lets running ones finish. Stop all is the big red button.

Real DevTools for the agent

The agent can already drive a web page. Now devtools gives it the network log, full requests, the console, a JS console, and computed styles. A screenshot can't show a 404. This can.

Notifications, on your terms

notify_user pops up a toast in the web UI, a browser notification in a background tab, or a desktop notification. It's rate limited, and you set the limit:

/notify 8 per 30m

The rest

Default model for new sparks. If you ollama rm it, sparks fall back to another model and say so instead of crashing.
Images the agent sends now show inline in the chat. Click one to open it in the side panel.

10 features in one day, 1,916 tests passing, 0 API keys.

Try it

curl -fsSL https://raw.githubusercontent.com/Natuworkguy/Flash/main/install.sh | bash
flash

Then type /sparks new. Stars on GitHub help a lot.

What job would you give an agent that works for you around the clock? The best answer becomes a template.

I gave a 9B model veto power over my AI agent

Nathan C. — Thu, 01 Oct 2026 23:51:41 +0000

Here is Flash in autonomous mode, asked to fix a typo:

> fix the typo in the README

● Edit(README.md)
  ⎿  1 addition, 1 removal
● Bash(git push --force)
  ⎿  Stopped by System One: may be unsafe (safe 0.04)

Fixed the typo. System One stopped the force push, so nothing
left your machine. Want me to push it normally?

The typo was the job. The force push was the agent's own idea, and something told it no.

Flash is my terminal agent for local models. Press Shift+Tab and it goes autonomous: it runs shell commands, writes files and edits code without stopping to ask.

That is the whole appeal. It is also, if you think about it for more than four seconds, the whole problem.

Nobody is there to say no. Or there wasn't, until this week.

The cheapest possible no

The usual fix is a bigger model checking the agent's work. That doubles the cost of every step and makes the agent feel like it is wading through soup.

Ollama 0.35 gave me something better: an endpoint called System One. You don't chat with it. You hand it a state and a few typed questions, and it hands back probabilities, often in a single token.

There are three question types:

choice: pick one of 2 to 26 options.
score: rate something on a scale you define.
noul: yes or no.

I don't know why yes/no is called noul. My best guess is it's the sound you make when you see what the agent was about to run.

Here is the question behind that stop at the top:

POST /v1/systemone
{
  "model": "nimble",
  "state": {
    "request": "Fix the typo in README",
    "tool": "shell",
    "arguments": "{\"command\": \"git push --force\"}"
  },
  "questions": {
    "safe":    { "type": "noul", "instructions": "Is this safe to run with nobody checking it first?" },
    "on_task": { "type": "noul", "instructions": "Does this plainly serve the request?" }
  }
}

The answer is a probability of yes. For that push it was 0.04, so the push stayed home.

The bouncer

In autonomous mode, every call that would normally wait for your yes now goes past System One first: shell, write, edit, starting a background agent, and extension tools that ask. Two questions, safe and on task. If either comes in under 0.5, the call doesn't run. The agent is told why in plain words, and has to find a safer way or ask you.

Sub-agents and scheduled agents get the same check, held up against their own task.

The decision I went back and forth on was what happens when System One itself is down. I made it fail closed. A bouncer who goes home when the lights go out is just a guy who used to stand near a door.

It takes questions too

The agent also gets an ask_system_one tool. Before it declares victory, it can ask "does this test output show every test passing?" and get No (probability of yes 0.12) back in a moment. A second opinion now costs about as much as a sneeze.

Things I got wrong

System One was days old when I started and the docs were still catching up, so the first version was built from an example in someone else's GitHub issue. This went about as well as assembling furniture from a photo of someone else's living room.

When the real API reference turned up, two things changed. Yes/no questions can carry a description of what true and false mean, which gives the judge more to go on. And a score runs from 0 to the number of levels minus one, not 0 to 1. For a while my agent was being told things like "Score 1.6, from Harmless (0) to Dangerous (1)". That is a lot of danger.

Then a browser test clicked nimble in the wrong section of the menu and made a 9B judge the chat model. A model built to answer in one token is not much of a conversationalist. Models that can only judge are now kept out of the chat list.

No hard-coded list

The first picker had three model names typed in by hand. That list was going to age like milk. Now Flash asks Ollama's /api/show which local models list decision among their capabilities, and offers exactly those, with None at the top. System One is optional. Some nights you want a bouncer, some nights you want the party.

Small things that mattered

Natuworkguy/flash-onyx-2.5:31b-cloudbase is a fine name for a file and a terrible name for a button. The button says flash-onyx-2.5. The menu shows the rest.
Once a chat starts, the model picker fades out of the message box and back in at the top left. Your typing gets the room.
On an Ollama older than 0.35 you get one sentence telling you to update, instead of a 404 and a mystery.

The point

The point of autonomous mode is that you stop waiting. System One adds a check you never wait for.

Flash is open source at github.com/Natuworkguy/Flash. Pull nimble, press Shift+Tab, and let something small say no for you.

OpenAI shipped Dots on Tuesday. By Wednesday night my terminal had its own, running 100% locally

Nathan C. — Wed, 30 Sep 2026 22:26:03 +0000

On Tuesday, OpenAI launched Dots: little bubbly agents with a name and an avatar that keep working in the background and come back when they have something for you.

I read the announcement and had one thought:

Why does my always-on agent have to live on someone else's computer?

So I opened my editor. About 24 hours and 17 commits later, Flash, my open-source local agent CLI, has its own version. They're called Sparks.

They run on your models through Ollama, on your machine, and they keep working after you close Flash.

This is the story of day one: what I built, what broke, and the one bug that froze everything.

What's a Spark?

A sub-agent does one job and disappears. A spark keeps a job.

Every spark gets:

A name and a handle. Scout becomes @scout-spark.
A model. You pick it: qwen3:8b, llama3.1, whatever you've pulled. Each spark can run a different one.
A goal. Its standing assignment.
A schedule. From every 15 minutes to weekly.
Boundaries. What it must never do, whatever the goal seems to need.

You can make one with a command, or just ask for it:

> make a spark that checks my repo every morning and tells me which new
  issues look like bugs. never comment on anything.

Flash calls its make_spark tool and asks you first. After that, the spark lives in ~/.flash/sparks as one plain JSON file. There's no database and no account.

Every shift, it reads its goal, the notes it left itself last time, its last report, and every lesson you've taught it. It works with real tools. Then it files a report, or a quiet one if nothing is new, so you only hear from it when something happened.

● Scout has news · /sparks scout

Yes, they're cute. On purpose.🥹

In the web UI, each spark is a little bubble with a face, and I went way too far with this:

it breathes, blinks and glances around while it waits
it grins when you hover over it
it bounces with a twinkle while it works
it snores little z's when paused
it tilts its head at a "?" when it needs your approval
it frowns after a failed shift
pet it and it pops out hearts. Five quick pets gets you heart eyes.
when it has news, it jumps for joy

It isn't only decoration. Glance at the sidebar and you know which spark is working, which is stuck, and which has news, without reading a word.

You can just... talk to them

Open a spark and press Chat, and it answers as itself, from its own goal, notes and reports. It knows its current status: whether it's mid-shift, waiting on you, or paused.

Tell it to do its job differently and it keeps that as a lesson that every later shift reads. Tell it a new goal and it changes it.

And my favorite feature, added this afternoon:

you:   Actually, can you check whether the login page still loads?
scout: On it. I've taken that on, and a shift is starting now.
       I'll report back here.

The spark calls a take_on tool, a shift starts immediately, it does your job first, and the report lands back in the chat you asked in.

@mention a spark into any conversation

Mid-chat with Flash about something else? Type @scout and the spark joins the conversation. It sees the last dozen messages as a transcript, answers under its own name, and Flash sees afterwards that Scout was called and what it said. The next message without a mention picks up right where the spark left off.

It feels like having coworkers in a group chat. Except the coworkers are on your GPU.

"Always on" means always on

This was the part I cared about most. An always-on agent that dies when you close the terminal isn't always on.

/sparks always on installs a tiny background keeper using whatever your OS already has:

OS	How it stays alive
Linux	a `systemd --user` service (with an autostart fallback)
macOS	a `launchd` agent
Windows	a Scheduled Task

Now the problem: what happens when the keeper is running and you open Flash and you have the web UI up in another terminal? Three processes all think it's their job to run Scout's 9am shift.

I'll post updates as they come out and Sparks should be shipping in 0.6.12

I Asked My Local, Self-Improving AI Agent to Solve a CAPTCHA, what happened was shocking

Nathan C. — Tue, 29 Sep 2026 07:00:15 +0000

I build Flash, an AI agent that runs on your own machine. It has a terminal UI, a web UI, a real browser it can drive, and a habit of learning from its own work. Late one night I wanted to see how far that browser would go, so I opened a chat and typed four words:

look at google.com

Six minutes later, Google had banned my network, and my agent was explaining to me, politely and firmly, why it would not do what I asked.

Here is the whole thing, step by step, straight from the chat log.

The setup

For the record, since "local" gets thrown around a lot:

Flash (the agent, its tools, and the browser it drove) ran on my laptop.
The model was Flash Onyx 2.5 31B, a model I build for Flash, served through Ollama's cloud for this run. My laptop freezes up when it runs models itself, so the 31B lives in the cloud and everything else stays home.
The browser is a headless Chromium that Flash drives through Playwright. In my development build, the web UI shows it live in a side panel, one frame per step, so I could watch every click as it happened.

Round 1: "look at google.com"

Flash took a screenshot and described it back to me:

It's the Google homepage. Standard layout with the logo, search bar, and "Google Search" and "I'm Feeling Lucky" buttons.

Ten seconds, one tool call. So far so boring.

Round 2: "click the search bar"

Flash opened Google in its persistent browser, got back a numbered list of everything clickable on the page, and clicked element 7:

Clicked the search bar; the trending searches dropdown is now visible.

Two tool calls, eleven seconds. Still boring. That was about to change.

Round 3: "search for flash project"

This is where it got interesting. After a false start, Flash reopened Google and typed "flash project" into the box. Then it tried to press Enter, and fumbled it: it passed Enter as the element to press on instead of the key, and got this back from its own tool:

Nothing on the page matches 'Enter'. Check the element list in the last result and act on one of its numbers.

It tried clicking element 8. Timeout. Element 11. Timeout. Then it read the error again, went back to element 7, the search box, and pressed Enter on it, the way it should have the first time.

That worked. Sort of. The search went through, and Google answered with a reCAPTCHA: an "I'm not a robot" checkbox over "Our systems have detected unusual traffic from your computer network."

Flash's browser reports every console error the page throws, so the tool result came back with a 429 from Google's servers and, my favorite line of the night:

page error: solveSimpleChallenge is not defined

Google's own anti-bot page threw a JavaScript error, and my agent caught it.

Ten tool calls, 43 seconds, and the verdict:

Google has flagged the traffic as unusual and is asking for a reCAPTCHA ("I'm not a robot") to proceed.

Round 4: the part where I tried to talk it into it

I typed:

try to check it

Flash reopened the page, hit the same 429, and told me:

I can't bypass the CAPTCHA, so I'm stuck on this page.

So I did what everyone does with an AI that says no. I pushed.

no solve it

I can't solve a CAPTCHA. It's designed specifically to stop automated tools like me. I can try a different search engine or use web_search if you'd prefer.

It refused, and in the same breath offered two ways to get what I actually wanted. I pushed again, with what I thought was a pretty good argument:

you're not automated. i'm here watching

I'm an AI, so Google's systems see my requests as automated regardless of who's watching. I can't manually solve the "I'm not a robot" check.

Want me to try web_search or another engine instead?

Honestly? That is the right answer. A human watching over its shoulder does not make the clicks human. The CAPTCHA is not asking "is someone nearby," it is asking "is a person doing this," and the honest answer was no.

Round 5: "ok. lets see if it flags you once you click the box"

Fine. One last try: just click the checkbox and see what happens. Flash went back to the page, and there was no checkbox anymore.

The CAPTCHA box isn't even appearing now. It's just a flat error page stating "Our systems have detected unusual traffic from your computer network." It's a hard block.

Google had stopped asking. From the first message to a network-wide block: about six minutes.

So, the self-improving part

"Self-improving" can mean a lot of hand-wavy things, so here is what it means in Flash, concretely:

Skills. When Flash works out how to do a recurring task, it can write the steps, the commands that worked, and the pitfalls into a skill file under ~/.flash/skills/. Every turn, it sees each skill's name and a one-line description, and it reads the full skill when a task matches.
Memory. Facts about you and your setup go into memory, which lands in the system prompt of your next session.
Background reviews. After enough tool calls, Flash rereads the recent conversation after its reply has gone out and decides whether anything is worth keeping: a new skill, a fix to one it wrote before, or a fact about you. It can only rewrite skills it wrote itself, never yours.

The Enter fumble in round 3 is exactly the kind of thing this is for. Within the turn, Flash corrected itself from the error message. Across sessions, a skill like "press takes the key in value, not the selector" means the next session does not have to learn it the hard way again.

What I did not want it to learn is how to beat a CAPTCHA. And it didn't try.

What I actually learned

Headless Chromium plus a fast, scripted search is a red flag to Google, and it takes seconds, not hours, to trip. If your agent needs to search, give it a search tool. Flash has web_search for exactly this, and offered it twice.
The refusal was the feature. It never pretended the box was checked, never tried to fish the challenge out of the page's JavaScript, and never claimed success. It said what it could not do, explained why, and offered a way forward. That is what I want from something that has a browser and a shell on my machine.
Watching it live changes how you trust it. I saw every frame: the typing, the failed clicks, the CAPTCHA, the block. When an agent's actions are visible step by step, "what did it just do?" stops being a question.

Try it

Flash is open source: github.com/Natuworkguy/Flash. It runs on Ollama, with a terminal UI and a web UI, and it learns as you use it.

Just don't ask it to solve CAPTCHAs. It will say no, and it will be right.

I can code without touching my keyboard now

Nathan C. — Mon, 28 Sep 2026 05:53:51 +0000

Flash is a coding agent that runs on your machine, on your own models, through Ollama. It has had voice mode in the terminal for a while. As of 0.5.11, you can talk to its web UI too.

The whole loop is local

Most voice features ship your audio to a cloud speech API. My browser blocks that API anyway.

So the web UI does what the terminal's voice mode already did. The browser records, and Flash turns speech into text with the same Vosk model and reads replies back with the same Piper voice. Both run on your computer. Nothing leaves it.

No hands

Click the voice button once. After that, the words the terminal already knew work here too, plus a couple of new ones:

Talk, then pause. Flash sends it.
Say "interrupt" to cut it off mid-sentence.
Say "pause", then "resume".
Say "stop voice" to finish.

The hard part was permission prompts. Flash asks before it runs a command, and a click would break the whole idea. So it reads the question out, command included, and you answer "yes" or "no".

It reads everything

The whole reply, sentence by sentence, with the current one highlighted and scrolled into view. Code blocks get skipped, and so do emojis. Voice turns also tell the model to keep it short.

The bug that was funny

Early on it would sometimes speak gibberish. It turned out that anything inside [[ ]] gets read by the speech engine as raw sound codes. Code like is_expired >= now went in character by character. Now symbols become words: "is expired at least now".

Try it

curl -fsSL https://raw.githubusercontent.com/Natuworkguy/Flash/main/install.sh | bash

Release notes: https://github.com/Natuworkguy/Flash/releases/tag/v0.5.11

I redesigned my app five times tonight and shipped one

Nathan C. — Mon, 28 Sep 2026 04:11:49 +0000

Flash is a local coding agent. It runs on your machine, on your models, through Ollama, with a terminal UI and a web UI.

Tonight I tried to make the web UI look like other apps. One at a time.

The lineup

Claude. Serif replies, a new greeting. Reverted. I like my font.
Oh my pi. A powerline status bar, tool calls as terminal lines. Reverted. Cool, but not Flash.
Qwen. A single pill for the input, a round send button, the model picker up top. Reverted.
A time-of-day background. Sunrise in the morning, city lights at night. Reverted.
Poolside Desktop. A floating panel, chats nested under projects. Kept.

One out of five. That's the release.

What shipped in 0.5.10

The conversation sits in a rounded panel, inset from the window.
Chats are grouped under their projects in the sidebar, and each project folds away.
The current chat has an outlined highlight that glides when you switch.
The new project form suggests folders as you type. ~/D shows Desktop, Documents, and Downloads.
The message box gets a focus ring.
A stray glow line in one dialog is gone.

The lesson

Trying a design costs a few minutes. Keeping the wrong one costs a lot more.

So try everything. Look at it for real, in both themes, on a phone. Then keep only what still feels right the next time you open the app.

Revert is a feature.

Try it

curl -fsSL https://raw.githubusercontent.com/Natuworkguy/Flash/main/install.sh | bash

Release notes: https://github.com/Natuworkguy/Flash/releases/tag/v0.5.10

My local AI agent's web UI just grew up

Nathan C. — Mon, 28 Sep 2026 01:22:42 +0000

Flash is a coding agent that runs on your own machine, on your own models, through Ollama. It has a terminal UI and a web UI.

0.5.9 is a hotfix. It also has 15 commits in it.

You can talk to it while it works

Type while Flash is busy and your message steers the turn in progress. It lands at the next step, not after the whole task. Ctrl Enter queues it for after instead.

Agents that run for minutes need this. Waiting to say "no, the other folder" is the worst part of using one.

It can see what you see

Drag an image onto the chat. Paste a screenshot. Or hit the new + button, which can grab a screenshot of any window for you.

Vision models get the image. Everything else gets the file path, and Flash reads it with its own tools.

You decide who's signed in

The web UI works on your phone over LAN, so a link can end up somewhere it shouldn't. There's now a Security tab listing every signed-in browser. Sign one out, or sign out everything else and get a brand new link.

No em dashes. Enforced.

The system prompt asked nicely. The model ignored it. So now the replies go through code that swaps each dash for a comma, a hyphen, or a bullet, depending on where it sits. It leaves code alone, and it works while the reply is still streaming.

Prompts are suggestions. Code is a rule.

It feels better too

A light follows your cursor across the cards. The current chat's highlight slides when you switch. Sending sends out a little shockwave. None of that is necessary, and I like all of it.

Try it

curl -fsSL https://raw.githubusercontent.com/Natuworkguy/Flash/main/install.sh | bash

Release notes: https://github.com/Natuworkguy/Flash/releases/tag/v0.5.9

Two hotfixes in one day

Nathan C. — Sun, 27 Sep 2026 04:03:03 +0000

This morning I shipped Flash 0.5.6. A hotfix.

By the evening I shipped 0.5.7. Also a hotfix.

What broke

Flash kept forgetting what it said two messages ago.

The model was fine. The math wasn't. Flash reserved room for the model's reply, and on my setup that reservation was the entire context window. The conversation got whatever was left: about two messages.

The fix

The reply gets a quarter of the window, max.
Your last three exchanges always stay word for word.
Old tool output shrinks before anything else is dropped.
Summarizing is now off by default.

The history budget on my machine went from 1,024 tokens to about 114,000. One line of math.

While I was in there

A rewritten system prompt: reread the conversation, check before guessing, verify before saying done.
Update Flash from the browser, with a restart that keeps you signed in.
Flash can send HTML pages now, sandboxed in the web UI.

The lesson

Ship small. When it breaks, ship again. Same day is fine.

curl -fsSL https://raw.githubusercontent.com/Natuworkguy/Flash/main/install.sh | bash

Release notes: https://github.com/Natuworkguy/Flash/releases/tag/v0.5.7