Agentic Engineering: Summer ’26 Update

Executive Summary: The Summer Shifts

When I launched the agentic engineering series back in late May 2026, I was clear with myself: this blog wouldn't become a weekly feed of model announcements. Yet, the pace of change over the past few months means some of my earlier picks now need a quiet update—and I prefer to share that in a single concise post rather than let outdated suggestions linger. Consider this your end-of-summer field note ✔️—the first in what I hope will be a recurring quarterly review—covering all three layers of the stack: the models, the harness, and the apps, plus what each setup costs. For newcomers, the apps and harnesses overview and the harness configuration guide explain exactly how I divide these layers. What follows is a personal, experience-based account from my day-to-day work.

At a Glance: What's Different Now

If you're short on time, here's the gist: my top model choices today are Fable 5, GPT-5.6 Sol, and—for budget-conscious work—GLM-5.3 Flash. On the harness front, there's little to report; the configuration advice from earlier still holds. The apps layer, though, has seen notable movement: the open-source T3 Code takes my top spot, while the Codex app remains my go-to for computer-use tasks. For models and costs, I'm providing the latest official DeepSWE results; for harnesses, those come via Artificial Analysis. Each section gets a short podium highlighting my three favorites. And the key takeaway is my current workflow: Fable 5 orchestrates the overall task, while GPT-5.6 Sol serves as the delegated sub-agent—this division is the most effective method I've found to conserve the limited Fable budget. I'll also offer my thoughts on loop engineering, which has been the summer's trending term.

Models: A Fresh Set of Three

Back in the LLM article from late May, I placed Opus 4.7 at the top for Angular, GPT-5.5 as the most versatile choice, and Composer 2.5 as the up-and-comer. A single summer has changed all that: Opus 4.7 was superseded by its manufacturer's latest release, GPT-5.5 by its direct descendant, and Composer 2.5 by a model that didn't exist in my May radar. It's not that the old guard degraded—it's that the next wave arrived. Notably, Cursor, which is now part of SpaceX following the SpaceXAI acquisition mentioned in the apps article that closed on August 14, didn't manage to produce a podium-worthy model. In the apps post, I had anticipated they'd enter the frontier conversation; that prediction hasn't panned out yet.

1: Fable 5 by Anthropic

If you've followed my Fable 5 write-up, this comes as no shock: This release represents a true generational shift, and it remains the finest model I've ever directed at an Angular project—or any project, for that matter. Its intelligence is remarkable, and it possesses that quality I always circle back to: breadth. Hand it a loosely-defined objective and it will roam the problem space, test hypotheses on its own, and return with verified conclusions rather than a mere guess. The most impressive part? It generally grasps my intent right away. Following the service outage drama in June, access resumed on July 2 and has been steady since. Fable 5 has since become my default for anything complex: system design, code reviews, architectural planning, and extensive refactorings. The drawbacks I noted earlier—cost, latency, rate limits—haven't changed, which is precisely why I've developed the sub-agent pattern outlined at the end of this piece.

2: GPT-5.6 Sol by OpenAI

In my Fable review, I speculated that OpenAI's countermove would be GPT-6. Instead, they shipped GPT-5.6, and honestly, the naming is the least noteworthy aspect. The flagship variant, GPT-5.6 Sol, is highly capable—a clear improvement over GPT-5.5—and it comes with a reasonable price tag: the usage allotment in OpenAI subscriptions is still ample, so I can run it continuously without worrying about costs. Furthermore, on August 21, OpenAI reduced Sol's pricing once more—20% off input tokens and a third off output tokens, an offer valid until November 21—marking the third price drop for the GPT-5.6 family in a month; subscription fees stay unchanged, but Codex credits and API usage become cheaper as well. It has inherited the position GPT-5.5 occupied in my stack—the dependable senior dev for targeted implementation tasks—and, as you'll soon see, it's my preferred sub-agent.

3: GLM-5.3 Flash by Zhipu (Z.ai)

The third rung on my podium sat unoccupied for the bulk of the summer. In May, that was the newcomer spot, held by Composer 2.5—which, in light of what followed, simply lacks the necessary capability now. I gave Grok 4.5 a genuine chance—it's affordable and handled straightforward refactorings and test writing fine—but when it came to the critical tasks, I kept gravitating back to the top two.

