SumatoSoft

AI coding raises the standard for the engineering discipline 🤖

Anthropic is scaling Claude Code fast enough that it struck a major new compute deal and expects its first adjusted quarterly operating profit on strong demand. That tells us something important about software delivery in 2026. AI coding tools are no longer a side experiment. They are becoming part of how teams write, review, and ship code. ⚙️
That makes the engineering discipline more important, not less. Weak architecture, vague ownership, and shallow review do not disappear when code generation gets better. They spread faster. 📈

Agents need system design 🏗️

Google is putting AI agents at the center of its enterprise push. That is a useful signal for software teams. Once an agent can retrieve, route, draft, and trigger actions, the product needs stronger permissions, better audit trails, and tighter workflow control. The model matters, but the surrounding system decides whether the feature can be trusted in production. 🔐
This is why agentic AI is also an architecture topic. 🧠

Cheaper models change product decisions 💰

Google used I/O 2026 to push a faster, cheaper Gemini model for enterprise use. As inference becomes cheaper, more AI features move from pilot mode into standard product logic. Teams can support more requests, broader usage, and steadier adoption without bending the entire budget around a single feature. 📉

That shifts the software question. The focus moves from "Can we add AI?" to "Where does AI improve the product enough to justify continuous use?"✅

Multi-agent patterns: which one fits your problem 🧩

As multi-agent AI deployments have become common in 2026, a small set of architectural patterns has emerged. Knowing which pattern fits your problem is the difference between a system that scales and one that gets stuck in coordination overhead.

The four patterns we use most often.

Supervisor and workers. A central planner agent receives the goal, breaks it into sub-tasks, and routes each to a specialised worker agent. The supervisor coordinates. Workers don't talk to each other. Best for workflows with clear sequential steps. Fails when sub-tasks have complex dependencies that benefit from worker-to-worker negotiation. 🤖

Sequential handoff. Each agent does one stage of work and passes the output to the next. Best for assembly-line patterns where the workflow is linear and predictable. Fails when later stages need to send information back to earlier stages. 🔄

Swarm. Many agents work in parallel, each on a small piece, with results aggregated at the end. Best for embarrassingly parallel work like analysing many documents independently. Fails when the work has interdependencies.

Hierarchical. Supervisors with their own sub-supervisors and workers, recursive. Best for very large workflows. Fails frequently because debugging multi-level hierarchies is operationally painful and policy enforcement gets murky at depth. 🏛️

The trap most teams fall into is reaching for the most flexible pattern (hierarchical) when the simplest one (handoff or supervisor) would work. The simpler pattern ships faster, debugs faster, costs less to run, and breaks in fewer places. Add complexity only when the simpler pattern stops working.

If a vendor pitches a multi-agent system without explaining which pattern they're using and why, they're either using whichever pattern their framework defaults to, or they haven't thought about it. Either is a yellow flag.

How small companies fine-tune without proprietary training data 🧠

A common assumption that's no longer correct: you need a large proprietary dataset to fine-tune a model usefully.

For most enterprise fine-tuning use cases in 2026, including domain-specific tone, structured output adherence, workflow-specific reasoning, and brand voice consistency, synthetic data has become a first-class option. The pattern works like this: you describe what you want the model to do in detail, you use a strong frontier model to generate hundreds or thousands of input-output pairs that match the description, you filter the synthetic pairs for quality, and you fine-tune a smaller model on the result. 🔄

The fine-tuned smaller model often performs the target task as well as the frontier model, at a fraction of the inference cost. This is the technique behind several recent open-weight model releases that punch above their parameter count.💰

Where synthetic data does and doesn't work: it works for behavioural fine-tuning (tone, format, structured output, domain-vocabulary adoption). It works less well for fine-tuning on specialised factual knowledge, where you want the model to know things it didn't know before. For factual grounding, RAG or graph RAG remains the better tool. The two approaches combine well: fine-tune for behaviour, retrieve for facts.🧩

For companies that have been told "we can't do AI because we don't have enough data," this changes the conversation. The data constraint that blocked fine-tuning in 2023 has loosened. What you need now is a clear specification of what the model should do, a frontier-model budget for synthetic generation, an eval suite to verify the result, and a serving infrastructure for the fine-tuned model. The fine-tuned model that comes out can often run on your own infrastructure for a few hundred dollars a month.✅

Voice AI just had its plumbing year 🎙️

Something happened to voice AI in the last twelve months that made it production-grade for enterprise deployments. 🏭

The core capability of speech-to-text plus LLM plus text-to-speech has existed for several years. What changed is the orchestration layer between them. Latency dropped from 3 to 4 seconds to under 800 milliseconds for a full conversational turn. Interruption handling, the thing that made voice agents sound robotic, became standard. Tone and emotion in synthesised speech crossed the uncanny valley for most use cases. Voice infrastructure platforms such as Vapi, Retell, and LiveKit shipped the production tooling that turns these capabilities into a deployable service. ⚙️📉

The deployment patterns we see this year: customer service IVR replacement (the largest category, with carrier-to-carrier check calls being a logistics-specific example), outbound qualifying calls for sales operations, appointment scheduling and confirmation, and field-service follow-up calls. None of these require frontier reasoning. They require reliable conversational flow under cost and latency budgets that match human-call economics. 📞✅

