Language Models for Text Classification: From Bag-of-Words to Jev

Software engineering builds on previous work, and the same goes for LLMs. Having worked with both enough to recognize the parallels, I find it interesting how many problems we now approach with general-purpose LLMs have roots in methods we have been using for years.

Sebastian Raschka’s piece on text classification is a useful reminder of that progression: bag-of-words representations with logistic regression or Naive Bayes, recurrent and convolutional networks, transformers, and now models positioned between specialized classifiers and general-purpose LLMs. The engineering question is therefore how much capability the workload actually requires.

For a bounded classification problem, model selection affects latency, inference cost, operational complexity and the amount of nondeterminism introduced into the system. A general-purpose LLM provides flexibility across tasks, while a specialized classifier can offer a narrower execution path when the input space and expected outputs are well defined.

My time with software engineering and data science has made this trade-off particularly familiar to me. The underlying principle has not changed much: understand the problem, define the constraints, then choose the least complex approach that satisfies them. LLMs expand the set of tools available to us, but they do not remove the architectural decisions that come before choosing one.

https://magazine.sebastianraschka.com/p/classifier-history-and-jev

Introducing Strand Harness

A 28% reduction in token cost without changing the underlying model immediately caught my attention, mostly because the optimization is happening somewhere that receives less attention than model selection: the agent harness.

The Strands team published benchmark results for its new agent harness, reporting 28% lower cost when using the same Claude or GPT models across six benchmarks, while maintaining similar accuracy. The implementation details are more interesting than the headline number: tool results above roughly 1,500 tokens are truncated, compaction starts after context usage exceeds 85%, and context recovery is handled inside the execution loop. Those mechanisms show how much of agent performance is now an orchestration problem rather than a model selection problem.

This feels particularly relevant with the attention around Jev from TypeSafe AI, which approaches the same problem from another direction by moving structured decisions away from general-purpose LLM generation altogether. We are starting to see the architecture around models become as important as the models themselves. The question is shifting from “which model should we use?” toward “which parts of the system actually need a general-purpose model, and how should intelligence be orchestrated around them?” Context lifecycle, model routing, typed decisions, tool boundaries, failure recovery and token economics are increasingly becoming architectural decisions in their own right.

#AI #AgenticAI #SoftwareArchitecture

https://strandsagents.com/blog/introducing-strands-harness/

Posted in AI

How Uber Protects Against Retry Storms

I have spent enough time around distributed systems to be suspicious of any resilience mechanism that operates without understanding where a failure originated. I remind why that matters with Uber’s write-up on retry storms.

In a deep service graph, retries that look reasonable at the level of one caller can multiply as an error propagates upstream, increasing load on the component that is already failing. Uber addresses this by introducing error ownership into shared infrastructure. A service distinguishes an error it originated from one it is propagating, and callers use that information to decide whether another attempt can plausibly help. In one production incident, Uber reports that this mechanism prevented roughly 9.5 million spurious requests, while preserving at-least-once retry behavior where appropriate.

The architectural point extends beyond retries. Reliability controls become more effective when they operate on causal context rather than local symptoms; rate limits, circuit breakers, backpressure, and retries all make better decisions when the system can preserve enough provenance across service boundaries to identify where intervention belongs. For large service meshes, resilience is then partly a context-propagation and attribution problem, not only a configuration problem.

https://www.uber.com/us/en/blog/protecting-against-retry-storms/

The Cuckoo’s Egg

I just finished “The Cuckoo’s Egg” by Clifford Stoll. This true story is from the 80’s and reading it as Gen Xer gave it an entirely different weight. Stoll’s obsessive tracking of a hacker through a maze of dial-up connections and computer networks brought back a flood of memories from my own teenage years, when I spent countless evenings dialing into BBS systems and waiting for that familiar screech of a modem handshake to connect me to a small, text-based corner of the world.

Because I belong to that first generation that experienced the early online world firsthand in its earliest, clunkiest, most improvised form, the technical descriptions in the book never feel like historical curiosities to me the way they might to younger readers. The idea of tracing a security breach across a patchwork of telephone exchanges and rented lines, of treating bandwidth and connection time as genuinely scarce resources worth fighting for, mirrors exactly what it felt like to be online during that era, when connection time and computing resources often carried a very tangible cost and every connection was a small negotiation with the physical infrastructure underneath it.

What makes the book more than just a nostalgia trip for people like me is how well it captures the tension between the physical world of telephone lines, modems, and telecommunications infrastructure and the emerging digital world that would eventually swallow it whole. Stoll wrote a technical thriller that also happens to be a time capsule of a specific and fleeting moment in computing history, and having lived through even a small piece of that moment makes his obsessive hunt for a hacker feel less like fiction and more like a shared memory.

If you came of age anywhere near computers and modems during that decade, I think this book will hit you the same way it hit me, somewhere between recognition and disbelief that we ever tolerated systems that slow and still found them thrilling.

Rust Is Tier-1 Language at Microsoft

I have been following Microsoft’s Rust investment for years, and this week’s update from the Rust Foundation stood out.

Microsoft has classified Rust as a Tier-1 engineering language, placing it alongside C++, C#, and TypeScript for internal development, which means Rust now gets a paved path from local development to production, including secure toolchain builds, developer tooling, and compliance with Microsoft’s Security Development Lifecycle requirements. The centerpiece of this effort is rustc_codegen_utc, a code generation backend for rustc that connects the compiler to MSVC, the native platform compiler for Windows; this places it in the same architectural family as rustc_codegen_llvm and rustc_codegen_cranelift, but it targets the toolchain that Windows and C++ teams already depend on for binary hardening, post-link compliance, hotpatching, and crash-dump analysis.

For engineers who work across hybrid Rust and C++ codebases, this matters because interoperability has historically meant duplicating platform-specific investments for each language separately. With a shared backend, new MSVC features, security capabilities, and diagnostics land on a common foundation, so Rust participates directly in the same engineering lifecycle that C++ has occupied at Microsoft for decades. More than 100 internal repositories already build with rustc_codegen_utc, and the rollout continues weekly, which suggests this is an operational shift in how Windows native software gets built, not a pilot.

The broader signal here is that language interoperability at this scale requires infrastructure investment measured in years, not a single migration project. Teams evaluating Rust adoption on Windows platforms should watch how this backend matures, since it changes the calculus for what a hybrid codebase can achieve without maintaining a parallel toolchain for every platform capability.

Guest Post: Rust Is Tier-1 Language at Microsoft

Europe’s Pitch Book

Follow this series by @Marieke Blom : Europe’s Pitch Book; it offers a glass-half-full perspective on Europe’s economic reality.

These are the first 3 articles:
•⁠ ⁠The case against European pessimism
https://think.ing.com/opinions/europe-pitchbook-introduction/
•⁠ ⁠Doomed by demographics?
https://think.ing.com/opinions/europes-pitch-book-doomed-by-demographics/
•⁠ ⁠Rethinking the productivity gap
https://think.ing.com/opinions/europes-pitch-book-doomed-by-demographics/
​