waximabbax

Right now the only Agent that fully supports Computer Control both natively and in background on same machine is TheGitAI Coding Agent. It also has similar one for MacOS. Here is a video on that:

https://www.youtube.com/watch?v=p_-pIIIpNXY

You can test it for free, no API Keys needed. Do let me know how it performs compared to other coding agents. And if there are any missing features that you would want me to add.

Thanks.

And its not just me, its everywhere on the internet for everyone. Pretty everyone is complaining about it on the X or atleast was yesterday. Perhaps since it broke many benchmarks there was too much load and that's why they did this and now as soon as it gets less attention quota will improve.

I did and they refused to help and said you used it heavily. Which doesn't make any sense to me since I gave me exact token break down. Quota has slightly improved since yesterday but still nowhere near claude code or other agents.

Looks very impressive especially considering the price and speed. Let's wait for AA to confirm how well their benchmarks hold up.

Alright its still little early since there is not enough independent testing but this looks very promising and I wasn't expecting anthropic to beat GPT-6 Luna especially at the same price. Haiku 5.5 beats Luna on every shared benchmark Anthropic published, particularly computer use and agentic coding.

It mostly feels horribly slow if you leave reasoning effort at max for Sol 6.1. If you dial it to normal/high/xhigh, Sol 6.1 is only a couple of minutes behind Astra, performs almost as well on terminal bench v4 tasks, and is about 4 to 5x cheaper.

Its use case is still pretty narrow, just like Jev. The only time Jev could make sense is if you want thousands of requests per second and can sacrifice a bit of accuracy. Otherwise, modern LLMs are super cheap, like GPT-6 Luna, GLM-5.3-Flash, or even Gemma 4, and reason much better than Jev with better accuracy while being perfectly capable of returning structured JSON. So it’s basically enforcing typed answers with lower accuracy vs. occasionally getting the response format wrong but having better accuracy.

Probably one of the better real-world AI use cases I’ve seen. Automate the tedious data work, save hours, and keep the actual scientific decisions with experts.

A few years ago, when terminal agents were still somewhat new, indexing was thought to be the holy grail for coding agents. But in most cases, it did us more harm than good. More often than not, it confused the model instead of letting it directly grep for context and work its way around the codebase. Not to mention that it also increased input token costs and added extra round trips.

Similarity search is rarely that relevant when working on codebases. Our biggest learning actually came from an accidental technical bug where indexing had been returning zero hits for quite some time, and we barely noticed any performance degradation. In fact, the agent seemed to be working better than ever.

After discovering the bug, we did some rigorous A/B testing and realized it was best to drop indexing altogether. There could still be a case for it in extremely large codebases with a lot of docs e.g. excel or several text files.

We removed retrieval from our coding agent a while back. What convinced us wasn’t a benchmark, we found that the retrieval path had been returning zero results for quite some time because of a technical bug, still nobody noticed, indeed it was working better than before.

After doing some rigorous A/B testing, we dropped indexing. For coding, I think the reason is that a repo is already searchable. Imports, call sites, file and test names, grep gives you cheap yet reliable version of what indexing would do, and the agent can read around a hit to verify it. Chunked retrieval hands the model something that looks right, and it tends to trust that instead of going to look for the actual source. Another thing that I noticed was the most intelligent models like Opus 5 and Fable ignored chunks anyway most of the time for some reason. Possibly perhaps they are trained around not trusting similarity checks for codebases.

Extremely large codebases with docs feel different. You can’t grep for a concept you can’t name. That’s the case where I’d still use retrieval.

(I work on TheGitAI, for disclosure.)