The Hstack
November 21, 2026 · 2 min read
A hierarchical multi-model architecture for cheaper AI software engineering
One of the interesting things about building AI coding agents is that we’re beginning to realize; the model that makes the best engineering decisions doesn’t necessarily need to be the model that writes most of the code.
The model that makes the best engineering decisions doesn’t necessarily need to be the model that writes most of the code. Consider a hierarchy where Claude Opus 5.5 acts as a senior engineer and Claude Haiku 5.5 acts as the implementation engineer. Instead of asking an expensive frontier model to plan, implement, debug, test, and review everything, we distribute those responsibilities.
The hierarchy:
Opus 5.5 — Orchestration Engineer:
Opus is responsible for: Understanding the requirements, defining the architecture and implementation constraints, delegating tasks to Haiku, reviewing implementation decisions, identifying potential bugs and improvements, providing corrective instructions, approving the final implementation.
Haiku 5.5 — Implementation Engineer (worker):
Haiku handles, planning the implementation, exploring the codebase, writing and modifying code, running tests, debugging, applying review feedback, iterating until the implementation satisfies the requirements.
Opus directs the engineering process, while Haiku does most of the execution.
How the workflow operates:
The process begins when a user submits an engineering task, which Opus analyzes to determine the requirements and establish an implementation strategy. Haiku then receives these instructions, creates a detailed implementation plan, develops the solution, runs the relevant tests, and submits the changes for review. Upon examining the implementation, Opus identifies any issues and suggests necessary improvements. Haiku subsequently applies these corrections and repeats the submission and review cycle until Opus approves the final result.
The economics behind it:
The architecture becomes particularly interesting when we consider token pricing.
As of the time of this article, Opus 5.5 is priced at $5.00 per 1 million input tokens and $25.00 per 1 million output tokens, whereas Haiku 5.5 costs $0.10 per 1 million input tokens and $0.50 per 1 million output tokens. Haiku is 50 times cheaper on both input and output tokens. However, the workflow deliberately distributes token consumption according to the cost structure.
Opus receives implementation reports, relevant code diffs, test results, and architectural context. It produces relatively concise instructions and reviews. Haiku receives those instructions and generates the majority of the implementation, plans, tests, and corrections.
In other words, we reserve expensive model output for engineering decisions and use cheaper model output for execution. The objective isn’t simply to minimize token consumption. It’s to minimize the cost of successfully completing an engineering task.
What we want to find out:
Can a cheaper model supervised by a stronger model achieve comparable software engineering quality to the stronger model working independently, while significantly reducing the cost per completed task?
Rather than treating an AI coding agent as a single model responsible for everything, we can treat it as an engineering organization. Different models have different responsibilities. Stronger models provide direction and judgment. Cheaper models handle execution. Feedback flows between them.
The best model doesn’t always need to do the most work. Sometimes, it just needs to make sure the work is done correctly.