What ultimately claimed that slot came from a lab I wasn't monitoring in May: GLM-5.3 Flash, the compact counterpart to Zhipu's GLM-5.3. Its intelligence isn't frontier-grade—it scores 63% on DeepSWE, a full ten points under Sol—but it's incredibly quick, costs roughly €0.25 per task, and in my Angular workflow, it outperforms the obvious budget option, GPT-5.6 Luna, which I already have access to through my OpenAI plan. The raw numbers don't fully support that claim—Luna at max setting hits 67%—but at the effort level I practically employ for Luna (high), it drops to 44%, whereas the Flash achieves its 63% flat-out at maximum effort. And at that price, effort configurations become irrelevant. That makes it the cheapest model whose output I'd actually consider merging. For the repetitive portion of my work—the clearly-scoped grind I'd never assign to Fable anyway—that's frequently sufficient, and beside two costly models, a budget-friendly third one fills a gap in my setup. More details in the costs section, where it takes the top spot.

The list of runners-up is lengthier than ever, and I'll continue to review it every quarter:

• Kimi K3 from Moonshot and the full-size GLM-5.3—both at 69% on DeepSWE for around €4 per task: more capable than the Flash, but not economical enough for the budget role, and not strong enough to unseat Sol.
• Grok 4.6 by xAI—the follow-up to the model that didn't stick, now at 67%.
• Muse Spark 1.2 from Meta AI—the dark horse at 55%; I haven't dedicated enough time to it for a full assessment, but it remains on my watchlist.
• DeepSeek V4—the Pro variant reaches 63% for under €2 per task, while the Flash hits 53% for roughly €0.45—making it the nearest rival to my new #3.
• And yes, even Opus 5 from Anthropic—the DeepSWE frontrunner at 74%, and, consistent with the Claude lineage, the model displaying the most refinement in this group. It delivers everything that made Opus 4.7 my top Angular pick in May, just slightly improved. But that's precisely the issue: a marginal gain, not a new category. In my daily Angular routine, it simply doesn't measure up to Fable 5 or GPT-5.6 Sol—and as a permanent third model for grunt work, it's prohibitively expensive.

What DeepSWE Reveals

Consistent with every installment in this series, I cross-check my instincts against the single benchmark I trust most: DeepSWE, since it mirrors a substantial portion of my implementation duties—a brief behavioral prompt, a genuine codebase, and an agent tasked with locating the correct spot and making a clean change. Here's the official v1.1 leaderboard as of August 26, 2026:

DeepSWE v1.1 pass@1—snapshot taken August 29, 2026, featuring my pick of eight out of 26 models; click the graphic for the real-time leaderboard. Every model operates through the identical minimal harness (mini-swe-agent), ensuring this genuinely compares models rather than products.

This is where things get compelling, since the benchmark and my own experience diverge on ordering. DeepSWE ranks Opus 5 first at 74%, GPT-5.6 Sol just behind at 73%, and Fable 5 third at 70%—each at maximum effort, and with the ±3 to ±4 point margins the leaderboard displays, all fall within one error bar of one another. Beneath the top tier, the landscape has shifted considerably since May—and this is where my shortlist resides: GLM-5.3 and Kimi K3 sit at 69%, the compact GPT-5.6 Luna, GPT-5.5, and Grok 4.6 at 67%, my new #3 GLM-5.3 Flash at 63%, and Opus 4.8—my architecture and review pick of early summer—at 59% (note that GPT-5.5, Opus 4.8, and Sonnet 5 aren't in my eight-model selection above—check the complete board for those). Sonnet 5 lands at 54%—and, oddly, it's the priciest model per task across the entire table—which backs what I stated in the verdict article: there's no justification for stepping down to the Sonnet tier.

So why does Fable 5 remain my #1 despite placing third on my preferred benchmark? Because DeepSWE evaluates one clearly-scoped task at a time—and that's precisely the kind of work I no longer hand to Fable (see the budget section below). The qualities that elevate Fable to a new generation for me—sticking with a vague, extended challenge, self-validating concepts, the polish of the outcome—don't surface in a single pass@1 statistic. It's the same narrative from the first post: benchmarks are valuable indicators, not definitive judgments. For the well-defined single task, the benchmark is accurate: GPT-5.6 Sol—and Opus 5—perform just as well and more affordably. That's exactly the division my workflow below exploits.

My Podium: Models

• 🥇 Fable 5 – my closest ally for architecture, design, reviews, and extended refactorings. Pricey, sluggish, metered—yet still the finest model I've encountered for an Angular codebase.
• 🥈 GPT-5.6 Sol – the steady senior engineer for focused implementation, sensibly priced, runner-up on DeepSWE, and my go-to sub-agent.
• 🥉 GLM-5.3 Flash – not as sharp as the top two, but remarkably fast and economical: the model for the tedious groundwork.

As always: evaluate these models in your own projects, with your own tasks and your own quality criteria.

Harness Layer: Stable, and That's a Compliment

