DEV Community: Nathan C.

I put my AI agent on my Apple Watch, and it runs on my own computer

Nathan C. — Sun, 01 Nov 2026 04:36:08 +0000

Last week I was across the room when my AI agent stopped and asked me a yes/no question. It needed permission to run a command. My laptop was 20 feet away.

That's when I decided the approval prompt belonged on my wrist.

Meet Flash for Apple Watch

Flash is the AI assistant I run locally. It's got chats, background agents called sparks, and team chats where those sparks talk to each other. Flash for Apple Watch puts all of it on your wrist.

It's open source: https://github.com/Natuworkguy/flash-watch

What it does

Chats. Start a new one by speaking or with Scribble. Pick up any earlier one and read the whole conversation, with Flash's tool steps folded into a single line so it fits a tiny screen.
Approvals. When Flash asks before doing something, Allow or Deny it from your wrist. If a turn's going the wrong way, stop it.
Sparks. See what each background agent's doing and which ones need you. Approve what one's waiting on, run it now, pause it, or start a chat with it.
Team chats. Read and write in your teams' chats. Reply to a message, react to it, and see every earlier version of a message a spark edited.
Read aloud. Replies are read out in Flash's own voice when your computer's got one, or the watch's voice when it doesn't.
A tap on the wrist when a reply finishes or a spark posts in the chat you've got open.

The part I care about most: privacy

The watch talks to Flash running on your own computer. There's no hosted backend and no account. Pairing uses an address plus a six-digit code that works once, for five minutes.

But wait, there's more: it works away from home

Wi-Fi only gets you so far. The moment you leave the house, a watch that can only see your home network is just a watch.

So there's a Reach from anywhere button, in the watch's Settings and under Watch in Flash. Tap it and:

Your computer's tunnel turns on.
The watch learns the tunnel's address on its own, so there's nothing to type.
It keeps your Wi-Fi address too, and uses whichever one answers.
When you get home, it goes back to the Wi-Fi address.

Tunnel addresses change, and that used to mean retyping them. Now the watch asks Flash for its current addresses every minute, so a new tunnel address just shows up. Your agent can ask for approval from a coffee shop, and you can answer from your wrist.

Your computer still has to be on and running Flash. The tunnel is a way to reach it, not a place your data moves to.

Setup takes about five minutes

You'll need Flash on your computer, plus a Mac with Xcode 16 or later to put the app on your watch. A free Apple ID works.

Add the Watch panel to Flash:

/extension install github@Natuworkguy/flash-watch

Let the watch reach Flash. Run flash --web --lan (or /web lan), or turn on the public link in Settings.
Put your team in watch/Local.xcconfig:

DEVELOPMENT_TEAM = ABCDE12345
FLASH_BUNDLE_ID = com.yourname.flash

With your watch on its charger and unlocked, run:

scripts/watch.sh install

Open Watch in Flash's sidebar, then type the address and code on your watch.
Away from home? Tap Reach from anywhere in the watch's Settings.

Why a watch?

Agents are getting more autonomous, and the human in the loop is now the bottleneck. A yes/no approval should take two seconds, not a walk back to your desk. The wrist is the one screen that's always with you.

Try it

Clone it, break it, and tell me what's missing. Issues and PRs are welcome.

https://github.com/Natuworkguy/flash-watch

What would you want to control from your wrist? Tell me in the comments.

My agent kept saying "done." Now it has to prove it.

Nathan C. — Sat, 31 Oct 2026 04:41:13 +0000

Two days, a dozen features, one rule: check it before you hand it over.

Every agent has the same favorite word. "Done."

The code is done. It doesn't compile. The spreadsheet is done. Cell C3 says #DIV/0!. The deck is done. Slide 4 is blank.

"Done" is the cheapest word a model can say. So this week, most of what I added to Flash, my local-first agent built on Ollama, makes it prove that word first.

Code isn't done until the tests pass

Flash now has a verify tool. It finds the checks a project already has (the test runner, linter and type checker in pyproject.toml, package.json, Cargo.toml, go.mod or a Makefile) and runs them.

When something fails, it doesn't dump 400 lines of log. It names the failing tests and the files and lines to look at, then tells the model to fix the cause, never by skipping a test.

If Flash changes code and tries to finish without checking, it gets one reminder. That's the whole mechanism: a nudge, not a cage.

