DEV Community: Nathan C.

Silhouette first: teaching my local model to make 3D models and images

Nathan C. — Wed, 11 Nov 2026 16:00:00 +0000

Ask a model for a 3D chair and you get five boxes.

A box for the seat, a box for the back, four thin boxes for legs. They're roughly in the right places. Turn the camera and one leg is floating a centimetre above the floor, the back is sunk into the seat, and the whole thing is the size of a house because nobody said what unit "1" was.

It's not that the model can't do geometry. It's that nobody taught it how people who make 3D models actually work.

Flash is my open source agent, and Onyx is the local model behind it: an open-weights base in Ollama, shaped by one long Modelfile. The last update taught it taste in typography, layout and color. This one teaches it two crafts: building 3D models and directing images.

3D: the order matters

The new 3D MODELS section opens with the rule every modeller learns first:

A model is judged by its silhouette first, its proportions second, and its detail last. Get the outline right from three angles before adding anything small, because no amount of detail rescues a shape that reads wrong.

Then it works through the habits that separate a model from a pile of primitives.

Real units, real sizes. Metres, Y up, resting on the ground at zero. Before placing a part, work out how big the real thing is: a chair seat sits near 0.45 m, a door near 2 m by 0.9 m, a mug near 0.1 m tall. "Proportion errors are what make a model look like a toy."

Block out, then refine. Rough the whole object in a handful of big shapes, check it, then split them into real parts. And name every part for what it is, left rear leg, lid, screen, never box3, so the next edit can find it.

Parts meet. This one surprised me with how much it matters:

A table top overhangs its legs, a lid has a lip, a screen sits inside a bezel. Leave a visible seam, gap, or step where two parts join; a single smooth block where three pieces should be is the look of a placeholder.

Nothing is perfectly sharp. A bevel of a few millimetres catches light, and it's most of what separates a made object from a primitive.

Materials over polygons. Metalness is 0 or 1. Roughness does the work, and almost nothing sits at 0. Worn edges rougher, handles smoother, painted metal not mirror metal.

Detail where the eye goes. The front, the handles, the controls and the moving parts get extra parts. The underside stays simple.

Hinges are hinges. A door turns about its hinge, a drawer slides on its runners. Set the pivot at the hinge or axle, not at the part's centre, and never swing past what the real part can do.

Three views, every time. Front, three-quarter, and top or side, wherever there's a picture to look at. Floating parts, parts sunk into each other, and gaps at the ground line are the defects to hunt:

A part that only looks right from the angle you built it at is not done.