The harness tier has remained remarkably quiet over the summer – and I take that as a positive sign. Everything laid out in the harness setup article continues to hold: the style guide remains the most impactful file, AGENTS.md still serves as the working agreement, and the iterative loops running from ng lint through Playwright are what transform a decent model into a dependable collaborator. The ng-agentic repository keeps receiving incremental updates, yet the core guidance stands firm. If your harness was assembled in June, there's no reason to start over now.

One word of caution, though: a harness is a living artifact. Every time something breaks, I patch the setup immediately – a new rule in AGENTS.md, a clarification in the style guide, a missing verification in the feedback loop – rather than working around the issue with extra prompting. Each fresh model also deserves a review of AGENTS.md and the other instruction files: certain rules exist solely because an older model repeatedly stumbled on a specific error, and a newer model may no longer require them.

The Harness Picture According to DeepSWE

The official DeepSWE leaderboard is deliberate about running every model through an identical minimal harness, so it offers no insight into harness design. Artificial Analysis is a different story: they push DeepSWE through the actual coding agents on the market – Claude Code, Codex, Cursor CLI, opencode, plus several others – and in their harness comparison they go so far as to keep the model fixed and swap only the harness. That's the same visualization I referenced in the harness setup article – Artificial Analysis still pins the model at Opus 4.7, meaning the relative spread among harnesses hasn't changed; the fresh development is the model-plus-harness combinations listed lower on their page:

Artificial Analysis Coding Agent Index broken down by harness for the same Opus 4.7 model at medium effort – captured August 28, 2026; select the chart to reach the interactive comparison.

Two observations jump out. First, with the model kept steady at Opus 4.7 (medium), opencode achieves 51 on their composite index, Cursor CLI reaches 47, and Claude Code lands at only 42 – and when you switch to the DeepSWE tab on that same chart, the gap widens further: roughly 40%, 32%, and 27%. The only variable adjusted was the wrapper – and the resulting spread exceeds what you'll see between most models on the main leaderboard. Second, and more directly useful for the two models I rely on most: with current-generation models, the agent pairings come in at Codex with GPT-5.6 Sol around 69%, Claude Code with Fable 5 around 66% (accounting for the sessions Anthropic's safety systems route to Opus), and Claude Code with Opus 5 around 63%, each measured at its highest effort setting. So when measured through their respective harnesses, the Codex-plus-Sol combination is both the fastest and the most economical of the three frontier pairs – which hints that Codex is a remarkably efficient shell for its own model.

Does that argue for running Opus through opencode rather than Claude Code? On paper, perhaps – and bonus tip 2 describes the one scenario where I do exactly that. On my Claude subscriptions, though, the answer is no: the Opus 4.7 chart is the only one where Artificial Analysis currently freezes the model across three harnesses, it reflects a spring model running at medium effort, and the Claude Code harness itself keeps advancing – sub-agents, hooks, /loop, and the whole foundation my orchestrator workflow is built on. The chart reinforces the central message of the harness setup article, not a reason to jump ship: the wrapper influences the outcome, and the piece of the wrapper under your control – style guide, AGENTS.md, feedback loops – is where you gain the most ground.

Harnesses: My Top Three

• 🥇 opencode – the most adaptable harness out there: it's open source, works with any model, and handles every model I'm currently interested in through the subscriptions and keys I already own – Fable 5 and Opus 5, GPT-5.6 Sol, plus GLM-5.3 Flash via OpenRouter. It also stands on its own merits – the one chart that holds the model constant places it above both competitors. It's one of the five harnesses T3 Code can drive – joined by Claude Code, Codex, Grok Build, and Cursor – it's the harness GLM-5.3 Flash uses through OpenRouter, and it's the foundation for the entire Copilot setup described in bonus tip 2 – more on that in the app, cost, and workflow sections.
• 🥈 Claude Code – the harness I direct Fable 5 and Opus 5 through – and it excels at coordinating sub-agents, even when GPT-5.6 Sol occupies the sub-agent role. Sub-agents defined in .claude/agents/ are the reason my orchestrator pattern exists – hooks and /loop are the extras opencode hasn't caught up with yet.
• 🥉 Cursor CLI – it still supports most of the significant models, it fine-tunes its tools and prompts for each new arrival, it integrates smoothly with the IDE, and it finishes second on that same harness comparison, ahead of Claude Code. Two drawbacks, however. Cost is the first: it charges usage at API rates, so the included allowance evaporates far more quickly than a Claude or OpenAI subscription – not where my daily volume belongs. And with Cursor joining SpaceX, OpenAI has stated it intends to phase out its agreement supplying models to Cursor, with November 12, 2026, as the suggested cutoff – so the "most models" claim now carries an expiration date.

