Production experience
I ran the i-quality version of this on my dgx-spark with a llama.cpp backend and a nice large context and
hooked it up to Opencode. I had it read the source of a moderately complex (19M of text) golang project I've
been working on. It took a while to read and summarize the entire project into context. I'd say it meandered
a little bit as I watched the reasoning process, but it inferred some pretty subtle details.
I then gave it a task to create a pair of systemd --user unit files for a pair of new models I had generated.
It needed to create the files in the proper format to be discovered by my parser, which was buried in the code.
It had to decide proper context sizes and model tuning parameters based on the model size and my available
system parameters. It figured out my system architecture autonomously, including the unified memory and cuda
architecture. It made educated guesses about the drafter settings (and got them right).
It determined that naming conventions and picked sane defaults for both models. It crafted and placed the
two units, ran the proper system tools to reread the units, ran the systemd verify command to check that the
format was correctly parsed by systemd.
It then wrote a little parser to double-check that the systemd units it had written parsed correctly and fixed
a bug it found in its parsing string. Once all that was done, it summarized all this for me and reported success.
If anything I would have preferred it asked for more clarification, but it completed the entire task autonomously.
Everything worked on the first try.
This is a capable large-context model natively trained to 1M tokens of context. I think this is the model I'll
use when I want to do something hard on my local machine that the fast little models get stuck.