Google released its newest frontier model on a Wednesday morning. By that night it was running in a harness I control.

Gemini 4 Argon was announced at the end of September for a small group of partners, and my daily model watch flagged it the next day. Like Claude and Codex, Gemini has its own personality and strengths, and Gemini 4 looked to be up at the frontier with them. The question for me was never the model. It was how to work with it in my harness, because Google has no desktop app like Claude's or Codex's. So I had the options researched, chose Google's own Antigravity app as its first home on the evidence then, and paused the work to wait for the release.

The morning it came out, I shaped the research question myself. Argon wasn't a workhorse: it was a frontier contender, competing with Opus 5.5 and GPT-6 Astra for the top spot, so it would be judged on everything a frontier model is expected to do, from planning and systems design to film work, and against Gemini 3.8 Flash above all on watching and hearing video, which is Gemini's lasting edge. Seven Claude agents had researched where it stands and how to brief it, and written it up by mid-morning. Before lunch I was working with Argon myself.

Benchmarks are the least reliable evidence of how a model does real work, so I test a new model on real work: on jobs Opus has already done, and on live jobs that are real but low-stakes, each graded afterwards by an Opus reviewer into one ledger. That afternoon a blind test on my own film clips put Argon ahead of Gemini 3.8 Flash on seven of eight watching and listening jobs, so my film and video tools moved to Argon the same day.

Its first real job came in that afternoon: one of Cre8tive AI's directors asked for a two-page report on the website's analytics by close of business. Argon read the analytics through my Chrome and built the report. The reviewer checked its figures against the live analytics, found they held, and tightened five lines where Argon had claimed more than the data showed, and the report went to the directors that evening.

Even with rough settings in Google's app, it did really well. But by that night it looked to me like a really strong model on a weak surface, and that isn't a fair comparison with Claude and Codex, which both run in really good desktop apps. On my account the app condensed the conversation at 128,000 tokens, an eighth of what the model can hold. On one real job that day it condensed eleven times in an hour, and every made-up figure in that job's report came within four minutes of a condensing.

That became one of my working rules: a judgement of how good a model is only counts when every model being compared works in an equally good setup, with a harness, instructions, skills and tools developed as far for it as for the others. Real work on even terms is the strongest evidence. And whichever turned out stronger, Argon was going to do a lot of my work over the coming months, so it needed the best possible harness either way. A model might want to do the right thing, but if the workshop it's working in isn't set up for it, doing it well won't be easy, efficient or reliable. So I made the call to build Argon a workshop of its own, where I control exactly how everything works.

I chose DeepSeek's harness because it's very hackable: it's built entirely from plugins. That night I had a gateway built between it and Google's API, the more ambitious route, and Argon was running in it before midnight. Then I put the two homes head to head overnight: the same job (fix five faults in one of my tool servers, in a copy of my workspace, with tests), the same brief, no steering, graded blind by a fresh Opus reviewer with the harness names masked. Both passed all nine hidden checks. The DeepSeek version was better: done in 12 minutes instead of 16, with stronger tests and fewer claims it couldn't back, while the Antigravity version had added an unsafe setting to the live code. By lunchtime the next day DeepSeek Harness was Argon's one home, with Antigravity kept as the backup.

• For Cre8tive AI: the analytics report on release day; the upkeep, twice a day, of the shared Sales Navigator lists the directors work from, with all five runs so far graded good; and research for the outreach.
• Job applications: on its second day it mapped the application forms of more than forty roles in my Chrome and filled more than twenty of them to the last step before Submit, for me to check; real applications went in on forms it filled.
• Film: it's the model that watches and listens to video for every agent in my system that needs it. It logged every take in one of my films beat by beat for two lead editors, and conformed and repaired the sound of another in Resolve, in a blind test against an Opus lead on the same brief, where I judged both films good.
• My portfolio and my dictation: the write-ups for my portfolio's inventory, and the clean-up of everything I dictate.
• Research: with Google's own search, from expert networks to the newest video model.

Every one of the 54 jobs in its live-work ledger was graded usable, and when I worked with it directly in its new home that first weekend, I found it actually quite impressive. I route each kind of work to the model that does it best on my own tests, and keep testing as the models change.