Codex CLI falls just short of the top three: it's the harness my GPT-5.6 sub-agent operates on every day – GPT-5.6 Sol and GPT-5.6 Luna through my OpenAI subscription, third-party models via API key – and, as the Artificial Analysis numbers above indicate, the Codex-plus-Sol pairing is the most streamlined of the frontier options. But it's engineered for OpenAI's models first, and – unlike Claude Code with its sub-agents and hooks – it contributes nothing extra that my orchestrator workflow requires. That's what keeps it off my podium. For terminal-first users, opencode remains my top suggestion – and Pi appeals to the builders who enjoy customizing their own harness.

Applications: T3 Code Steps Forward

Here's the genuine news in this post. In the apps and harnesses article, I gave T3 Code a passing mention as an open-source interface layered on the agents you already pay for. Since then, the open-source T3 Code has quietly risen to my preferred application. The Codex app has slipped to my backup, demoted from daily companion to dependable runner-up.

What prompted the move? Three factors – plus one substantial perk:

1. Remote access, without the vendor tie-in. Much like the Codex app, T3 Code allows me to steer my agents from a phone while the desktop handles the heavy lifting – launch a task from the couch, inspect the diff while commuting. With T3 Code, this snaps together easily through a Tailscale link: my phone communicates with my own device, with no cloud relay in between. That arrangement also keeps the data and privacy considerations pleasingly straightforward – the code still reaches whichever model I select, but nothing else sits in the pathway.

2. Open source and free. There's no fee for the application itself, and the code is available publicly, so I can audit every line. After the Claude Code source-map incident detailed in the harness setup article, I've grown to value the ability to inspect the layer surrounding my code.

3. Any model, any provider. T3 Code remains indifferent to which vendor I'm aligned with this week. All three of my current picks – Fable 5, GPT-5.6 Sol, and GLM-5.3 Flash – run without issue inside it, using the subscriptions and credentials I already maintain – and two of them, Fable 5 and GPT-5.6 Sol, even operate through opencode on a corporate GitHub Copilot plan (see bonus tip 2 at the close of the workflow section). Recall the "avoid depending on a single vendor" guidance from the apps article? This is the solution.

My frequently used models in T3 Code's picker, each a keyboard shortcut away: Fable 5 through Claude Code and – via opencode – through GitHub Copilot, GPT-5.6 Sol through Codex or Copilot, and GLM-5.3 Flash through opencode and OpenRouter.

4. The refreshed sidebar. A (significant) extra rather than a primary justification, but the recently shipped sidebar is a pleasure to use – it keeps all the essential details visible during an agent's work, eliminating the tab-switching I had grown accustomed to in other super apps. Consider it an inbox: each thread appears as a single entry with project, branch, and status, and once you finish one, you settle it and it moves to the bottom.

The T3 Code sidebar functioning as an inbox: active threads at the top, settled ones below – client names obscured, with this very post in the center.

In fairness to Codex: if your workflow stays entirely within the OpenAI ecosystem, it remains an excellent choice. In my case, it has shifted from primary tool to niche player: T3 Code handles the majority of my day, and I open the Codex app mainly for computer use – the browser-operating, screenshot-verifying tasks where it remains unmatched in my toolkit.

And the terminal? Honestly, I rarely open one for agent-driven work anymore – the super apps have simply become too convenient. If you prefer it anyway: opencode for most, Pi for the experimenters – details in the harness section above.

Applications: My Top Three

There's no benchmark here – nobody quantifies interface polish – so this ranking is purely subjective:

• 🥇 T3 Code – open source, supports any model, remote control via Tailscale, and that sidebar. The first app I launch every morning.
• 🥈 Codex app – still the most refined closed application, consistently reliable, and my choice for computer use. Also the one I'd recommend to a teammate who lives entirely in OpenAI's world.
• 🥉 Cursor – the super app with the tightest IDE integration, supporting most meaningful models under its own harness – but Cursor-provided access to OpenAI's models is scheduled to conclude, with November 12 as the proposed date (see the harness section).

The Claude Desktop app just misses the podium: it remains the natural habitat for the Claude Code harness, but T3 Code now fulfills that role for me – with a broader model selection.

Costs: Fable 5 Is the Expensive One

Model podium, harness podium, app podium – now the mundane part that determines whether any of it is viable: money. The costs post from June remains valid on every significant point: the subsidized subscriptions are still far and away the best value, and the metric that truly matters remains the cost per accepted, reviewed, merged change, not the price per token. What has shifted is the gap between the leading models – and DeepSWE offers me the closest proxy I have for that, since it logs the average API cost per task right next to the score:

DeepSWE v1.1 cost view – average API cost per task plotted against the score, snapshot taken on August 29, 2026, my chosen set of 34 out of 63 configs – covering all effort levels for the frontier models plus most of my shortlist, so you can see the trends; click the chart to open the live leaderboard. Mind the inverted cost axis – cheaper sits further to the right – so up and to the right is the sweet spot.

