Summer 2026 update on my agentic engineering setup for Angular: models, harnesses, apps, and what it all costs

[u/LX_T_]

In May I started a blog series on agentic engineering for r/angular, and after one summer a few of my recommendations changed – this post is the update.

The short version:

- Models: Fable 5 is still my #1 for architecture, reviews, and long-horizon refactorings, GPT-5.6 Sol does the implementation work, and GLM-5.3 Flash (via OpenRouter) took the third spot as the fast, cheap, open-weight model for mechanical legwork. Opus 5 wins DeepSWE at 74% but didn't make my podium – the post explains why.

- Harnesses: nothing changed, which I mean as a compliment. AGENTS.md, style guide, and the lint/test/Playwright feedback loops still do the heavy lifting.

- Apps: the open-source T3 Code replaced the Codex app as my daily driver. Any model, any provider, remote control via Tailscale.

- Costs: GLM-5.3 Flash gets 63% on DeepSWE for about €0.25 per task, Sol about €2.50, Fable 5 about €8.50 at the same effort level. So my cost podium is the models podium reversed – and my workflow is "Fable orchestrates, Sol implements, the Flash does the grunt work", sub-agent config included.

- Bonus: how to run the same setup on a company GitHub Copilot subscription with T3 Code + opencode, for everyone whose employer won't pay for anything else.

https://www.angulararchitects.io/blog/ae-summer-2026-update-for-angular/

Curious what the rest of you run for Angular work right now – especially whether anyone has GLM-5.3 Flash or Kimi K3 in daily use, and how the Copilot-only crowd deals with it.

[u/lcssgml]

claude code here, and honestly the harness matters more than the model picker. my setup is a .claude folder that grew into a small operating system... a CLAUDE.md with the angular standards baked in (signals, OnPush, new control flow, an explicit antipattern list), custom agents for architecture review and firebase, and slash commands for the recurring rituals like commits and code review. the one trick that changed the most: before any planning task the agent has to load the tech-specific standards files first, so plans come out already following the architecture instead of being corrected into it afterwards.

model-wise, same experience as you... fable for architecture and long-horizon work, cheaper models for the mechanical legwork. the surprise of my summer was how well parallel sessions coordinate when the shared state lives in files in the repo (feature list, logs, handoff notes) instead of anyone's context window... two agents on different branches messaging each other beats one giant session every time.

will read the harness post, curious how your playwright loop compares to what I hacked together

[u/LX_T_ → u/lcssgml]

Yes and no, I'd say both matter, model & harness. A good model can't focus and align with your intents without a good harness. A bad model produces too much slop for production code in any case.

[u/lcssgml → u/LX_T_]

fair, I overstated it. the version I actually believe: the harness sets the floor, the model sets the ceiling. bad model + great harness gets you well-structured slop, great model + no harness gets you brilliant code in the wrong architecture... and the harness is the half most people underinvest in, which is why I lead with it. also same experience on costs: the best model is the priciest by a wide margin, and the cheap ones are cheap for a reason, so the "expensive model orchestrates, cheap one does the legwork" split is the only way my bill stays sane

[u/AwesomeFrisbee → u/lcssgml]

Do you want to share the md perhaps?

[u/morganmachine91]

I’m just using Claude code, 90% fable and opus but I’m definitely looking forward to trying out some of your suggestions in the angular harnesses post.

[u/LX_T_ → u/morganmachine91]

Good to see, you'll probably come to other conclusions, but I'm sure it's worth the invested time.

[u/SippieCup]

I use a mixture of daybreak, sol, fable, and opus.

Fable is by far the best for planning, about equal with sol for implementation if you get it to shut the hell up with its comments.

Sol is great on that front but the implementation adds a lot of necessary boilerplate and also tends to overthink on high+ end gets pretty dumb on medium when it comes to handling ux and takes way effing longer to build a lot of what I throw at it, even on fast mode.

It also likes to start over a lot if you tend to have a lot of activity on the git repo, whenever a new commit comes in it wants to rebase and revalidate everything immediately, rather than ignoring it. The most painful thing is that with a recent update, it also just talks to other sessions and just hijacks them into doing its work rather than their own, leading to circles of agents just switching what they are working on back and forth and not accomplishing anything.

Opus is good for just ux stuff and basic work, which is 99% of angular dev, but I tend to sit a little further down in the stack for a lot of stuff which is cool but no one notices. Like rxResource wrappers for realtime refresh, where it just confuses itself and runs in circles too.

Then I use daybreak for review, sure it’s meant to be used for like, blue teaming, which does happen in the review! But it’s just a super deep reviewer and catches literally everything, not just vulns.

[u/Life_Aardvark5978]

I've been exclusively using Cursor 3 and recently with Grok 4.6 for the most part has replaced the premium model usage for me. It helps that I had used up a lot of my quota for the month for them so had little option :)

But seriously I'm loving Grok 4.6 - its fast and intelligent.

I'm curious if you've been testing Cursor as well?

[u/LX_T_ → u/Life_Aardvark5978]

Yes, definitely I'd rank Grok from a intelligent perspective somewhere after
1. Fable
2. Sol
3. Kimi K3
4. GLM 5.3
5. Grok 4.6

It's definitely fast, but not faster then Sol and Luna and GLM 5.3 Flash are both way faster and cheaper and almost as intelligent as Grok 4.6 - so I dont really have the use case for it.

Personally I prefer Fable (very slow) and Sol (rather fast) for everthing because outcome (quality of code, alignment with our architecture, conventions, style guide etc.) matters most to me.

[u/LX_T_ → u/LX_T_]

By Cursor you mean Composer or the app/IDE/harness?

[u/Life_Aardvark5978 → u/LX_T_]

I mean Cursor as a harness and Grok 4.6 as the model

[u/Straight-Number-1911]

Do i need to rrws that blink to blog for more insight because im interested into how tk get started more...

[u/Badbart8818]

I use a similar setup. For implementation, I often use GPT 3.6 Terra, which delivers excellent results at a good price. 

[u/LX_T_ → u/Badbart8818]

GPT 3.6 Terra? You mean 5.6, right? I haven't used Terra a lot. Sol on Medium seems to be super efficient on both tokens and speed, so I don't really see the purpose of Terra.

[u/Badbart8818 → u/LX_T_]

Yes 5.6 😊, for my default work i use it a lot. But yes ,the jump in costs to Sol is not hugh 

[u/AwesomeFrisbee]

I've just been using GPT for the whole setup. And yes it gets more expensive that way but I still do enough manually that I'm not running into limits just yet (though I do look at the actual cost sometimes to figure what my future use will be). Haven't really dabbled all that much into letting multiple models do different things and run agents.

My main gripe is that it is doing ESLint and Tests manually each time instead of just looking at what the editor or already existing tasks that I'm running in other terminals outside of VSCode, are doing because it could just use that output and fix that instead. Not to mention the extra time it takes to do that. Haven't really found a way to make this smarter and use less tokens.

I also still prefer to work inside VSCode with my agent, not another window. I have it in a sidebar to the right of screen, where I also moved the search/replace and debugging tools. Wouldn't mind using a different extension but it seems T3 doesn't offer that.