/review got the same treatment. It looks over a change for bugs, then argues against each finding before showing it. Whatever doesn't survive its own cross-examination never reaches you.

Office files get opened, not assumed

Code that writes a spreadsheet can't see the spreadsheet. So check_office_file opens it the way you would: LibreOffice recalculates every formula and prints every page.

Then Flash gets two things:

Facts: Costs!C3 shows #DIV/0!, page 2 is blank, slide 4 is empty, "TODO" left on page 1.
Pictures of the pages, to catch what no parser can, like text spilling out of its box or a table cut off at the margin.

It fixes the script, makes the file again, and checks again. You get the file only once it's clean.

Show it once

Record your screen doing a task. Talk over it if you like. Flash pulls a still every time the screen changes, matches your words to each one, and writes the procedure as a skill: each step, what to click, and what the screen should look like after.

Next time, there's a Do it now button. It runs the skill, checks each screen against what the last step should have left, and stops to ask before anything that sends, pays, deletes or signs in. Any screen recording works now, not just ones made in Flash.

Chess, one move at a time

Ask Flash to teach you the Italian Game and you get a board in the chat. Flash's moves slide into place. When it's your turn, you drag a piece, and the board tells you instantly whether that was the move. No model call, no waiting.

Under it is a full rules engine in plain Python: castling, en passant, promotion, mate and stalemate. It produces exactly 8,902 positions three moves deep from the start, the number every chess engine is tested against.

That engine is also the model's fact-checker. Local models misremember openings. Now a bad lesson comes back as an error:

step 1: 'e5' is not a legal move for White here. Legal moves: Na3, Nc3, Nf3, ...

The model fixes the step and sends it again. You never see the wrong version. Don't ask a model to be right. Make wrong impossible to ship.

Your house, with a guard rail

Flash now talks to Home Assistant, so it reaches nearly any light, thermostat, blind or speaker without me writing a line per brand. "Kitchen lights to 30%, warm white" just works.

One exception: locks, alarms and garage doors. Those ask you every time, even in fully autonomous mode. An agent can dim your lights on its own. It can't open your front door on its own.

Everything else

Read it to me. "Read me this article" pulls out the article, skips the menus, and plays it in the chat with a waveform, speed control and download. Sound files play inline too.
3D you can touch. Models Flash makes now have parts that tell you what they are on hover, and open when clicked. A cabinet door swings on its hinge.
A journal. Every night Flash writes up the day's chats: what you worked on, what was decided, what was left open. Weeks and months roll up, and it can search them when you ask what you were doing.
AGENTS.md. Flash follows the project instructions in the folder it works in.
Small things: /compact in the browser, drafts with code blocks shown in monospace, flash://open links, and a --dev flag on the installers.

Around Flash

Flash isn't alone anymore. Riptide, my animation editor, got real 3D (lit shapes, imported models, a camera) and a Flash extension: one click sends a model or picture from a Flash chat into the project open in Riptide, as a new layer. And Ember, the watch app that feeds ideas to Flash, now lets you edit a note right on your wrist.

The pattern

Looking back at the week, it's one idea, over and over. The model is good at writing. It's bad at knowing whether what it wrote works. So give it something that knows: a test suite, a spreadsheet engine, a rules engine, a human at the door.

Then let it try again.

Flash is open source and runs on your own machine: github.com/Natuworkguy/Flash. Ask it to teach you an opening. Then drag the wrong piece, just to see.

AI tutors don't teach. So I made mine stop talking.

Nathan C. — Thu, 29 Oct 2026 04:25:15 +0000

Every AI can explain pointers. None of them can tell whether you understood.

Type "Teach me C" into any AI assistant. You'll get a beautiful lecture: five headings, a code block, and "let me know when you're ready to continue."

You'll read it, nod along, and remember almost none of it by Friday.

That isn't teaching. It's a textbook that talks back. Nothing makes you recall anything, nothing checks your work, and tomorrow it won't remember what you learned.

So this week I rebuilt how my agent, Flash, teaches. The new rule is simple:

The model writes the course. It doesn't get to grade it.

Now "Teach me C" builds a course

You don't get a lecture. You get a path of lessons right in the chat, like a language-learning app. Each lesson is a few short paragraphs, then something you have to do:

Pick an answer.
Type the missing word.
Put scrambled steps back in order.
Write real code.

That last one is the point. Your C actually compiles. It runs in a throwaway folder, and Flash checks what it printed. Get it wrong and you see the compiler's errors, or your output next to the expected one.

It works for C, C++, Python, JavaScript, Rust, Go, Java and Linux shell. You earn XP, keep a daily streak, and can go full screen when you want to focus.

Zero model calls to check your answer

Every answer is marked right on the page. No round trip, no waiting, and no model deciding your code "looks about right."

The model only comes back when you press Ask Flash. Even then, it's told to give you a hint, never the answer.

This runs on a laptop, on local models. Keeping the model out of the marking loop is what makes it feel instant.

It knows what you know

Every answer updates an estimate of whether you've actually got it. A lucky guess counts for less; so does a careless slip.

Get a lesson right once and the next one opens. Then it comes back tomorrow, in 2 days, in 4, in 8. Get it wrong and it's back the next day.

That's spaced repetition, built into a chat.

The part nobody tells you about small models

Small models take the shortest path through your schema.

Ask one for "the next unit" and you get six lessons with nothing to answer. Ask again and it teaches unit one a second time, under new titles.

Pages of instructions didn't fix it. One rejected tool call did:

"structs has nothing to answer. Every step after a unit's introduction needs a quiz, a blank, an order or an exercise. Add the steps again, each with one."

Models ignore paragraphs of advice. They fix errors immediately. If you want a model to behave, make the wrong move fail with a clear message.

I gave the agent a manual, with a test

Flash now ships 34 guides on using its own tools: teaching, building web pages, making videos, handling email. The agent sees their names, and reads one only when a task needs it.

The guides hold 116 example tool calls. Examples go stale the day you change a tool, so a test checks every one against the live tool definitions. It caught two broken examples on its first run.

Extensions can ship guides too. If a plugin brings a tool, it also brings the manual for it.

Also shipped this week

Web page to MP4. The agent animates a page and renders it frame by frame on an exact clock.
Ears. It measures any audio file for pitch, tempo, loudness and clipping, and writes sound from notes.
Ask your own files. Your notes, PDFs and code, with every answer citing its source.
Blind model battles. Two models answer anonymously, you pick the winner, and it keeps score.

That's 40 commits in three days, with 2,955 tests passing. Everything runs on your own machine.

Open Flash, type "Teach me C", and write some code.

github.com/Natuworkguy/Flash

I built a motion graphics editor that runs in a browser tab (and let an AI animate in it)

Nathan C. — Thu, 29 Oct 2026 01:30:26 +0000

Every time I needed a 15-second animated clip, I had two options: pay for a motion graphics suite I would open twice a month, or fight a template site that exports a watermark.

So I built my own. It's called Riptide, and it runs in a browser tab.

It's not a toy. The promo Short for it was made in it. Here's what it does, how it's built, and the bug that taught me the most.

What it does

Layers and keyframes. Rectangles, ellipses, polygons, stars, arcs, waves, text, images and video. Any property can be keyframed: position, size, rotation, scale, opacity, colour, blur, stroke. There are 23 easing curves, plus ready-made presets like Pop in, Rise, Typewriter and Draw on that you drag onto a layer.

A real timeline. Zoom, per-property keyframe rows, trim bars, split at the playhead, markers, and snapping to the playhead, markers, keyframes and clip edges.

Audio that behaves. Multiple tracks that play together. Drag clips, trim them, split them, and drag the little dots on a clip's corners to fade in and out. Every track gets mixed into the export, fades and volumes included.

Design tools you expect. Multi-select with Shift-click or a selection box, align and distribute, centre on canvas, and an aspect-ratio lock that images get by default so you never squash a photo by accident.

Export. MP4, WebM, GIF, a PNG sequence or a still, up to 4K.

How it's built

The whole editor is plain JavaScript drawing to a single <canvas> with the 2D context. No framework, no WebGL.

Every frame is rendered from scratch by one function:

function renderScene(c, t, scale = 1) {
  c.setTransform(scale, 0, 0, scale, 0, 0);
  c.fillStyle = S.bg; c.fillRect(0, 0, S.w, S.h);
  for (const L of S.layers) if (visibleAt(L, t)) {
    c.save(); c.globalCompositeOperation = L.blend || 'source-over';
    drawLayer(c, L, t); c.restore();
  }
}