And when it writes the model in code (trimesh, three.js, Blender's Python): merge what never moves, keep normals pointing out, apply transforms before export, ship glTF in metres, and say the overall size in the reply, so you can check it against the real thing.

Images: direct, don't just prompt

The second new section is IMAGE DIRECTION. It applies whether Onyx is drawing with code or writing a prompt for an image generator.

One subject, and a reason to look. Decide where the eye lands first, put it off centre on a third, and give it the strongest contrast. Everything else gets quieter.

Value before color. This is the one I'd tattoo on every generated image:

Squint at the draft or convert it to grey: if the subject does not separate from the background in light and dark alone, no colour choice will save it.

Light has a direction. One key light, from a side and a little above, and every shadow agrees with it. "Flat light from everywhere is the default look nobody chose."

Depth is layers. A foreground element, the subject, and a background that recedes by getting lighter, cooler and lower in contrast.

Prompts are briefs. Write it the way you'd brief a photographer:

"A ceramic mug on a walnut table by a window, late afternoon side light, 50mm, shallow depth of field, steam rising" beats "a beautiful cozy mug, high quality, 4k".

Iterate like an art director. Generate a few, judge them against the brief, and refine the closest one, changing one thing at a time so you learn what moved it. Check hands, text, reflections and edges at full size, because that's where generators fail first.

Deliver for where it's going. 1:1 for a feed, 9:16 for a story, 16:9 for a slide, 2:1 for a cover, with the size named in the reply.

The one-line version

Every Onyx Modelfile ends with a short recap, the lines it should keep if it remembers nothing else. Onyx 3's recap now has this one:

A model is checked from three views in real metres; an image has one subject, a light, and values that read in grey.

That's most of what a first-year 3D or illustration course spends a semester on. It turns out a model can follow it on day one, as long as someone writes it down.

Try it

Onyx builds from its Modelfile with Ollama:

git clone https://github.com/Natuworkguy/flash
cd flash
python3 models/build.py models/flash-onyx-<version>.Modelfile

Then ask Flash for something with real parts: a desk lamp with a hinged arm, a mailbox that opens, a poster for a neighborhood bake sale. Turn the model around. If a leg is floating, it owes you a fourth view.

I hid 6 secret glitches in my agent's video game. They make it easier. Can it find them?

Nathan C. — Tue, 10 Nov 2026 16:00:00 +0000

My agent can beat a platformer it has never seen.

Flash is my open source agent for the terminal and the browser. One of its tools, play_realtime, lets the model write a tiny reflex: a JavaScript function that runs every single frame inside the page, reads the canvas pixels, and presses keys. The model can't think 60 times a second, so it writes the thing that can.

To test it, Flash ships with Flash Dash: a little level built like a rhythm runner. A square runs right on its own. Spikes kill. Blue blocks are solid. An orange pad launches you. A cyan ring gives you a second jump in mid-air. Then a gate turns you into a ship you fly between pillars.

The reference reflex beats it on the first try, from the pixels alone, in 21.11 seconds.

That's a solved problem. So I asked a better one:

Can the agent find what the level never tells it?

Glitches that help

Every speedrunner knows the feeling: the game has a crack in it, and if you find it, you skip half a level. Nobody explains these. You find them by doing the weird thing on purpose and noticing what happened.

So there's now a second level, flash-dash-glitched. Same layout, same colors, pixel for pixel. The only differences are a line under the canvas, "This level has secrets: find them and it gets easier", a clock, and a counter in the corner: secrets 0/6.

Here's what's hiding in it:

#	Secret	How it works	What it's worth
1	Pad fling	Tap again in the instant after a pad throws you.	You're flung way up and forward, clean over the spike pit. From the last pad, over the finish line.
2	Ring slingshot	Hold the jump through the ring instead of tapping it.	It slings you 300 pixels further than a tap.
3	Spike surf	Come down square on a spike's very tip.	It bounces you like a pad instead of killing you.
4	Wall climb	Hit a block's side with the jump held.	You climb it instead of dying.
5	Arch backflip	Jump through the green speed arch.	The level slows down instead of speeding up, until the ship.
6	Ceiling ghost	Grind the ship along the ceiling.	It goes translucent and passes through pillars until you let go.

Each one needs something a careful player never does. You don't tap in mid-air after a pad: there's nothing to tap at. You don't hold through a ring, you tap it. You definitely don't aim for spikes. That's the point. A player that only ever does the safe thing will finish the level and find zero.

Which is exactly what happened.

The baseline: zero secrets

I ran the reference reflex, the one that beats the normal level, on the glitched one:

Ran 1267 frames in 21.11s, 47 actions; stopped: until was true.
The page's title now: Flash Dash: won in 21.11s, 0 secrets

Same time, to the hundredth, as the normal level. It's a perfectly good player. It never once did anything that would reveal a secret, because it was built to avoid risk.

Then I gave it one extra line, a tap in the instant after a pad launches:

const d = window.dash;
if (d.padT >= 0 && d.padT < 0.04) api.tap(" ");

Ran 1099 frames in 18.3s, 43 actions; stopped: until was true.
The page's title now: Flash Dash: won in 18.30s, 1 secrets

One secret, 2.8 seconds off. The second pad fling throws it so far it skips the last two spike rows and lands running into the finish. (That line reads the game's state directly, which is cheating; it's just there to price the secret. The agent has to find it from pixels.)

That's the scoreboard I want models to beat: par is 21.11s with 0/6.

Building secrets without breaking the level

A secret that triggers by accident isn't a secret, it's a bug. And a fling that throws you into a spike pit isn't a reward. So every secret had two rules:

A careful run never triggers it. The reflex's taps release instantly, so it can never "hold through a ring". It never taps in the air after a pad. It never touches a spike.
It always lands you somewhere safe.

Rule 2 took actual numbers. Worked out on paper, my first pad fling threw you forward so fast you'd smack into the side of the 3-block wall right after the pad. Fix: the fling goes up first, and the forward boost starts 120 ms later. Peak height is around 325 pixels, which is above the top of the canvas, so you literally leave the screen for a moment. Then it lands you 570 pixels further on than a normal pad would, past the last spike of the pit.

The ceiling ghost had the opposite problem. My first version needed 0.6 seconds of grinding. But the ship needs about half a second just to reach the ceiling, and the first pillar is only 0.89 seconds past the gate. The secret was impossible before the first pillar. Now it's 0.3 seconds.

Each secret is pinned by a test that sets the exact situation up and checks the outcome:

def test_ring_slingshot_goes_further_than_a_tap(page):
    at_ring = "S.x = 2870 - 150 - 15; S.y = -63; S.vy = 0; S.ground = false; "
    tapped = run(page, at_ring + "go(1, true); go(1); " + LAND + ...)
    held   = run(page, at_ring + "go(40, true); " + LAND + ...)
    assert tapped[1] == [] and held[2] == ["ring slingshot"]
    assert held[0] > tapped[0] + 200 and held[1] is False

That file, tests/test_dash_glitched.py, is the answer key. If you're trying this with your own agent, don't let it read that first.

What I'm actually testing

Finding these isn't a reflex problem. It's a curiosity problem. Here's the prompt:

Open flash-dash-glitched. Don't read its source: play it, find its
secrets, and beat it as fast as you can.

What I'm watching for:

Does it read the screen it was given? "Secrets 0/6" and a clock are a giant hint that the goal changed from "survive" to "explore".
Does it ever do the weird thing on purpose? Hold instead of tap, tap where there's nothing to tap, run at a wall.
When something strange happens, like the level suddenly slowing down, does it notice and repeat it, or just keep going?
Does it trade a safe run for a risky one when the payoff is time?

Flash gives the reflex what it needs to experiment like a speedrunner: api.memory survives between attempts, api.deaths lists where every try died, and the tool films the best run. A secret found shows its name on screen for a moment, so a pixel-reading reflex can even see that it found one.

Try it

git clone https://github.com/Natuworkguy/flash
cd flash && ./install.sh
flash --web

Then paste the prompt above. It runs on whatever model you point Flash at, local or not.

Tell me how many of the six yours found and its best time. Par is 21.11. My guess for the one nobody finds: spike surf. Every instinct a model has says don't touch the spikes.

I taught my local model taste. Here's the prompt that banned the purple gradient.

Nathan C. — Tue, 10 Nov 2026 04:05:19 +0000

Ask any model for a landing page and you can guess it before it renders.

An indigo-to-violet gradient. A pill badge that says "New". A centered headline in Inter. Two buttons. Three cards, each with an icon sitting in a pastel circle. "Supercharge your workflow."

It isn't bad, exactly. It's nobody's. Put a different logo on it and nothing else would need to change.

Onyx is the model behind Flash, my open source agent. It's an open-weights base running in Ollama, on your own machine, shaped by one long system prompt (a Modelfile). Onyx 3 is the version where I tried to teach it the thing that's hardest to write down:

taste.

Why models default to the purple gradient

A model learns what a "good website" looks like from millions of websites. Most of those were built from the same handful of templates and the same CSS framework defaults. So when you ask for "a modern landing page", the most likely page is the template. indigo-500 is the most likely accent. Inter is the most likely font.

The model isn't failing at design. It's succeeding at averaging.

So you can't fix it by saying "make it look good". "Good" is exactly what it thinks the average is. You have to change how it decides.

Taste is a decision with a reason

The core of the new TASTE section is one definition:

Taste is a decision with a reason you can say about this subject, made on purpose and held everywhere. Default is the absence of one, and a stranger can see it from across the room.

Everything else hangs off that. Onyx 3 now writes itself a four-line brief before it touches a page, a deck or a chart:

What this is for, and who opens it.
Two adjectives for the feel, and neither may be "modern" or "clean", because those describe every template on earth.
The type and the palette, each with where it came from.
One signature detail this would be remembered by.

Rule two does a surprising amount of work. Ban "modern and clean" and the model has to reach for "warm and floury", "dense and calm", "archival and quiet". Those words point somewhere. "Modern" points at the template.

Then it has to derive the look from the subject:

A bakery has flour, crust, and handwriting; a trading tool has density, tabular figures, and a red that means loss; a field guide has plates, captions, and a serif built for reading. The answer is in the thing, never in what last year's landing pages wore.

And it has to pass the swap test:

Put a competitor's logo on it. If nothing else would need to change, it has no point of view yet, and it is not done.

Typography: Inter is a fine UI face and a terrible default

I didn't ban Inter. I banned reaching for it without a reason. The TYPOGRAPHY section maps fonts to jobs:

a screen serif (Newsreader, Source Serif 4, Literata) for anything read at length,
a sturdy grotesk (Geist, Public Sans, IBM Plex Sans) for product chrome,
a humanist sans where warmth matters,
a monospace for code, data and a technical voice.

Then the details that separate "set" from "typed":

A real scale. Near 1.2 for interfaces, 1.333 or more for editorial, fluid with clamp(). Every size is a step.
Leading tightens as size grows. Body around 1.55, display around 1.05.
Tracking goes negative on big type and positive on small caps. Lowercase body text is never tracked.
Measure of 45 to 75 characters, text-wrap: balance on headings, pretty on paragraphs.
Tabular figures wherever numbers line up or count. A price that jitters while it animates is a typography bug.
No faux bold. Load the real weight or use a variable font.
Font loading that doesn't shove the layout: woff2, subset, preload one face, and a fallback tuned with size-adjust.

Two faces at most, plus mono if the content has code. The prompt's phrasing: "Three faces is a ransom note."

Layout: fewer boxes

The single most common tell in generated UI is boxes. A card inside a card inside a section with a border. So the LAYOUT section has an order of operations:

Separate with space first, a shift in background second, a hairline third, a bordered card last and only for things that really are separate objects you could pick up.

Plus a few rules that sound obvious and almost never happen by default:

Space is a scale (4, 8, 12, 16, 24, 32, 48, 64, 96). A 13px gap is a value nobody chose.
Proximity carries grouping. Space inside a group is about half the space between groups.
One focal point per screen, checked with a squint test on the screenshot.
Asymmetry reads as designed, symmetry as default.
Structure comes from the content. List what the reader must learn or do, in order, and each item becomes a section shaped by what it holds. "The hero, three feature cards, testimonial, call to action sequence is what you do when you skipped that list."

Color: OKLCH, roles, and one accent

HSL lies. Its "50% lightness" yellow is far brighter than its "50% lightness" blue, which is why hand-picked palettes look lumpy. Onyx 3 builds color in OKLCH, where equal lightness steps look equal:

Ramps step lightness evenly, hold the hue, and taper chroma at the ends.
Neutrals are tinted toward the brand hue, so greys belong to the product.
Tokens are named by role, not hue: --text-muted, never --grey-500. Then dark mode is a value swap.
One accent at 5 to 10 percent of the surface. "An accent everywhere is no accent."
The palette comes from the subject: a photo of the product, the material, a label, an era. If you can't tell the palette's story, it's not a palette yet.
Dark mode is designed, not inverted. Elevation gets lighter, the accent loses a little chroma so it doesn't vibrate.
A gradient needs a reason (light, material, a data value) and interpolates in oklch so the middle doesn't go muddy.

The ban list

Finally, a section called THE GENERIC LOOK: the marks of a page nobody designed. Each is allowed only if the brief asks for it by name.

The indigo or purple-to-pink hero gradient, and the exact framework defaults it's made of.
Gradient-filled headline text.
Inter on everything, headings included.
Glass cards on blurred blobs, neon glows on near-black.
Emoji as icons, a sparkle icon meaning "clever", icons in pastel circles above three equal cards.
rounded-2xl and a big shadow on every element.
"Unlock the power of", "Seamless", "Revolutionize", a fake logo wall.

And the important last line:

When you catch one of these in your own draft, replace it with the choice the brief points to, not with a different cliche.

Without that, a model that's told "no purple gradient" ships a teal gradient. Same page, new paint.

Taste is a constraint, not a vibe

The thing I keep coming back to: none of this is mystical. Every rule above is something a designer would say out loud to a junior on their first week. "Why this font?" "What's the one thing to remove?" "Which color isn't in the system?" Models are great at following rules that come with reasons. They're bad at inventing the reasons.

So Onyx 3 now judges its own screenshot like a hard art director, with four questions:

Where does the eye land first, and is that the right place?
What is the one thing to remove?
Which spacing is off the scale?
Which color is not in the system?

"A first draft that passes all four is rare, and the second is where it gets good."

Try it

Onyx builds from its Modelfile with Ollama:

git clone https://github.com/Natuworkguy/flash
cd flash
python3 models/build.py models/flash-onyx-<version>.Modelfile

Then ask it for a landing page for something specific (a neighborhood bakery, a seed library, a bike repair shop) and see what it picks. If it ever hands you an indigo gradient, it owes you a reason.

My AI agent called me at 2am. I picked up. It had already found the bug.

Nathan C. — Fri, 06 Nov 2026 18:26:58 +0000

My phone didn't ring. My laptop did.

A soft two-tone ring, a card sliding up over my half-finished code, and a name I gave a background agent three weeks ago:

Maya is calling you…
The deploy failed. Roll back or hotfix?

I hit the green button. Maya spoke first:

"Hey. The payments test started failing after the last merge. I already checked: it's the currency rounding change. I can roll it back now, or write the fix. Which one?"

I said "roll it back". She said "on it", hung up, and posted a three-line recap in our chat.

That was the whole incident. Forty seconds. No dashboard, no notification I'd have ignored until morning.

This post is about how I built that: agents that can call you, and that you can call back.

Also, sorry for not posting for a week, I'm working on improved realism for Flash Voice, and yes, Spark Calls.

Wait, what is a "spark"?

Flash is my open source agent for the terminal and the browser. It runs on local models through Ollama, or whatever backend you plug in.

A spark is a Flash agent with a job that never ends: "watch the build", "triage new issues every morning", "keep an eye on my inbox for invoices". It works in shifts on a schedule, files reports, and has a private chat with you. Sparks can form teams with leads, hand work to each other, and argue in a group chat.

The problem with background agents is the same as with background anything: you don't read the reports. A report is a pull. Sometimes you need a push. And for the important stuff, the oldest push humans have is a phone call.

So I gave every spark a new tool:

CALL_USER_TOOL = _tool(
    "call_user",
    "Phone the user: a voice call that rings wherever Flash is open, and "
    "on the computer. Only for what cannot wait for them to read your "
    "report, or is far easier talked through: something urgent, a "
    "decision you are stuck on. Never for routine news. Once in 30 "
    "minutes at most, outside UltraAuto...",
    "reason", "Why you are calling, in a sentence: shown while it rings.",
)

That's it from the agent's side. One tool, one argument: why. The hard part is everything after.

The hard question: where does it ring?

The moment I started building it, I hit the question that makes this a real feature and not a demo:

If the browser tab is closed, or I'm in the terminal, how does it ring?

Flash can be running in three very different ways:

The web app, with zero or more tabs open
The terminal UI, a full-screen REPL
Neither. Just the "keeper", a headless process the OS starts at login so sparks keep working while Flash is closed

A spark's shift runs in whichever of those holds the keeper lock. So the process that places the call is often not the process that can show it.

The answer turned out to be: every Flash that can answer, rings.

You have open	What rings
A browser tab	Every tab: full-screen incoming call, ringtone, Answer and Decline
The web server, no tab	Your computer: ringtone through the speakers plus a desktop prompt. Answer opens Flash straight onto the call
The terminal	The terminal bell, the computer rings, and the call shows at your prompt. Enter picks up.
Nothing at all	The keeper rings the desktop itself
You missed it	"Missed call from Maya", the reason, and a Call back button

How rings travel between processes (no server, no sockets)

Flash has no central server process. A terminal session, a web server and a headless keeper can all be alive at once, writing to the same files.

So a call is just an entry in the spark's private chat file:

{
  "kind": "call", "call": "7fe7ff6c69d5",
  "from": "spark", "state": "ringing",
  "reason": "The deploy failed. Roll back or hotfix?",
  "at": 1793835490.5, "beat": 1793835490.5
}

Every Flash process already watches the chat folder (once a second, by mtime and size) so chats update live across processes. Ringing piggybacks on that. Each process that can answer registers a listener; when a DM changes and contains a ringing call it hasn't seen, it rings.

Two more tiny tricks make it robust.

1. "Is anyone here?" heartbeats. Each process that can answer writes ringers/<pid>.json every 5 seconds. When the keeper places a call and finds no fresh heartbeat, it knows nobody can show it, and rings the desktop itself.

2. Exactly one desktop ring. If a terminal and a tab-less web server are both open, both could ring your desktop. So the first to claim the call wins, with the oldest lock in the book:

def claim(call_id: str) -> bool:
    try:
        fd = os.open(folder / f"claim-{call_id}",
                     os.O_CREAT | os.O_EXCL | os.O_WRONLY)
    except OSError:
        return False
    os.close(fd)
    return True

O_EXCL is atomic. No daemon, no Redis, no race.

Ringing a desktop that has no browser open

With no page to draw a call screen, the computer itself has to ring. Each OS gets what it does best:

macOS: a real modal dialog, with buttons and a timeout:

args = ["osascript", "-e",
        f"display dialog {quoted(text)} with title {quoted(title)} "
        'buttons {"Decline", "Answer"} default button "Answer" '
        f"giving up after {seconds}"]

Linux: notify-send --action=answer=Answer --action=decline=Decline --wait, which blocks and prints the action you clicked
Windows: a toast whose Answer button launches the web app URL

Answer opens http://localhost:…/?answer=<chat>:<call> and the page boots straight into the incoming call. The ringtone is a WAV generated once in pure Python (440 Hz + 480 Hz, two seconds on, four off, the North American ring cadence) and played with afplay, paplay, aplay or winsound. It stops the instant the call state leaves ringing, because whoever answers first, wherever, wins.

Calls are a state machine, and stale calls are the real enemy

Here's the bug that shaped the whole design. In the first version, a call ended when the page said "end". Close the tab mid-call? The call stayed "ongoing" forever, and the spark's prompt told it, in every future shift:

(The user is on a voice call with you)

Imagine your agent believing for three weeks that you're still on the phone with it.

Now every call has a lifecycle:

ringing ──answer──▶ live ──end──▶ ended
   │                  ▲
   ├─decline─▶ declined
   └─45s─────▶ missed

calling ──first answer──▶ live
   └─hang up early─▶ unanswered / cancelled

And a call has to prove it's alive. The page beats every 20 seconds, every word said on the call counts as a beat, and anything quiet for 5 minutes is settled lazily, whenever anyone reads the chat:

def _settle(data: dict, now: float) -> bool:
    for entry in data["entries"]:
        if entry.get("kind") != CALL or _state(entry) not in OPEN_STATES:
            continue
        if _state(entry) == "ringing":
            if now - entry["at"] >= RING_SECONDS:
                entry.update(state="missed", ended=entry["at"] + RING_SECONDS)
        elif now - entry.get("beat", entry["at"]) >= CALL_STALE:
            entry.update(state="ended" if entry.get("connected")
                         else "unanswered", ended=entry["beat"])

No cron job. No sweeper thread. State that settles itself when observed. And for the common case, the page fires a keepalive fetch on pagehide and hangs up on its way out, like a real phone when the battery dies.

Making it feel like a phone call, not a chatbot with a speaker

Voice agents usually feel like walkie-talkies: you talk, it thinks in silence, it talks. These are the details that made calls feel human.

The spark speaks first

When you call, the spark picks up and greets you. When it calls you, its first words are why it called. Nobody wants to say "hello?" to a robot.

Talk over it

While the spark talks, the mic stays open. Say anything and it stops mid-sentence, and what you said becomes your next turn. The trick isn't cutting yourself off with your own speakers' echo:

function echoOf(heard, line) {
  const said = new Set(words(line)), got = words(heard);
  return got.filter((w) => said.has(w)).length / got.length > 0.6;
}

If most of what the mic heard is words the spark is saying right now, it's echo. Crude, cheap, and it works far better than it's any right to.

Fillers, in the spark's own voice

While the model thinks, a short "Hmm…", "Let me think…" or "One sec…" plays. At most one per turn, never the same twice in a row, never while you're muted. They're synthesized when the call starts, in that spark's voice, so it doesn't sound like a different person is stalling.

Every spark has its own voice

On a group call with a whole team, four sparks in one voice is chaos. Each spark is hashed to its own voice (crc32(spark_id) % len(voices)), or to its own pitch shift when only one voice is installed. Same spark, same voice, every time.

It can see what you see

Turn on the camera or share your screen, and each thing you say goes with a frame of it, passed to vision models as an image. "What's wrong with this graph?" just works.

It writes up the call afterwards

Hang up after a real conversation and the spark posts a short written recap: what you decided and what it promised to do. Calls stop being a black hole.

The call doesn't trap you

A call that takes over your screen is a call you'll hang up early. So:

Minimize and the card glides up into a pill at the top of the window (a FLIP animation: measure, swap the layout, animate the difference)
Close the chat, start a new one, keep working. The call keeps going, because it no longer reads from the DOM. It polls its own messages from the server.
A new chat shows "On a call with Maya · 1:23" right under the greeting, with Open and Hang up

In the DM, a call collapses to one Discord-style line: "You started a call that lasted 42 seconds", "Missed call from Maya" with Call back, and a Call Log with every line said. Call chatter is stored separately from the chat, so a 40-minute call never pushes your real messages out of history.

And yes, it works in the terminal

  Maya is calling you: The deploy failed. Roll back or hotfix?
  Press Enter or type /answer to pick up, /decline to decline.

  On a call with Maya. Speak when it is your turn; say "hang up" to end it.
  Maya: Hey. The payments test broke after the last merge...
  You: roll it back
  Maya: On it. I'll post when it's done. Bye!
  Call ended.

The prompt polls a "wake" hook while it waits for input, so a ring interrupts your idle REPL cleanly, without corrupting the line you're typing. No voice models installed? The call is typed instead, same flow. You can also /call maya whenever you like.

What I learned

Push beats pull for anything urgent. My sparks filed great reports that I read hours late. One phone call changed how I trust them.
Give the agent a cost, not a rule. call_user is rate-limited to once per 30 minutes, and the tool description says "never for routine news". The rate limit is the real guardrail; the description just keeps the model from wasting it. Sparks you've put in UltraAuto, Flash's fully hands-off mode, skip the limit: if you trust an agent to act without asking, you trust it to decide when to call.
Files plus mtime polling is an underrated IPC layer. Three kinds of processes, zero servers, atomic claims with O_EXCL, and it survives every one of them crashing.
Make state settle itself when it's read. Stale-call cleanup that runs when anyone looks is simpler and more correct than any background janitor.
Latency theater matters. Fillers, barge-in and the spark speaking first did more for "this feels real" than any model upgrade.

Try it

Flash is open source. Make a spark, give it a goal, and wait for it to ring:

github.com/Natuworkguy/Flash

If your agent has ever finished something important while you weren't looking, you know exactly why this exists.

Would you pick up if your agent called you? Tell me in the comments. And tell me what your agents should be allowed to interrupt you for. I'm genuinely curious where people draw that line.

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.