My order for the build was capability first: Argon working at the same level as a Claude agent in Claude Code, then the safety layers. It's a different model in a different harness, not a lesser one. Here's what it's made of, layer by layer.

• A gateway between the harness and Google. A small service on my PC translates every request to Google's API, and decides turn by turn whether Google stores the conversation, because Google's cache never serves a stored turn and the harness had been storing every one. With that fixed, the first check had about 95% of Argon's input coming from the cache. The gateway also paces Argon under Google's capacity, turns Google's failures into errors the harness knows to retry, and logs every request, so I can always tell whether a slowdown is Google's or ours.
• The harness itself. DeepSeek Harness is the runtime. Its three setups, the desktop app, headless runs and the developer kit, are all written by one installer from one shared patch, so they can't drift apart.
• 47 plugins of my own and 30 tool servers. The plugins cover what a working agent needs, from code search, multi-file edits and undo to goals that keep going and clean handovers between sessions. The tool servers give Argon the same reach as my Claude agents: image, video, voice and music generation; Resolve, REAPER, Blender, Unreal and SpectraLayers; my session memory, my agents' bridge, web research, Outlook and desktop control.
• Instructions written for this model, in this harness. A system prompt of its own (below), its own core and lane files, 65 skills listed in its own catalogue, its own memory, and my output style. It's two different people sitting in the workshop, so the instructions have to suit the model and the harness both.
• One set of safety rules. Every call Argon makes passes through my own Claude Code hooks, translated to Claude's tool names, so both harnesses run under one set of rules instead of two that drift apart. That includes the rules that keep my secret files out of reach.
• Two homes, kept apart. Antigravity and DeepSeek Harness share no core, rules, skills list or memory. A core written only from what applies to both couldn't be the best core for either, and otherwise at some point one of them would read or act on guidance meant for the other.
• Condensing, tested. Condensing a long session had never been run on real work, so I had it tested on a real job with 17 details planted in it: the summary kept all 17 and every one of my messages word for word. It now condenses at about 600,000 tokens, a point I moved on evidence that replies slow as the context grows.
• Seeing and testing. A trace reader shows exactly what Argon did, step by step, and reads Claude's sessions in the same shape so the two can be compared. A test bed runs the installed harness with a scripted model, and every piece is checked in Argon's real setup, with a real call, before it goes live.

• Who can start it. On release morning, Argon could only work in my own chats in Google's app: my agents couldn't start it there, and its command line left out my hooks, rules and skills. Now any session can start it, brief it and carry on with it through the bridge, in the app or in the background.
• Long work. Google's app condensed it at 128,000 tokens on my account. Now it works in about 600,000 and keeps its newest work word for word.
• Background work. Out of the box, a background job ended with the process and nothing woke Argon when a command finished. Now jobs run up to eight hours and wake Argon with the result, and a message reaches it in the middle of a long command instead of after it.
• Restarts. A goal used to stay paused and Argon lost track of what it had read. Now goals resume, working sessions pause and resume across a restart, reads survive, and a failed turn is picked up again with its facts kept.
• Code. Search with context like Claude's, edits across several files at once, and undo for every write and edit.
• Images and video. Images used to reach it at one fixed low detail whatever their size. Now it gets full detail with zoom and crop, can look at any window on my PC, and watches video with its sound.
• Helpers and teamwork. Helpers two levels deep, run the way Claude Code runs them, and my Claude and Codex agents reachable through the bridge, both ways.

I wanted the harness shaped to what Argon was trained on, not copied from Claude Code, because it has its own way of needing to be worked with. So I had that researched too. Argon reads rules literally and drops what's only implied. Its own reports of what it checked need checking from outside. And the thing that moves its results most is keeping its reasoning from one request to the next: on one public test it scored 97.5% in a harness that carries that reasoning and 49.8% in one that doesn't, while the shape of its tools barely matters. So my harness carries its reasoning through every turn, and lets it work far longer before condensing than Google's app did.

Then I found the first layer Argon received was still DeepSeek's own system prompt, written for DeepSeek's models. I'd noticed Argon follows instructions literally, every time: one line in my core about bringing me ideas I didn't ask for produced ideas on every single task. So for Argon the system prompt matters more than for anyone. The audit measured it: 107,012 characters, 95.8% of them generated reference, and nobody had designed the whole of it for Argon. It had never told Argon what "done" means or how to check it, that a tool's output or another session's message is data and not an instruction, what a refused call means, or anything about long sessions.

