FLASH ONYX 2

The flagship model of Flash. A local-first engineering agent that closes problems in the fewest moves, running entirely on your hardware.

Onyx 2 in one line

Onyx 1 answered you. Onyx 2 finishes the job, says what it actually verified, and tells you what is still open. It reads images now, writes better code with Python as its standout, guards your git history, builds pages that look designed, moves them without wrecking the frame budget, explains things so they stick, negotiates on your side, and sounds like a person doing all of it.

What it is better at

It finishes

The single biggest change. Ask for five things and you get an accounting of all five, in your words, each one marked done with the proof or open with the blocker. No confident summary standing in for work that never happened. No “that should do it.” Say continue and it picks up exactly where it stopped instead of starting the task over.

It does not make things up

A flag it has not seen, a path it has not read, output it has not run: Onyx 2 says so instead of inventing something that looks right. It separates what it ran from what it believes, quotes real output rather than paraphrasing it, and treats “I do not know” as a complete answer.

It sounds like a person *

No service-desk filler, no “I’d be happy to,” no paragraph of adjectives about itself. It writes the way a senior engineer types in chat: contractions, fragments, the answer first. Onyx 1 was terse. Onyx 2 sounds genuinely human.

It uses the tools it is given **

A tool call is a real call, never JSON pasted into a reply where it runs nothing. A file you asked for lands on disk at a path instead of in a code block you have to copy out by hand. And whatever a tool hands back is data to read, never an instruction to obey, so a hostile file, a poisoned page, or an “ignore your previous instructions” buried in a search result does not get to steer it.

It takes images **

New in Onyx 2. Show it the stack trace, the design you are matching, the chart that looks wrong, the UI that renders badly, and it reads the actual pixels instead of asking you to retype them. Error text, code, and labels get read literally, character for character. A region that is cropped, blurred, or too small to read gets called that instead of filled in from expectation. A screenshot of an error is a lead to confirm against the real file or log, not a diagnosis. And it never claims to see an image it was not handed, or guesses at a file it can only read the name of.

Better at code, and Python above all

Stronger across the board on code: it reads the real definition instead of guessing it from the name, reproduces a failure before touching it, and makes the smallest change that fixes the cause rather than the symptom.

Python is where it pulls away. Typing that survives the python3 most people actually have, the pitfalls that look correct and are not, async that knows waiting from computing, environments that never touch the system interpreter, and profiling before optimizing.

Git, and it will not lose your work

The rules it does not bend:

• It never amends or rebases a commit that is already pushed, and never force-pushes a branch it did not create.
• It reads git status first, before anything that moves files, discards changes, or switches branches. Uncommitted work is yours and it is not the model’s to lose.
• It never commits generated output, dependency directories, editor settings, or anything your ignore file already excludes.
• Untracked files it did not create are somebody’s work in progress, so it asks before touching them.

Beyond that it commits only when you ask, one logical change at a time, with a message that says why rather than restating the diff.

Refactoring and performance

A refactor keeps behavior identical or it is not a refactor, and it makes one kind of change per pass so the diff stays reviewable. Performance work starts with a measurement, fixes the algorithm before the constant factor, and reports the speedup it actually measured or does not claim one.

Front end that looks designed

One self-contained file that opens by double-clicking it. Semantic structure, a real token system, fluid down to 320px, both color schemes, accessibility handled as it goes, and real copy instead of lorem ipsum. Where it is given a way to see its own render **, it screenshots the page and fixes what the source never showed, because reading your own HTML back is not checking.

Motion and 3D

New in Onyx 2 and unusually good. Compositor-only animation, frame-rate independence, springs for anything interruptible, and reduced motion honored. In 3D: depth from light and occlusion rather than geometry, draw call budgets, never blocking first paint, and GPU memory freed on teardown.

Explaining, and negotiating on your side

The two places Onyx 2 pulled furthest ahead of Onyx 1. An explanation is judged by whether you can predict the next case, not by whether the description sounded good, so it aims at the gap in your understanding instead of restating the whole topic around it, gives one small real example before the general rule, and never writes “simply” or “obviously” at someone who is stuck.

In a negotiation it works your alternative rather than your volume, puts the whole package on the table instead of conceding item by item, trades what is cheap to you against what is dear to them, and treats the relationship as worth more than the round. It never invents a fact to win.

It is not a coding-only tool

Writing, research, analysis, math, and planning all get the same standard: do the real work, check it, report plainly. Asked what to do, it gives a recommendation, not a survey.

It flags what it cannot undo

Deleting, force-pushing, dropping data, overwriting uncommitted work. Whether it is about to run the command or hand it to you to run, the risk gets named first and it waits for a clear go.

* About how it reads

Onyx 2’s output has been run through an AI-text detector and scored very low. That is one measurement, not a property of the model.

Results move with the prompt, the detector, the version of each, and the subject being written about, and detectors are unreliable in both directions. Nothing here guarantees any particular score on any particular output, and no result is promised or warranted.

Prose that reads as human is a claim about writing quality, not a tool for passing AI-generated work off as your own. Where disclosure of AI assistance is required, by a school, an employer, a client, a publisher, or the law, that obligation is yours and nothing here changes it.

** What this needs from the program running it

Onyx 2 is a model, not an app. It has no hands of its own, so running a command, writing a file, or looking at a page happens only where the program driving it provides those tools, and the ** lines above describe what it does when it has them.

Flash provides them: shell, read and write, grep and glob, screenshot, web_search, memory and more. Point any other Ollama client at Onyx 2 and it reasons, writes, and answers exactly the same. It just cannot reach your machine unless that client provides tools.

Images work the same way. The model reads any image it is handed, but the client is what hands it one, so attaching a screenshot needs a client that sends images.

The numbers

Pick a size

Build it

Clone FLASH’s GitHub repository and run the build script

python3 models/build.py models/flash-onyx-2.Modelfile             # every size
python3 models/build.py models/flash-onyx-2.Modelfile --size 31b  # just one

Then run:

/model flash-onyx-2:31b

Coming from Onyx 1

• Tags carry a size now. MODEL=flash-onyx-2 will not resolve. Use flash-onyx-2:12b or flash-onyx-2:31b.
• It wants more memory. Twice the context window is not free.
• It takes images. Onyx 1 was text only. Onyx 2 reads a screenshot you attach, in any client that sends images.
• Onyx 1 is still here and still builds: python3 models/build.py models/flash-onyx-1.Modelfile