The question worth answering before scoping a voice project: which calls in your operation follow a script with predictable variations? Those calls are now automatable. The calls that don't follow scripts (relationship management, complex troubleshooting, anything where tone and judgment carry the conversation) remain human work for now. The economics of voice AI deployments only land when you sort calls correctly into the two buckets. 🧠🗂️

The missing layer in most enterprise AI stacks 🧩

A gap I see in most enterprise AI deployments: the application is in production, the model is in production, and the observability layer is missing. 👀

In a normal software stack, observability is non-negotiable. Logs, metrics, traces, alerts. You wouldn't ship a service without them. AI features get shipped without their equivalent more often than not, and the consequences arrive at month four. 📉

What AI observability covers, beyond traditional APM: request-level traces of the model call (system prompt, retrieved context, model output, latency, token cost), eval results in production rather than only at deploy, drift detection on input distribution and output quality, cost tracking per workflow and per tenant, and audit logs of which version of which prompt produced which decision. 🧠

The tools have matured. LangSmith, Langfuse, Arize, Helicone, and Datadog's LLM observability layer all hit production-ready in the last 18 months. 🛠️

What hasn't matured is the procurement reflex to include them. Most AI vendor proposals quote the model integration and skip the observability layer. The buyer doesn't notice until production, by which point retrofitting observability into a deployed system costs more than building it in. ⏳

When plain RAG breaks ⚙️

A pattern across enterprise AI projects this year: vanilla RAG works for the first 80 percent of queries and breaks on the next 15. The break is structural, and a class of fixes called "graph RAG" has emerged to handle it. 📉

Plain retrieval-augmented generation works by chunking your documents, embedding the chunks, and retrieving the closest chunks to the query. This works when the answer to a query lives in a single document or a handful of contiguous chunks. It breaks when the answer requires connecting facts across documents that don't sit close together in embedding space. 🔗❌

The classic example: "Which of our suppliers have had compliance incidents and also serve customers in regulated industries?" That answer requires a multi-hop traversal. Suppliers, then incidents, then suppliers again, then customers, then customers' industries. No chunk contains the full answer. Embedding similarity won't find it. 🧩

Graph RAG approaches solve this by building a knowledge graph from the source documents (entities, relationships, attributes), then querying the graph alongside or instead of the embedding store. Microsoft published a notable graph RAG paper last year, and several open-source frameworks now implement the pattern. Production deployments are landing across legal, healthcare, supply chain, and financial services in 2026. 📊✅

"Prompt engineering" is a 2023 word 📅

The phrase has quietly stopped showing up in serious AI engineering practice. What replaced it: context engineering. 🔄

Prompt engineering was about phrasing the instruction well: writing a single prompt that produces a good output for a single use. Context engineering is about assembling everything the model needs to do its job. The system prompt, retrieved documents, tool definitions, conversation history, user metadata, structured examples, and policy constraints, all selected and ordered for the specific request. 🧠

For a single-shot question, the difference is invisible. For an agent handling a complex workflow, it determines whether the system works at all. The agent that has access to all the right context produces good outputs reliably. The same agent with everything except the right ordering produces unpredictable outputs that look like model failures but are context-assembly failures. ⚙️

What this means for projects: the engineering work is upstream of the prompt. Building the retrieval pipeline that finds relevant content. Building the metadata layer that injects user-specific context. Building the templating system that orders information for the model's attention pattern. Building the cache layer that makes context-heavy requests affordable. Most of the work that determines whether an AI feature ships well lives in assembly, not phrasing. 🏗️

When a vendor pitches "we'll write your prompts," they're selling 2023. When they pitch context architecture, schema design for agent inputs, and retrieval evaluation, they're selling what 2026 ships. 📦

If your AI deployment doesn't run evals on every commit, it isn't in production ⚙️

A pattern across AI integration projects that ship versus ones that don't: the shipping ones treat evaluations as production infrastructure, not as a testing phase. 🚢

The distinction is straightforward. In a normal software stack, you write unit tests, integration tests, and end-to-end tests. They run on every commit. If they fail, the deploy is blocked. AI features need an equivalent layer, and the equivalent is the eval suite. A test answers "did the function return the expected output?" An eval answers "did the model produce a response of acceptable quality on a representative input?" 🤖

What an eval suite for a production AI feature looks like: a fixed set of inputs that span the workflow's distribution, ground-truth answers or scoring rubrics, automated grading (often by another LLM or a deterministic check), latency and cost gates, and regression detection across versions. Anthropic, OpenAI, and Google all publish their internal eval setups now. The pattern has converged. 📊

Why this matters for the buyer: when a vendor says they tested the AI feature, the question to ask is "do you run evals on every deploy?" Vendors that say yes are operating in 2026. The ones that conflate testing with evals are operating in 2023, and you'll find out in production. 🛒

Most failed AI integration projects didn't fail because the model was wrong. They failed because nobody had a running eval suite that would have caught the regression when the prompt changed, the model version updated, or the retrieval source drifted. Build the eval suite first. The model work is downstream of it. 🔧