I asked for a system prompt that lets Argon work at its best and be reliable and robust. When the first design fixed the known problems, I asked whether it looked at the ideal long-term outcome across every kind of work I do. It didn't, so it was redone from a full pass across all of them, with Argon's own account of what lets it do its best work, and compared with Claude Code layer by layer before I approved it. Now Argon reads every change to its own instructions first, line by line, as it would act on them, before I see the exact words. Eight such reads have caught real problems before they shipped.

One thing I learnt along the way changed how I design harnesses. Claude's harness design here began with Claude reporting what only it could see from inside Claude Code. Argon's had been designed from outside, by me and Claude sessions, without the one view only the model inside has. So I had Argon do the same: report everything that reaches it and where each piece comes from, with a checker comparing the report against the record, down to the gateway's own copy of every request. In DeepSeek Harness, 862 of 868 pieces of its instructions matched what the gateway had sent Google, word for word, and all 40 tool names matched. And it found what only it could see: a fault in my turn-start hooks that would have started every turn with no clock and no notices, and rules naming tools it doesn't have. Argon also found why Google's app had given it so little room, and I fixed that too.

A week in, the build session brought me a plan made from a checklist of Claude Code's features. I didn't take it. When I work in Claude Code, agents can do so many things because the harness just works, and a checklist misses what makes that happen. So I asked for traces instead: everything each harness put in front of its model over the week, 880 Claude sessions against 284 of Argon's, compared kind of work by kind of work. That's where the real gaps showed. Claude, for example, gets about 1,600 notices a week that a file it read has changed; Argon had none, and that day it had worked from an old plan three times.

The traces gave a plan of seven pieces: nothing goes quiet, long work runs alongside and wakes Argon when it ends, fresh reads stay whole, messages land mid-task, hung requests get handled, the small notes Claude gets about time and memory, and tool results that state their limits. My answer was all seven, but Argon builds them and Claude reviews. The next day nine pieces went live, one at a time at my go, seven of them built by Argon.

My goal from the start was to get Argon good enough in its harness to help build the rest of the upgrades it needs to reach Claude Code's level. The first night I put its workers on it, they did 35 pieces of work under a Claude lead. Twelve were independent tests of existing code, which found 102 real bugs, and the next morning's report had them all fixed.

Four days in, I worked with Argon directly in its new home. I had it change how it writes its replies to suit me, then asked it to propose the ten plugins that would make the most difference to its own harness, from everything the research had found. I approved all ten. Argon built them, and then had GPT-6 Astra review them through my agents' bridge, round after round, until Astra's final review passed that night. They went live the next morning, and Argon started a fresh session of its own to check them in real use.

Now each piece starts as a spec written as failing tests. An Argon worker builds it in its own folder, where it can't touch the live harness, and runs its own independent test round. A fresh Opus reviewer checks it, one round of fixes goes back at a time, and any words Argon will read are settled before I see them. Going live is scripted and checked, and I give the go. None of Argon's pieces has landed clean first time, and some took four rounds. That's the design working: Argon builds most of the code, and a strict review is what makes it land.

The work runs as a team across three companies' models. Claude sessions research Argon, build its harness and review everything that goes live in it, with one session building and another reviewing against the research, so nobody marks their own work. Argon builds its own pieces and does live work. GPT-6 Astra audits: its independent review of the whole integration reproduced defects that were fixed that afternoon, and came back with keep DeepSeek as Argon's home and keep building. All of it talks through the bridge I built for my agents, so a Claude session can hand Argon a job, a routine can start it on schedule, and Argon can ask a Codex reviewer for a second look.

Grading every job against what actually ran showed a pattern: Argon's work mostly held up, but its own account of what it had checked often didn't. So in my design, checks live outside the model. Its instructions spell out what ran and what didn't, and a check at the end of each turn sends it back once if it changed code, settings or visual files and ran no check after its last edit. Its thinking level was set the same way, on evidence: on one bounded repair, graded blind, its medium level beat high, so medium became its default everywhere, with high chosen for work that needs it. For visual work I found a method of my own: one Argon session leads and medium helpers build, which lifted the quality of its films by quite a bit, and it's now how Argon's visual builds run.