DeepSWE reports figures in US dollars; I converted to euros and rounded. For the frontier models, every effort level is displayed, since high is what I typically run and the leaderboard's default view only highlights the best score per model – usually the maximum effort configuration. At high effort, a single DeepSWE task lands around €8.50 with Fable 5 (69%), €5.50 with Opus 5 (73%), and €2.50 with GPT-5.6 Sol (69%). At max effort, the same trio scores 70%, 74%, and 73% at roughly €20, €11, and €6. Read that again: max effort roughly doubles the expense for a single extra point on both Claude models – Sol is the only one where the upgrade yields something real, four points.

The score ranking shifts with effort level, but the cost difference holds steady: at every setting, Fable 5 runs about three times as expensive per task as GPT-5.6 Sol. Two drivers: Fable churns through nearly twice the output tokens per task that Sol does (119k at max versus 60k), and its per-token rate sits well above Sol's on top of that. Token efficiency is where OpenAI is currently ahead, and that holds weight even on a subscription, because tokens are precisely what your usage limits are built from.

The budget corner is where it gets compelling, and that is where my #3 resides. GLM-5.3 Flash nails 63% of the tasks at about €0.25 – a tenth of what Sol demands at high effort, and a sliver of Fable's cost at any level. It is clearly a rung below the frontier models, but for the routine portion of my workload it's frequently sufficient, and it's quick – which is why it tops my cost podium below. The competition in that corner is genuine, though: GPT-5.6 Luna, Sol's smaller sibling, forms the line of dots hugging the right edge of the chart – 44% for about €0.15 at high effort, 67% for about €0.60 at max – with DeepSeek V4 Flash close behind and DeepSeek V4 Pro a bit higher on the scale. The larger open-weight duo from my shortlist, GLM-5.3 and Kimi K3, sits higher up at 69% – the top score among open-weight models, though Sol matches it for less, and the Flash undercuts both on cost per task.

Artificial Analysis corroborates the same picture in harness form and adds the timing factor: a Codex run with GPT-5.6 Sol costs about €4.50 per task and wraps up in roughly ten minutes, while Claude Code lands at about €7.50 with Opus 5 (at xhigh) and about €11 with Fable 5 – and both Claude runs stretch to nearly 24 minutes. That Fable is slow is no surprise; that the gap is now quantifiable is.

What does that imply for my spending? Less than you might expect, because nearly everything still operates on subscriptions rather than per token: two €200 Claude subscriptions since July (as admitted in the Fable post), one OpenAI subscription that GPT-5.6 has never come close to maxing out – and, for GLM-5.3 Flash, an OpenRouter key I route through opencode inside T3 Code – plus a GitHub Copilot plan for the setup in bonus tip 2. OpenRouter tacks on a modest fee over the model's own price, but at €0.25 per task that's negligible, and in exchange I can test any new model on the leaderboard the very same afternoon. All of that combined, at my hourly rate, is still covered by lunchtime on the first working day of the month. But the per-task numbers above translate directly into how rapidly a subscription's limits deplete – and that is exactly why the next section follows.

My Podium: Cost per Accepted Change

Not price per token – cost per change I actually merge. DeepSWE's per-task cost is merely a stand-in for that, so the rest comes down to my assessment:

• 🥇 GLM-5.3 Flash – not as sharp as the frontier models, but swift and nearly free – which suits me fine, since I don't assign it the tough material. For mechanical work, it delivers the best cost per accepted change I have come across.
• 🥈 GPT-5.6 Sol – the balanced option: top-three quality at a fraction of the Claude cost per task, the leanest token count per task, plus the most generous included usage. The best bargain among frontier models, plain and simple.
• 🥉 Fable 5 – the finest model and the priciest in my selection. The worst value on paper, yet the best value for problems that would otherwise consume a full day of my time: worth every cent for tough, extended-horizon tasks, excessive for anything routine.

Notice what just occurred: this is the models podium flipped on its head. And that is precisely the friction the next section tackles – I want to lean on the best model as much as I can, and I simply can't afford to.

How I Save My Fable Budget

Fable 5 is the one model I deliberately pace, and after a summer of doing exactly that, these are the habits that endured – the biggest one saved for last, because it earns its own section:

1. GPT-5.6 Sol is the standard, Fable 5 is the outlier. The question I pose before every task: would GPT-5.6 Sol – or even GLM-5.3 Flash – handle this correctly as well? For ordinary implementation work, the answer is yes, the benchmark confirms it, and it never touches the Claude limits. If I prefer to remain within the Claude ecosystem, Opus 5 delivers the same outcome at roughly two thirds of Fable's cost per task at high effort, and about half at max. Fable gets the ambiguous goals, the architecture, the reviews, and the brownfield refactorings that reach across half the repository.
2. Medium to high effort, not max. The effort figures from the costs section make the argument better than I could: one extra point for double the expense – and even at medium, Fable still hits 65% for around €5.50. So I operate Fable at medium or high and hold max in reserve for the occasional task where a wrong answer outweighs the token cost.
3. Plan first, then let it loose. A few minutes of spec and planning before the extended autonomous run spare a host of costly laps. Fable shines when the destination is clear but the path is not – a long-horizon problem it can navigate without first having to infer what success looks like – and at its most wasteful when it must uncover the objective through trial and error, at Fable rates.
4. Keep the context trim. Fresh thread per task, compact AGENTS.md, no sprawling terminal dumps – the team rules from the costs post, just enforced with more rigor. A bloated context gets re-read on every turn, and those are the tokens that drain your 5-hour window.
5. Delegate the grunt work to a sub-agent. This is the significant one: Fable 5 strategizes, a cheaper model types. It's the suggestion from the July 4th update of the Fable post, and by now it's my normal workflow – so it claims its own section right below.

And if all that still falls short? Then you're in my position – see the two Claude subscriptions above.

My Current Workflow: Fable 5 Orchestrates, GPT-5.6 Sol Does the Legwork

Here is the fifth tip in detail—the practice that conserves the most usage for me, because it targets the Fable 5 limitation that stings the most: the usage caps.

The concept is straightforward: Fable 5 should deliberate, not type. I operate Fable 5 as the coordinating agent—it handles planning, architectural choices, and the final assessment—and I pass the clearly specified implementation work to GPT-5.6 Sol as a sub-agent. Fable 5 produces a self-contained task brief, the sub-agent carries it out through the Codex CLI on my OpenAI billing, and Fable 5 evaluates the outcome. The premium model spends its tokens on discernment; the reasonably priced model spends its tokens on volume.

In Claude Code (and consequently in any application driving that harness), this is a single Markdown file in .claude/agents/:

---
name: gpt-implementer
description: Delegates well-specified implementation tasks to GPT-5.6 Sol via the Codex CLI. Use for mechanical, clearly spec'd legwork – not for architecture or design decisions.
tools: Bash, Read, Grep, Glob
---

You are a thin wrapper around the Codex CLI. Take the task you were given, write it into a single self-contained prompt (all relevant file paths, constraints, and acceptance criteria included – Codex starts with zero conversation context), then run:

codex exec -m gpt-5.6-sol "<your prompt>"

Return Codex's output as your result. Do not implement anything yourself.

That's all there is to it. The orchestrating Fable 5 session now delegates automatically whenever a task is routine enough, and my Fable allowances last considerably longer—I run Fable 5 itself at medium to high effort and let the sub-agent consume the implementation tokens. The same division of responsibilities functions with Opus 5 in the sub-agent position if you'd prefer to remain entirely within the Claude ecosystem—more economical than Fable, same harness, no Codex detour. And naturally, the harness setup does its unobtrusive work here as well: the sub-agent reads the same AGENTS.md and style guide as everyone else, so the resulting code matches my conventions regardless of which model produced it.

Bonus Tip 1: A 1M-Token Context Window for GPT-5.6 Sol in Codex

A related tip for the Codex side of this configuration, since it comes up frequently: by default, Codex runs GPT-5.6 with a deliberately reduced context window compared to what the model supports—tuned for performance and cost. Earlier this month (on August 16, 2026), OpenAI's Tibo Sottiaux described how to increase it to a 1M-token working window for GPT-5.6 Sol. Open ~/.codex/config.toml and add these three lines at the top level, before any [section] header:

model = "gpt-5.6-sol"
model_context_window = 1000000
model_auto_compact_token_limit = 900000

The first line specifies the model, the second grants Codex a one-million-token context budget, and the third initiates automatic compaction of older history at roughly 900k tokens, preserving some buffer. Restart Codex and begin a fresh session. If you'd prefer to experiment once without modifying your defaults:

codex -m gpt-5.6-sol \
  -c model_context_window=1000000 \
  -c model_auto_compact_token_limit=900000

For the sub-agent workflow described above, this matters less than you might expect—every codex exec begins anew with a self-contained prompt anyway. Where it proves valuable is in the longer-running Codex sessions you drive directly, whether in the app or the CLI: more code, tool output, and conversational context stay visible before Codex needs to condense older material. My perspective: OpenAI calibrated the default thoughtfully, and I'm not enabling it universally—but for the occasional large brownfield assignment, it's reassuring to know the option exists.