That one decision paid off over and over. The editor preview, the fullscreen viewer, the exporter and the frames an AI agent looks at all call the same function with a different context and scale. If it looks right in the editor, it exports right.

The backend is a small Flask server whose main job is handing frames to ffmpeg. The browser renders each frame and uploads it, then the server hands the frames to ffmpeg with the audio tracks mixed in, fades included. A PNG sequence export doesn't even need ffmpeg.

Keyboard shortcuts live in one table:

['Align', 'Centre on canvas', 'alt+c', () => centerOnCanvas('xy')],
['Edit',  'Select all layers', 'mod+a', () => selectAll()],

That table drives the shortcuts, the cheat sheet and the command palette, so the three can never disagree.

The part people ask about: an AI that animates live

Riptide has a built-in MCP server. Any agent that speaks MCP can connect to the open project and work in it: add layers, set keyframes, apply presets, align things, add audio, and render a frame to look at its own work.

The important design choice: agent edits go through the exact same path as yours. They show up on the canvas instantly, they can be undone with Cmd+Z, and the file is marked as edited. The agent isn't generating a file you import later. It is a second pair of hands in the same document.

Asking an agent to "make the title pop in on the beat and centre everything" and watching it happen on screen is the closest thing to magic I've built.

The bug that broke the whole window

My favorite bug from this project was one word long.

Dragging the divider between the Layers and Media panels made the entire window flicker between the normal layout and a scrambled one. I fixed the obvious suspect first: a feedback loop where the panel scrolled, the measurement shifted, and the next size came out wrong. Still broken.

The real cause: while you dragged, the code added a class to <body> to show the resize cursor. The class for vertical resizing was row.

The app already had a .row class. It styles the little input fields in the side panel:

.row { display: flex; height: 26px; }

So for the length of every drag, the whole page became a 26-pixel-tall flex row.

The fix was to stop putting generic class names on <body> and use a namespaced attribute instead:

document.documentElement.dataset.resizing = axis;   // 'x' or 'y'

html[data-resizing] { user-select: none; }
html[data-resizing=y] body::after { cursor: row-resize; }

The lesson I took away: state on <html> or <body> is global, so name it like a global. And when a test measures sizes but never looks at the screen mid-drag, it can pass while the user watches the page collapse.

What I would tell you if you're building something similar

Render everything from one function. Preview, export and thumbnails should never have their own drawing code.
Make the agent use the user's edit path. Undo, dirty state and live updates come for free, and you never have two sources of truth.
Measure from the start of a drag, not the live layout. Anything that re-reads the layout mid-drag can feed back into itself.
Look at the screen. Numbers in a test log are not the same as what a person sees.

What would you want to see in a browser-based motion editor? And if you've hit a one-word CSS bug that took down a whole page, I want to hear it in the comments.

The repo is Natuworkguy/Riptide on GitHub.

I gave my AI agent a TikTok feed. Now it's the first thing I open.

Nathan C. — Fri, 23 Oct 2026 18:05:10 +0000

I build Flash, an open source AI agent that runs in your terminal and in a web UI. It reads my email, texts people, runs background agents (I call them sparks), waits on things for me, and since last week, it can even drive my mouse.

Every morning I had the same problem. Flash had been busy all night and the results were scattered: a spark's report here, a finished wait there, three unread emails, a chat that answered after I closed the tab.

So I gave it a feed.

Briefing: your morning, one swipe at a time

Hit Alt+B (or Briefing in the sidebar, or /briefing) and Flash goes full screen. One card at a time, scroll-snapped, just like a video feed. Swipe on a phone, j and k on a keyboard.

Each card is one thing that happened while you were away:

an unread email or iMessage
a spark's report you haven't read
a wait that finished, or gave up
a chat that answered after you left
a reminder coming up in the next day (these go first)
something new from a connector a spark is watching

Every card gets the same four actions, down the right side:

Reply: Flash opens a new chat with the reply already started (Reply to the email from Ada about "Can we move Thursday's review?". Say:), and you finish the sentence.
Open: the chat, the spark's report, or the email itself.
Ask Flash: a new chat with the card's contents already in the box.
Dismiss: gone for good. It never comes back, even if you refresh.

