A Toronto startup called Taalas hardwired an LLM into transistors and got 16,000 tokens per second. That number sounds like a benchmark. It's actually a paradigm shift hiding in plain sight.
Every decade or so, the computing industry reaches a point where it keeps solving the wrong problem. In the 1990s, the industry optimized instruction pipelines endlessly while memory latency quietly became the actual bottleneck — what scientists called the "memory wall." solution wasn't a faster CPU. It was a different architectural philosophy: caches, NUMA awareness, locality of reference.
We are building more powerful general-purpose accelerators for an increasingly specific workload, while the actual barriers — latency and cost per inference — remain stubbornly high. A startup called Taalas just walked through a door that everyone else assumed was locked.
Their idea sounds almost offensive in its simplicity. Instead of building a better computer to run AI models, they asked: what if the model itself became the computer? Not metaphorically. Literally. They etched the weights of Llama 3.1-8B directly into silicon — one weight, one multiply, one transistor. Result is a chip that does exactly one thing and does it at 16,000 tokens per second per user. That's not a 2× improvement. It's an order of magnitude beyond what Nvidia, Cerebras, and Groq can achieve on the same model.
Abstraction Tax We Stopped Noticing
To understand why this matters, consider what happens every time a GPU runs inference. You have a general-purpose parallel compute engine. On top of that sits CUDA. On top of that, a deep learning framework. On top of that, a model serving system. On top of that, the model itself — with weights loaded from High Bandwidth Memory that sits physically separated from the compute units, connected by a bandwidth-constrained bus. Every layer of that stack has a cost: power, latency, engineering complexity. HBM memory stacked on modern AI chips consumes significant power just shuttling weights back and forth. Chip doesn't know it's running a transformer. It learns this at runtime through software.
Taalas eliminated the entire middle of that stack. Their HC1 chip — built on TSMC's N6 process at 815mm² — stores model weights in the transistors themselves using a mask ROM fabric. Compute and memory collapse into the same physical location. The von Neumann bottleneck, the memory wall that has haunted computer architects for forty years, simply doesn't exist. There is no bus to saturate. There is no data to move. The multiply happens where the weight lives.
What's striking is not just the performance number, but the power consumption story. Ten HC1 chips running continuous inference consume 2.5 kilowatts. An equivalent GPU setup for the same throughput would demand significantly more power and require liquid cooling, custom packaging, and HBM stacks. Taalas runs in standard air-cooled racks. If this scales, it doesn't just change AI economics — it changes where AI can physically run.
Flexibility-Performance Corner Nobody Explored
The obvious objection is flexibility. An HC1 chip runs exactly one model: Llama 3.1-8B. Update the model, retape the chip. In a field where frontier models are replaced every few months, betting on dedicated silicon seems reckless. This is exactly why nobody went down this path before. The assumption — reasonable until recently — was that AI was changing so fast that any specialized hardware would be obsolete before it paid for itself.
— Ljubisa Bajic, CEO, Taalas
But Taalas found something in that corner. Two things changed that make their bet less reckless than it appears. First, a growing subset of model families — the Llamas, the DeepSeeks, the Qwens — are stabilizing into production workhorses. Enterprises aren't running the frontier model of the week. They're running fine-tuned versions of models that are already 6–12 months old, because that's what their workflows are validated against. Second, Taalas' retaping cycle is two months, not two years. They only customize two metal layers on an otherwise fixed chip — borrowing an idea from structured ASICs of the early 2000s. The base chip is permanent; only the weight layer changes. Order a chip for your deployment window, run it until the model evolves, retape. If the cost per inference drops by 1,600×, you can absorb a faster hardware refresh cycle and still come out far ahead.
What Does Sub-Millisecond Inference Unlock?
Here is where it gets interesting — and where most analysis of Taalas misses the bigger story. The coverage tends to frame this as "Nvidia competitor" or "cheaper inference." Both are true but both are underselling it. The more important question is: what categories of software become possible when inference is effectively free and instantaneous?
Think about agentic AI systems the way we think about database transactions. Today, every call to an LLM is expensive enough that you architect your system to minimize them — a prompt here, a structured output there, careful chain design. It's the equivalent of designing around the cost of disk I/O in the 1980s. Every application decision was shaped by that constraint. When memory got cheap enough, the constraint dissolved, and entire new software paradigms emerged. In-memory databases. Real-time analytics. Applications that would have been unthinkable when you had to plan every memory access became trivial. Sub-millisecond, near-zero-cost inference does the same thing for AI-native applications.
A coding agent that can spawn 100 parallel reasoning threads to explore different implementation approaches — and complete all of them in the time a single GPU call takes today — is not just a faster version of Copilot. It's a different class of tool. Voice interfaces that feel genuinely instantaneous rather than simulated-fast-typing change the interaction model entirely. IoT devices that run inference locally, on-chip, without cloud round-trips, enable entirely new application categories: real-time translation in earbuds, continuous monitoring in industrial settings, robotic perception loops that don't wait for a network packet.
Architecture of Deployment is About to Flip
There is a deeper structural implication here that I haven't seen discussed elsewhere. The current AI deployment model is highly centralized. You train at hyperscale data centers, you serve from hyperscale data centers, and latency is a tax you pay for accessing that centralized intelligence. This isn't a choice — it's a law of the physics. GPU clusters consume hundreds of kilowatts. You run them where power is cheap and cooling is achievable. Everything else connects via API.
Taalas' HC1 running 10 chips at 2.5 kilowatts fits in a standard rack. Not a special power-zone rack. Not a liquid-cooled custom installation. A standard rack. Scale this to their second-generation silicon and frontier models, and suddenly the economics of edge inference look very different. A hospital running inference on-premise. A factory running quality control loops locally. A telecom running inference at the edge of the network. None of these require a supercomputer. They require a box that costs a few hundred kilowatts and delivers sub-millisecond responses.
The historical parallel that comes to mind is the minicomputer revolution. In the 1960s, computing was centralized by necessity — mainframes were expensive and power-hungry, and only institutions could afford them. The minicomputer didn't just make computing cheaper. It redistributed computing into departments, into labs, into engineering teams that previously had to submit batch jobs and wait. The same shift happened again with workstations, again with PCs, again with smartphones. Each wave moved intelligence closer to the point of use, and each wave unlocked applications that were inconceivable at the previous scale. Taalas, if their roadmap holds, is proposing that AI inference can make that same journey — from hyperscale data center to edge server to eventually embedded device.
What the Risk Profile Actually Looks Like
The hardwired approach carries genuine risks that deserve an honest look. The model specificity is not a minor caveat — it's the central bet. If the Llama family fades and a new architecture dominates, chips hardwired for the old model have limited residual value. The two-month retaping cycle is fast by traditional ASIC standards, but in an AI field where significant model releases happen monthly, it still represents a lag. There's also the question of whether Taalas' approach scales to frontier models. The HC1 runs an 8B parameter model — valuable for production workloads, but well below the frontier. Their second-generation silicon targets a mid-size reasoning model, and frontier capability is planned for later in 2026. That progression is the one to watch.
There's also a market dynamics question. Cloud providers don't necessarily want their customers achieving this kind of cost reduction on inference. Lower inference costs are great for consumers but threaten the economics of API businesses. Whether hyperscalers will adopt Taalas chips, build competing specialized silicon, or simply let GPU clusters continue to dominate through inertia — that's an open question with real strategic stakes.
And yet, the technical result is hard to argue with. 16,000 tokens per second per user. $0.0075 per million tokens. 250 watts per chip. These aren't paper benchmarks — the chip exists, developers can apply for access today. A Toronto company with 25 employees and $219 million raised has produced a benchmark that makes the GPU stack look architecturally mismatched for this workload.
Lesson Worth Carrying Forward
The lesson I take from Taalas isn't about AI chips specifically. It's about the value of inhabiting the corners of solution spaces that everyone else has deemed too risky to explore. The GPU path is rational. General-purpose compute is flexible, quickly amortized, and continuously improved by massive R&D budgets. The structured ASIC path looks irrational until you do the physics carefully enough to see that the entire software stack you're preserving with all that flexibility is itself the bottleneck. Taalas didn't find a new physics. They found a corner in the design space where the tradeoffs that seemed unacceptable from the outside look entirely acceptable from the inside — because the gains are large enough to absorb the rigidity.
For software engineers building AI-powered systems today, the practical implication is this: the inference cost model you're designing around right now is not a law of nature. It's an artifact of the current hardware generation. If Taalas' approach — or the pressure it creates on incumbent vendors — succeeds in driving inference costs down by one or two orders of magnitude, the right architectural choices for AI-native applications will look completely different in 18 months. The applications that seem economically impossible today — agents that think in parallel, voice interactions that feel truly instant, intelligence embedded in every device — are not science fiction. They're just waiting for the infrastructure to catch up with the ambition.
The model, it turns out, can become the machine. That changes more than inference costs.