Bonus Tip 2: "Hey Alex, I'm Only Allowed to Use Copilot"

I encounter this statement in nearly every workshop, and my response used to be brief: in the costs post I noted that I wouldn't construct a 2026 setup around Copilot, and the harness setup post guides you away from plain VS Code plus Copilot. Both remain valid—for the Copilot harness. The Copilot subscription is a separate matter. Since Fable 5 and GPT-5.6 Sol appeared in Copilot's model selector (on the Pro+, Max, Business, and Enterprise tiers), the subscription your organization already covers grants you access to the two frontier models from my rankings—all you need is a superior harness around them. And, amusingly enough, that's a configuration I'm running myself at present, alongside the Claude Code plus Codex approach above: T3 Code on top of opencode on top of GitHub Copilot. The same orchestrator pattern as before—Fable 5 deliberates, GPT-5.6 Sol executes—just without the Codex route, and without requiring a Claude or OpenAI subscription of your own.

Step 1: connect opencode to Copilot. Install opencode, execute opencode auth login (or /connect within an active session), select GitHub Copilot, and verify the device code on GitHub. Subsequently, opencode models displays everything your plan unlocks as github-copilot/<model>. Two caveats: the opencode documentation indicates that some models require a Pro+ plan or higher, and on the Business and Enterprise plans your administrator must enable the frontier models in the Copilot policies first—that's the single conversation you can't automate.

Step 2: global defaults. In ~/.config/opencode/opencode.json, Fable 5 becomes the session model, and Luna handles opencode's minor internal operations—titles, summaries—without consuming the expensive budget:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "github-copilot/claude-fable-5",
  "small_model": "github-copilot/gpt-5.6-luna"
}

My actual file also contains the OpenRouter provider entry for GLM-5.3 Flash from the costs section, but that's optional.

Step 3: the sub-agents. This is the opencode counterpart of the .claude/agents/ file mentioned earlier, except it resides in the project's opencode.json—and it's even simpler, since GPT-5.6 Sol is a native opencode model here, so no CLI wrapper is required. Sub-agents are specified under the agent key; the built-in general, explore, and scout agents also receive a model assignment, ensuring every sub-agent's model is unambiguous:

{
  "$schema": "https://opencode.ai/config.json",
  "instructions": [".opencode/OPENCODE.md"],
  "agent": {
    "general": { "model": "github-copilot/claude-fable-5" },
    "explore": { "model": "github-copilot/gpt-5.6-sol" },
    "scout": { "model": "github-copilot/gpt-5.6-sol" },
    "implement-sol": {
      "mode": "subagent",
      "model": "github-copilot/gpt-5.6-sol",
      "description": "Implementer on GPT-5.6 Sol. Give it a self-contained brief (files, exact behavior, constraints, verification commands); it implements exactly that and reports back. All implementation goes here – never implement in the session.",
      "prompt": "You are the implementer on GPT-5.6 Sol. The session model (Claude Fable 5) has already made the design decisions and hands you a brief. Implement exactly that brief – no scope changes, no redesign, no opportunistic refactors. Follow AGENTS.md and the style guide. Run the verification commands the brief names – at least the linter for every touched project. Never stage, commit, push, or switch branches. If the brief is ambiguous or conflicts with the code you find, stop and report instead of guessing. Final message, short: files changed, verification results, open questions.",
      "permission": {
        "edit": "allow",
        "bash": {
          "*": "allow",
          "*git add*": "deny",
          "*git commit*": "deny",
          "*git push*": "deny",
          "*git checkout*": "deny"
        },
        "task": "deny"
      }
    }
  }
}

The permissions serve as the safeguards: the implementer may modify files and execute commands, but the git operations that would stage, commit, push, or switch branches are blocked, and "task": "deny" prevents it from launching sub-agents of its own. opencode's Task tool has no model parameter—a sub-agent's model derives solely from its definition—which is precisely what we need. general remains on Fable because the occasional open-ended delegation is exactly the kind of judgment I want the expensive model to exercise; all mechanical work routes to implement-sol. My three reviewers (review-fable, review-opus, review-sol) follow the same structure with "edit": "deny", and the routing guidelines live in the .opencode/OPENCODE.md referenced under instructions: Fable never implements; it drafts the brief, launches implement-sol, runs the three reviewers concurrently on the same diff, and re-briefs implement-sol until the review passes cleanly. Broad codebase fact-gathering goes to explore, and external research to scout; both are fixed to Sol. And you can always address the sub-agents directly with @implement-sol or @review-sol in your prompt.

Step 4: T3 Code on top. Install T3 Code, choose opencode as the harness for your project, and the model picker will show the Copilot models alongside whatever else you have connected—refer to the screenshot in the app section. From that point forward, it's the workflow described above.