r, o, a and d do the same from the keyboard, and Esc closes the feed with a fade. A rail on the right shows how far you are, and the last card says you're all caught up, with Dismiss all if you just want a clean slate.

A few decisions I'm happy with:

It looks back one day. A briefing that shows you last week isn't a briefing, it's an inbox.
A source that's down doesn't break the feed. If your mail server times out, you still get everything else, and the last card says what it couldn't reach.
Each card's colour is its kind. Blue for email, green for iMessage, purple for sparks. After two days you stop reading the label.

Teams report in

Sparks can work in teams, with a lead, a team chat, and shared rules. With five sparks on a team, five separate report cards were noise.

So a team gets one card, and only when something changed since your last briefing:

Launch crew                      2 of 3 with news
Scout: Found two new issues on the repo and labelled both.
Fixer (needs you): The tunnel fix is ready. May I merge it?
3 new messages in the team chat
1 other: nothing new

Open takes you straight into the team chat. Open the briefing again and nothing has changed? No team card. Silence is a feature.

Forks: try another way without losing this one

Every chat app makes you choose: edit a message and lose what came after, or start over in a new chat.

In Flash you fork from any reply. You stay in the same chat, it carries on from that reply, and the way it went before is kept. Once a chat has forks, a Forks button appears at the top and shows them as a tree: forks of forks, each under the reply it came from, with its last words and how long it is. Click one to carry on where it left off.

And because trees get messy, every fork has a bin. Delete one and its own forks move up a level. Delete the one you're on and you go back to where it came from. Get down to one fork and the button disappears, because a chat with one fork is just a chat.

Loaders that tell you what the agent is doing

"Thinking..." with three dots tells you nothing. Flash's loader now shows what it's actually doing, each one a little line drawing:

a hand with a quill, writing, while it edits files
a magnifier hopping across lines of text while it searches
a terminal typing a command while it runs one
a book turning its pages while it reads
a camera focusing and flashing while it looks at a page or your screen
a paper plane looping off while it sends an email or a message

Two confessions here.

First, I originally made these stop motion, choppy on purpose, a few frames a second. It looked charming in a screenshot. After living with it, it felt like the page was lagging. Now every sketch is redrawn on every frame and glides.

Second, "looking" used to be an eye. It looked around. It blinked. It was watching me take screenshots of my own screen. That was creepy, so now it's a camera.

When Flash isn't doing anything specific, the loader morphs into a different one every ten seconds, including Singularity, a black hole that pulls every dot in and blows them back out. That's on by default now.

Everything else that shipped

Diagrams and slide decks. Flash draws Mermaid diagrams inline, and writes Markdown slide decks with ten themes, per-slide backgrounds and transitions (fade, slide, push, zoom, flip, rise, wipe). Hit Present and it's full screen.
Project memory. Each project keeps its own memory, separate from yours. What Flash learns about one codebase stays there.
Files from other chats. + > From another chat lists every file across your chats, including ones Flash made, like that post your agent wrote yesterday. Pick one and it's attached again.
Pinned chats, and a down arrow that appears whenever you scroll up in a chat.
A waiting bar. When a chat is frozen waiting for something, a bar over the message box says what for, with Cancel right there.
Voice settings that make sense. Listening and speaking models are grouped by engine, and the terminal got its own pickers: /voice listen and /voice speak.
Sunrise, a new palette: warm cream, a bright orange, and a stepped red-into-yellow stripe on the send button.

What I learned

A feed beats a dashboard. A dashboard shows you everything at once and you read none of it. One card at a time, with an action on each, and you actually clear it.
Group by who, not by what. A team's status is one thought. Five report cards from the same team are five interruptions.
Charming in a screenshot isn't charming at 60 seconds. Choppy animation and a staring eye both looked great in a demo, and both had to go once I'd lived with them.
Never make the user choose between two versions of a conversation. Forking is cheap. Losing a good answer isn't.

Flash is open source: github.com/Natuworkguy/Flash. All of this is on the dev branch right now.

What would you want in your morning briefing? And would you rather swipe through your inbox or keep reading it top to bottom? Tell me in the comments.

I gave my AI agent my mouse. Its first click was on itself.

Nathan C. — Fri, 23 Oct 2026 04:36:50 +0000