What you sacrifice: Claude Code's hooks and /loop, the Codex CLI's 1M-token control from bonus tip 1, and, since Copilot transitioned to usage-based billing, every Fable turn appears as AI credits on your administrator's dashboard—one more rationale for letting Sol do the typing. What you gain: the frontier models on the subscription you already possess, within a harness genuinely designed for agents. And if your administrator still declines, the approach I suggested in the costs post remains available 😉.

Loop Engineering: The Buzzword of the Summer

One more topic, because you'll encounter this term regardless: loop engineering. Google's Addy Osmani provided the term its prominent treatment earlier this summer (in June 2026), and it comes with two highly citable phrases. Boris Cherny, head of Claude Code at Anthropic, stated on stage in June—as quoted by Osmani: "I don't prompt Claude anymore. I have loops running that prompt Claude." And Peter Steinberger, the creator of OpenClaw, was even more blunt on X: "You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents."

The concept in a single sentence: following prompt engineering and context engineering, the next capability isn't crafting a superior prompt—it's not writing the prompt yourself at all. Rather, you architect the system that prompts the agent: a schedule that activates it each morning, a hook that triggers when CI goes red, a goal it iterates toward until the checks succeed—and only then halts. The tooling already exists: Claude Code includes /loop, hooks, and scheduled agents, and the Codex app offers its scheduled tasks.

My personal assessment? The label is fresh, the substance largely isn't. Strip away the terminology and loop engineering is what the harness setup post has contended throughout: an agent is a model operating in a loop, and that loop is only as effective as the feedback circulating through it. If your ng lint, tests, and Playwright runs provide the agent with a dependable signal, you can let the loop run longer without supervision—if they don't, a self-prompting agent simply generates junk on a timetable. Even Osmani cautions about precisely that: unattended errors and the comprehension burden of code nobody reviewed. So my principle doesn't change—whatever executed while I was away, I still hold final responsibility for every diff. I'm employing loops in limited doses so far, and I'll investigate where they genuinely provide value—and where they're merely an elaborate cron job—in an upcoming installment of this series.

Meanwhile, read Manfred Steyer's Loop Engineering with Super Mario and Twelve AI Coding Agents: he assigned twelve coding agents the same two tickets—a Koopa Troopa for an Angular-based Super Mario clone—and allowed a single automated loop to run all of them. All twelve delivered, with a 160x variation in cost and a 19x variation in speed, and his central conclusion echoes my harness principle in one sentence: every systematic failure traced back to something the tickets omitted. Loops don't resolve an ambiguous specification—they execute it, literally.

Agentic Engineering Workshop

Model trio, app of the summer, orchestrator workflow—if this post demonstrates anything, it's that the components keep evolving while the underlying framework remains constant. Learning that framework, rather than pursuing each individual piece, is precisely what our Agentic Engineering Workshop addresses, offered in both English and German: AI-ready project configuration, guardrails, spec-first and plan-first methodologies, UX and component prototyping, code review, testing, and brownfield refactoring for experienced Angular developers.

• 🤖 Agentic Engineering Workshop – 2 days, remote

Wrapping Up

After three months of writing this series, a clear pattern has emerged: models change the quickest (Fable 5, GPT-5.6 Sol, and GLM-5.3 Flash right now – ask me again by November), applications follow every few months (with open-source T3 Code leading, and Codex as the fallback), and the harness configuration remains remarkably unchanged. The cost structure is equally consistent: the subscription continues to be the smartest spend, and Fable 5 is still the only model worth allocating carefully. This is the very reason I continue to emphasize that your investment grows in the harness – you should keep everything else at arm's length.

If there's one takeaway you hold onto from this update, let it be the orchestrator workflow: let Fable 5 handle the reasoning, let GPT-5.6 Sol handle the typing, and trust your guardrails to keep the diff indistinguishable. Given that a quarter is roughly how long these recommendations stay relevant, the next update in this series is scheduled for November 2026 – looking forward to seeing you then.

But you won't have to wait that long for the series to move forward: next week picks up right where the harness setup post left off, with the article I had promised at its conclusion – Agent Skills for Angular Development. If the harness gives your agent a clean slate and an operating agreement, skills hand it repeatable workflows: a full inventory of Angular-specific skills hosted in a new companion repository, guidance on incorporating third-party skills, instructions for crafting your own, and strategies for fine-tuning them to suit your specific project. A solid prompt offers value for a single interaction – a solid skill pays off with every single use.

I appreciate you taking the time to read this 🙏 this article was authored by Alexander Thalhammer. For any thoughts, comments, or inquiries, feel free to get in touch with me ❤️