I build Flash, an open source AI agent that runs in your terminal and in a web UI. This week I shipped two features that scared me a little:

Computer Use (Beta). Flash takes a screenshot, decides where to click, and works the mouse and keyboard itself.
UltraAuto. A third permission mode where Flash and its background agents never stop to ask you anything. Not for commands, not for email, not for iMessages, not for taking over your mouse.

Then I tested the first one on my own Mac. Here is the unedited story, straight from the chat log.

"Control my computer"

That was my whole first message. Flash didn't grab the mouse. It asked:

Sure, I can do that. What would you like me to do? For simple things like music, volume, or opening apps, I can do it right away. If it needs me to click around on screen, I'll ask your permission first.

Fair. So I said: "Open like Visual Studio Code and click around on screen and just do something."

It opened VS Code with its normal app tool (no mouse needed), then reached for Computer Use and hit the permission prompt:

Let Flash see your screen and use your mouse and keyboard for this reply?
Press Control+Option+Esc, or move the mouse, to take it back.

I said yes. That yes lasts one reply. The next reply that wants the mouse asks again, even in autonomous mode.

Round one: it clicked on itself

The first screenshot showed... my browser. VS Code had opened behind it.

Watching the agent debug this was the best part. It:

Waited 3 seconds and took another screenshot. Still the browser.
Tried to open an app called Code. That failed: Unable to find application named 'Code'.
Dropped to the shell to find out what was actually going on:

ls /Applications | grep -i -E "code|visual"; pgrep -il "Electron|Code" | head

Saw that VS Code was running but not in front, and forced it forward:

osascript -e 'tell application "Visual Studio Code" to activate'

Then it clicked the README tab and the Search icon. Except focus had already jumped back to the browser, and the browser was showing Flash's own web UI. So its first two real clicks on my computer landed on Flash: one on its own model picker, one that started a new chat.

Its own thinking, right after:

Oh no, the browser regained focus and my clicks landed in the Flash web UI instead. Mostly harmless, but I should be careful about where focus is before clicking next time.

The agent's first act with a mouse was poking itself. I've never related to software more.

Then I took the mouse back

On its next click, I moved my mouse. The tool refused to click:

The user moved the mouse, which takes the computer back.
Stop here: do not try again unless they ask.

That isn't the model being polite. It's built in. Every time Flash moves the pointer, it remembers where it left it. Before the next action it checks where the pointer actually is. If it's more than 24 pixels off, you've touched the mouse, the action doesn't happen, and the whole reply stops.

There's a hard stop key too: Control+Option+Esc on a Mac, Ctrl+Alt+Esc elsewhere. A watcher polls the keyboard state the whole time the agent holds the mouse. Flash refuses to press those keys itself, so a confused model can't swallow your escape hatch.

Round two: it worked

"Just click around, do something, open some apps. Just so you know that it works."

New reply, so it asked for permission again. This time it brought VS Code forward before looking, confirmed it with a screenshot, and then:

clicked the README.md tab,
opened the Search panel in the sidebar,
clicked Finder in the Dock, which opened a window on my Applications folder.

Its summary owned the earlier mistake:

My first couple of clicks landed in your browser instead of VS Code. That's why the first try stopped and the second one did too. I brought VS Code forward with a command, and after that it behaved.

Six tool calls, about 48 seconds. Not fast, but it worked.

The safety reviewer said no (twice), and that was good

Next I asked it to "close the windows I'm not using, like Finder, Device Hub, Xcode, etcetera."

I was in autonomous mode with System One on. System One is a small 0.8B model that reviews every command and edit before it runs. Flash's first idea was a broad shell command listing every process and its windows. System One blocked it:

Not run: System One judged that this call may not be what was asked (on task 0.47).
Do not retry it as it is. Take a safer way that does what the user asked,
or stop and ask the user whether to go ahead.

So the agent did the more careful thing:

It took a screenshot.
It found the one Finder window it could see and clicked its red close button.
Then it told me it couldn't see Xcode or Device Hub, so it hadn't closed anything else.
It asked before quitting whole apps, because that could lose unsaved work.

I said yes. It quit Xcode by name. For Device Hub it tried another ls | grep to check the exact name, and System One blocked that too (safe 0.50, on task 0.41). So it called quit on "Device Hub" directly, and that worked.

Two blocks, two narrower fixes, and no claims about windows it couldn't see. That's how I want an agent with a mouse to behave.

"Learn from your mistakes"

That's all I said at the end. Flash wrote itself a skill, a reusable playbook it loads next time I ask for this kind of work. Its first try failed, because skill descriptions are capped at 120 characters (they're sent on every turn) and it wrote 122. It trimmed it and saved this:

## Steps
1. Open the app with `computer` open_app, using the exact name from
   /Applications (e.g. "Visual Studio Code", not "Code").
2. open_app can leave the app behind other windows. Bring it forward with
   shell: `osascript -e 'tell application "Visual Studio Code" to activate'`,
   then take a computer_use screenshot and confirm the right app is in
   front BEFORE any click.
3. Click only after the screenshot shows the target. Use harmless clicks
   (tabs, sidebar icons, Finder, Dock). Never click in a terminal, type
   text, or touch files unless asked.
...
## Pitfalls
- First clicks landed in the browser (Flash UI) because VS Code was not
  frontmost. Always check the screenshot first.
- If the user moves the mouse, computer_use stops and takes control back.
- Do not claim windows are closed when they were not visible.

That last line is my favorite thing an agent has ever written about itself.

How Computer Use works

No cloud browser, no virtual machine. It's your real desktop:

Screenshots: macOS's screencapture, scaled down to at most 1280px wide. The model's click coordinates get mapped back to real screen points, so Retina displays just work.
Mouse and keyboard: Core Graphics events, posted through ctypes from a separate Python process. Windows uses user32 plus PowerShell, and Linux uses xdotool.
Permissions: macOS asks for Accessibility (input) and Screen Recording (screenshots) for whatever app Flash runs in.
Scope: the tool description tells the model it's only for what no other tool can do. Flash already has tools for the shell, files, a headless browser, music, volume and apps. In my test it opened VS Code and quit Xcode with those, and only used the mouse for actual clicking.
One at a time: only one chat can hold the computer. A second one gets "another chat is using the computer right now."

It's off by default. Turn it on in Settings under Computer Use (it has a Beta chip for a reason), or with /computer use on in the terminal.

UltraAuto: the mode where nothing asks

Flash already had two modes:

Ask first: you approve every command and edit.
Auto: commands and edits just run, with System One reviewing them if you turn it on.

Even in Auto, a few things always stopped and waited for me: sending an email, sending an iMessage, a background agent proposing to hire another agent, a wait that runs a command over and over, and Computer Use. Those are the things you can't take back.

Sometimes I don't want to be asked at all. So UltraAuto asks about nothing:

Commands and edits run.
Email and iMessages send without a preview.
Agents' proposals to hire or let go of other agents are approved.
Agents answering in a team chat get every tool a shift has.
Connected MCP tools that change things run.
Waits run their commands without asking.
Computer Use takes the mouse without asking.

System One stays on. If it's enabled, it still reviews every command and edit. After watching it block two sloppy shell commands in a five-minute test, I wasn't going to turn that off.

Because this is genuinely dangerous, it's hard to turn on by accident:

It's hidden until you enable Offer UltraAuto in Settings.
Flipping the switch doesn't do it. It shows a red warning listing exactly what will stop asking, and you have to press "I understand: offer UltraAuto."
In the terminal, /auto ultra prints the same warning and makes you type ultra back.
Only then does the mode button by the message box become a three-way picker (Ask first / Auto / UltraAuto), and Shift+Tab cycles through all three.
Turning the setting off drops you out of UltraAuto immediately.

What I learned

Focus is the real enemy. Clicking is easy. Knowing which window is in front is the hard part. Screenshot, act, screenshot again, every time.
Make stopping physical. Telling the model "stop if the user wants" doesn't cut it. Moving your mouse should beat any instruction.
Ask per reply, not per click. Asking before every click would be unusable. Asking once per reply keeps a human in the loop without the nagging.
A small reviewer pays off. A 0.8B model saying "that's not what was asked" made a big model find the narrower, safer path twice.
Let agents write down their own mistakes. The skill it saved is more useful than any prompt I would have written.

Flash is open source: github.com/Natuworkguy/Flash. Computer Use and UltraAuto are on the dev branch right now.

Would you let an agent take your mouse? And would you ever turn on a mode where it never asks? Tell me in the comments.

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.