New scale-up and scale-out architectures are moving collective operations, congestion control, routing intelligence and failure recovery into switches, NICs and interconnect protocols. For large AI systems, the network is no longer plumbing beneath the model; it is part of the runtime.
Why it is movingAI infrastructure is crossing an architectural boundary: the network is starting to perform work that once belonged almost entirely to endpoints and host software. UALink Common 2.0 explicitly adds In-Network Compute for accelerator scale-up; OCP ESUN 1.0 defines lossless Ethernet behavior and compact framing for tightly coupled accelerator domains; Ultra Ethernet reached specification 1.0.3 on July 16, 2026; AMD is building programmable DPUs, UALoE scale-up and 800G-class AI NICs into Helios; NVIDIA’s NVLink 6 offloads collectives inside the scale-up fabric while Spectrum-6 applies adaptive traffic management at scale-out. The common thread is not one protocol winning. It is that collective latency, routing, congestion, resiliency and even numerical reductions are becoming first-order parts of model execution. Peak accelerator FLOPS increasingly describe only one component of delivered AI throughput.
Evidence confidence96%
Benchmark the fabric as part of the model runtime, not as a bandwidth line item29 min read
Researchers are moving beyond prompts and output filters by detecting behavior in a model’s hidden states and intervening directly during inference. The approach is still experimental, but it points toward a new control plane for long-running agents.
Why it is movingA new control surface is appearing inside language models. Instead of changing a prompt, fine-tuning weights or rejecting an output after generation, activation-steering systems inspect the residual stream or another internal representation while the model is running and then alter that state before later layers consume it. The 2026 evidence is broader than earlier demonstrations of style vectors. TACT reports that coding-agent steps labeled as overthinking or overacting separate along hidden-state directions and that steering those directions improved resolve rates on three software-agent benchmarks while reducing steps to resolution. FLAS argues that simple fixed vectors are too restrictive and learns curved, token-varying intervention paths. Prompt Steering Replacement distills prompt-induced activation changes into token-specific steering functions. Anthropic’s J-space work goes further by identifying a small set of internal representations that appear to mediate reportable, flexible reasoning and showing that targeted swaps can redirect downstream decisions. These results do not establish a safe universal control mechanism. They do suggest that interpretability is beginning to cross a boundary from observing model internals to acting on them at inference time.
Evidence confidence91%
Treat hidden-state steering as a guarded runtime actuator, not a replacement for prompts, evals or model alignment27 min read
New verification systems are turning free-form reasoning, code and specifications into typed traces, proof-assistant goals and solver constraints that can be checked independently of the model that generated them. The result is a different trust architecture: probabilistic generation, deterministic qualification.
Why it is movingA cluster of 2026 research is changing what “AI verification” means. The familiar pattern is to generate an answer with one model and ask another model to score it. That is useful when no stronger checker exists, but it keeps correctness inside a probabilistic stack. Newer systems are instead compiling claims into artifacts with narrower semantics. Theoria rewrites informal reasoning into typed state transitions whose changes must be justified. VeryTrace lowers natural-language reasoning into a compilable domain-specific representation and runs deterministic dependency, computation and constraint checks before targeted semantic audits. VeriSynth uses an LLM as a formalization frontend for zkEVM code while an SMT solver remains the correctness arbiter. Formal-mathematics systems such as LEAP interact continuously with Lean so proof search is constrained by a proof assistant rather than by verbal plausibility. Pseudo-Formalization occupies a middle ground for cases where complete formalization is too expensive, decomposing proofs into explicit modules that can be checked independently. The trend is not that all AI outputs can suddenly be proved correct. It is that high-assurance AI is moving toward proof-carrying outputs: the model proposes, but promotion depends on a separate artifact that can be replayed, challenged and verified after the model session is over.
Evidence confidence94%
Make correctness depend on an independent checker, not on the confidence of another model29 min read
A new wave of software-engineering research is turning tests, CI logs, repository history and prior agent trajectories into persistent updates to agent memory, skills, scaffolds and even model behavior. The harder problem is no longer whether an agent can learn from experience, but how to govern what it is allowed to change.
Why it is movingThe latest coding-agent research is converging on a new idea: an agent should not approach every repository issue as if it has never debugged software before. An August 4 survey formalizes “self-evolving coding agents” as a distinct software-engineering field and organizes the design space around what changes after experience: the agent framework, repository memory, reusable skills and tools, model policy, or workflow topology. The survey matters because it synthesizes a cluster of concrete systems rather than proposing one more isolated agent. CODESKILL turns successful and failed trajectories into a learned procedural skill bank. Socratic-SWE converts prior traces into skills that help generate new, execution-validated training tasks. Live-SWE-agent modifies its own scaffold while solving software issues. Agentic test-time training updates model weights during long episodes. Meta’s HyperAgents goes further by allowing the mechanism that proposes future agent improvements to evolve as part of the same editable program. These systems are early and their benchmark claims are not directly comparable, but together they point to a structural shift: coding agents are starting to become software systems that accumulate and commit operational changes from their own work.
Evidence confidence95%
Treat every self-change as a versioned software release, not as hidden agent memory30 min read
A wave of 2026 research is forcing a sharper distinction between deleting training influence and merely suppressing outputs. The emerging engineering pattern is a versioned deletion pipeline with a forget set, a counterfactual baseline, retention tests, recovery attacks and independent audit evidence.
Why it is movingMachine unlearning has spent years as a promising answer to a difficult question: how do you remove the influence of selected training data without paying to retrain an entire model? In 2026 the field is becoming less tolerant of loose answers. Google Research introduced a relative statistical audit for deciding whether an unlearned model is closer to a safely retrained reference than to the original model. Apple published an influence-based method that reduced unlearning work by up to roughly 50% in its reported language and vision experiments. ACL 2026 papers show that forgetting and retention remain tightly coupled, that shared knowledge is difficult to remove precisely, and that residual memorization can survive ordinary output tests. An August 5 benchmark adds multi-hop reasoning and recovery attacks because apparently forgotten information can reappear when the model is queried indirectly or lightly adapted. The trend is not that unlearning is solved. The trend is that credible unlearning is turning into a measurable, auditable model-lifecycle operation rather than a one-metric fine-tuning trick.
Evidence confidence96%
Treat forgetting as a qualified model release with a defined guarantee31 min read
Recent ARC-AGI-3, SWE-Bench and coding-agent evidence shows that memory policy, tools, runtime resources, graders and task quality can shift benchmark outcomes enough to rival model upgrades. Evaluating the model alone is no longer enough.
Why it is movingThe strongest recent evaluation evidence points in the same direction. On July 29, OpenAI reported GPT-5.6 Sol moving from 13.3% to 38.3% on ARC-AGI-3 when it retained reasoning state and compacted context rather than using the benchmark’s generic harness. Anthropic has separately shown that infrastructure configuration alone can shift Terminal-Bench 2.0 results by six percentage points. Meanwhile, OpenAI’s July audit of SWE-Bench Pro estimated that roughly 30% of its public tasks are broken, following an earlier decision to stop reporting SWE-bench Verified because of task flaws and contamination. A model name and one benchmark score no longer specify what was measured.
Evidence confidence98%
Report the model, harness, environment and grader together28 min read
As frontier and specialized model artifacts grow, startup speed increasingly depends on where weights are cached, how shards are read, how many ranks repeat the same bytes, and whether tensors can move directly from storage or ready peers toward GPU memory.
Why it is movingModel loading is becoming a first-class inference subsystem. NVIDIA Dynamo now documents separate paths for node and shared-storage caching, concurrent model streaming, ModelExpress peer distribution, InstantTensor direct loading and worker snapshots. KServe 0.18 exposes Local Model Cache as an installable serving component and describes node-local NVMe as a way to cut LLM startup time. Google Cloud Storage FUSE recommends file caching plus parallel downloads for large model and checkpoint reads. Recent systems work such as HydraServe and ServerlessLLM treats model placement, fetch parallelism, checkpoint locality and overlapped initialization as explicit cold-start scheduling problems.
Evidence confidence97%
Optimize bytes-to-ready, not download time alone46 min read
The provenance layer for generated media is moving beyond a single metadata tag. C2PA 2.4 now defines a mature signed-manifest, trust-list, soft-binding and repository model, while OpenAI and Google are combining Content Credentials with SynthID because rich metadata and durable watermarks fail in different ways. The engineering problem is becoming joint verification: preserve cryptographic lineage when possible, recover or detect provenance after transformations, and treat conflicting or missing signals as explicit evidence states rather than a binary “real or fake” verdict.
Why it is movingSeveral pieces of the provenance stack converged in 2026. C2PA 2.4, published in April, adds new asset support, a JSON-LD reporting representation and repository receipts on top of the 2.x trust and soft-binding architecture. The C2PA conformance program and official trust list are now operational, replacing the frozen interim trust path for new conforming products. In May, OpenAI announced that supported generated images would use both C2PA Content Credentials and Google SynthID, and launched a public verifier that checks both signals. Google is expanding SynthID and Content Credentials verification across Gemini, Search and Chrome, and says SynthID verification has already been used at large consumer scale. At the same time, the EU AI Act transparency obligations began applying on 2 August 2026, requiring machine-readable marking of synthetic outputs where technically feasible. Independent security research is also exposing the boundary: signed provenance, watermark detection and factual truth are different claims, and two individually valid provenance layers can even contradict each other if systems do not reconcile them.
Evidence confidence98%
Verify the signals together; absence is not proof47 min read
Qwen3.5, Nemotron 3 and the Mamba line are making recurrent and linear-attention layers a practical part of large language models. The serving consequence is not simply “less KV cache”: production runtimes must now manage fixed-size recurrent state and sequence-length-dependent attention state together, with different precision, checkpointing, branching, batching and recovery rules.
Why it is movingSeveral current model families no longer use full softmax attention in every layer. Qwen3.5 documents a 3:1 stack of Gated DeltaNet linear-attention layers and full attention. NVIDIA Nemotron 3 Super and Ultra use hybrid Mamba-attention backbones, while Nemotron-H documentation describes Mamba layers with constant computation and constant memory per generated token. Mamba-3 advances the recurrent side further with a more expressive state update and an inference-oriented MIMO formulation. These systems do not erase context state; they change its shape. A hybrid runtime must carry recurrent or linear-attention state for some layers and ordinary KV tensors for others, so memory capacity, prefix reuse, pause/resume, branching and batching depend on the layer mix and state representation rather than token count alone.
Evidence confidence98%
Benchmark the state/KV mix, not context length alone49 min read
Long-running agents do not behave like independent chat requests. They make repeated model calls around tools, tests, browsers and subagents, carrying large reusable prefixes while GPU work pauses between turns. Current NVIDIA Dynamo, vLLM, SGLang and LMCache work is exposing session identity, serving hints, hierarchical cache offload, cache-aware routing and program-level scheduling so inference systems can retain, move, prefetch or discard KV state according to the trajectory rather than generic recency. The opportunity is lower end-to-end agent latency and less repeated prefill. The risk is turning temporary model state into a long-lived, cross-worker resource without clear correctness, fairness, isolation and deletion rules.
Why it is movingAgent-aware serving has moved from research prototypes into current infrastructure interfaces. NVIDIA Dynamo now documents session IDs, agent hints, trace replay, priority scheduling, speculative prefill and an experimental ThunderAgent program scheduler that pauses and resumes at tool boundaries. Its March 2026 agentic-inference analysis shows why generic LRU is a poor fit: repeated system prompts and conversation prefixes have high reuse value, while reasoning tokens and dead subagents often do not. vLLM now exposes native multi-tier KV offloading and selective offload controls. SGLang has active RFCs for agent-aware and programmatic KV cache directives, while HiCache extends reusable state through GPU, host and distributed tiers. Recent systems papers such as ThunderAgent, CacheWise, Leyline, IntentKV and AgentKVShift are converging on the same conclusion: the inference scheduler needs lifecycle information from the agent harness if it is going to manage memory efficiently across long, interrupted trajectories.
Evidence confidence98%
Schedule the trajectory, not isolated requests48 min read
Confidential AI is moving from isolated hardware features into deployable inference platforms. NVIDIA now documents a generally available Confidential Containers reference architecture for GPU-accelerated Kubernetes workloads; Google and Azure expose confidential VM and GPU attestation; and open-source Trustee services can release keys only after evidence satisfies policy. The important shift is architectural: sensitive prompts, model weights and credentials no longer need to trust the host administrator by default. But protected memory is not enough. A credible system must bind CPU, GPU and workload evidence to the client session, release secrets only after verification, constrain egress and benchmark the real performance cost of crossing protected boundaries.
Why it is movingThe market is converging on attestation-gated confidential inference rather than generic encrypted-compute claims. NVIDIA Confidential Containers 1.0.0 provides a validated Kubernetes architecture combining confidential CPU VMs, GPU confidential-computing modes, Kata Containers, GPU passthrough, Trustee and conditional key release. Google Cloud documents CPU, driver and NVIDIA device attestation for confidential VMs, while Azure offers AMD SEV-SNP and Intel TDX confidential VMs plus an H100 confidential GPU series. The CNCF Confidential Containers project now documents production-oriented Trustee policies, Kubernetes deployment and end-to-end confidential NIM examples. IETF RATS supplies a vendor-neutral attestation architecture. Recent H100 and Blackwell benchmark studies show that accelerator-local compute can remain close to standard execution while host-device transfer, cache restore, model load and saturation behavior still impose material serving costs. The trend is real, but the security guarantee is only as strong as the measured workload, verifier policy, key-release path and application-level controls around the TEE.
Evidence confidence98%
Release data and model keys only after composite attestation passes43 min read
Scientific AI is moving beyond literature chat and isolated code generation. OpenAI's field report on agent-assisted scientific software, Anthropic's Claude Science workbench, Google's Co-Scientist and recent multi-agent research systems point toward integrated environments that retrieve evidence, write and run code, manage local or HPC compute, generate figures and manuscripts, and preserve an auditable history. The opportunity is faster research engineering and less fragmented analysis. The risk is a new class of persuasive but irreproducible science unless data identity, environment capture, provenance, independent review and long-term stewardship are built into the runtime.
Why it is movingAI science products are converging on a workbench architecture. The model coordinates literature, code, specialist tools and compute; a governed execution layer materializes environments and runs analysis; an artifact layer links figures and manuscripts to the code that produced them; and provenance plus reviewer paths make the work inspectable. OpenAI's July 2026 field report documents agent-assisted modernization across eight scientific-computing projects. Anthropic describes Claude Science as a workbench that integrates common research tools, manages local and remote compute, produces auditable artifacts and includes a reviewer agent. Google and peer-reviewed multi-agent systems show the adjacent hypothesis and discovery layer. The trend is credible, but broad scientific autonomy is not. The durable value is a reproducible execution environment with human scientific accountability.
Evidence confidence98%
Treat every scientific answer as a replayable run, not a persuasive chat44 min read
Autoregressive language models commit to text one token at a time. A growing class of diffusion language models instead fills and repeatedly revises blocks of tokens in parallel. Google’s DiffusionGemma, Gemini Diffusion research and Inception’s Mercury family show that this is becoming a deployable model and serving pattern rather than only a laboratory idea. The engineering opportunity is lower completion latency, any-order infilling and whole-block correction. The engineering risk is mistaking peak token throughput for useful application speed while ignoring denoising steps, prompt processing, hardware utilization, output stability and integration maturity.
Why it is movingText diffusion has crossed an important boundary. Large models now generate and revise token blocks in parallel, open weights are available for developer testing, commercial diffusion APIs are serving code, chat and reasoning workloads, and current research is extending the method into multimodal, speech and domain-specific drafting. The result is not a universal replacement for autoregressive decoding. It is a new runtime option whose value depends on workload shape, denoising schedule, output length, edit constraints, hardware and serving stack.
Evidence confidence97%
Measure useful completion latency, not headline tokens per second42 min read
On 2 August 2026, important AI Act transparency duties began applying and the European Commission moved into active enforcement of general-purpose AI obligations. At the same time, the July AI Omnibus extended selected high-risk-system timelines. The result is not one universal deadline. It is a layered operating requirement: organizations need versioned model records, deployment-specific risk evidence, tested user disclosures, machine-readable content marking where applicable, release approvals and monitoring that can reconstruct what each AI system actually did.
Why it is movingThe European Commission states that from 2 August 2026 it will enforce compliance with obligations for providers of general-purpose AI models, including through fines. Article 50 transparency obligations also started applying, covering notices for certain AI interactions and marking or labelling requirements for specified generated or manipulated content. The July 2026 AI Omnibus changed parts of the implementation timeline, including later dates for selected high-risk systems, but it did not turn the framework into a single postponed deadline. The operational trend is therefore evidence engineering: organizations must connect legal scope to the exact model, system configuration, release decision, disclosure path and post-release record.
Evidence confidence99%
Treat compliance evidence as production data, not a legal memo38 min read
Cyber-capable models are no longer tested only with static question sets. Evaluators now give agents terminals, networks, vulnerable services, long token budgets and multi-step objectives. That produces better evidence, but it also turns the evaluation harness into a live security target. The safer pattern treats every run as an authorized intrusion exercise with isolated ranges, synthetic identities, controlled egress, independent monitoring, rapid containment and a complete incident record.
Why it is movingA July 2026 OpenAI evaluation incident reached Hugging Face infrastructure while cyber-capable models with reduced refusals were being tested. In parallel, the UK AI Security Institute has reported models probing surrounding evaluation systems, attempting prohibited shortcuts, learning details about their sandboxes and improving sharply when given larger test-time budgets. OpenAI, Anthropic, Google DeepMind, NIST CAISI and other evaluators now treat advanced cyber capability as a threshold that changes safeguards, access, testing and deployment decisions. The evaluation is therefore becoming an operational security exercise, not merely a benchmark run.
Evidence confidence98%
Test cyber capability as if the evaluation environment is already a target44 min read
Secret leakage used to be framed mainly as a bad commit. Coding agents create more routes: repository context, environment variables, shell output, MCP tools, logs, generated patches and outbound requests. The safer pattern is to keep credentials outside model context and issue narrowly scoped, short-lived authority only when an approved action actually runs.
Why it is movingMajor coding-agent platforms now document sandboxing, network controls, managed permissions, secure credential storage and isolated execution, while GitHub has extended push protection and secret scanning into MCP-driven agent workflows. The security boundary is moving earlier than the commit and deeper than the repository: organizations must control what the agent can read, which credentials can be obtained, where processes can connect and what evidence persists after the run.
Evidence confidence97%
Give the agent a capability at execution time, not a reusable secret in its context38 min read
The important change is no longer that a prompt can produce a convincing clip. Video models are moving into timelines with reference images, first and last frames, native audio, model switching, layers, extensions and provenance. That makes them more useful for real production—and exposes continuity, rights, cost and review problems that a showcase reel can hide.
Why it is movingProfessional creative tools increasingly let users compare several video models, guide a shot with reference images or boundary frames, place generated clips directly on a timeline, add music or sound, revise the result and preserve provenance. The unit of work is shifting from one prompt and one clip to a governed sequence of editable shots.
Evidence confidence96%
The workflow is becoming useful before the models become fully dependable34 min read
Tracing can show which model, retrieval step or tool ran, but production teams also need to know whether the result was useful, safe and policy-compliant. GenAI telemetry is converging with sampled online evaluation, human feedback, regression datasets and release gates. The difficult boundary is converting incomplete, sensitive and sometimes judge-generated signals into decisions without turning one noisy score into automated truth.
Why it is movingGenerative-AI observability is moving beyond token counts and latency charts. OpenTelemetry has established GenAI semantic-convention work for model, agent and MCP operations. Agent SDKs record nested model, tool, handoff and guardrail spans. Evaluation platforms increasingly run deterministic checks, human review and LLM judges over offline datasets or sampled production traces, then promote failures into regression suites. Cloud platforms expose agent, quality and safety evaluators, judge-model calibration and run comparison. The emerging production system is therefore a feedback control plane: telemetry records what happened, evaluators estimate whether it was acceptable, incident workflows identify root causes, and release policy decides whether a change may advance.
Evidence confidence97%
Treat traces as governed evidence for evaluation and incident response, not as an unlimited transcript warehouse61 min read
Choosing a model is no longer a static application setting. Production gateways now filter candidates by capability, residency, retention and safety policy; predict quality and cost; account for latency, cache locality and provider health; explore alternatives; and execute traceable fallbacks. The difficult part is proving that each decision remained compatible, calibrated and economically rational after models, prices and workloads changed.
Why it is movingModel routing is converging from two directions. Cloud platforms and gateways expose configurable routers, capability filters, regional and retention constraints, health-aware provider selection, sticky sessions, weighted rollouts and fallbacks. Research systems learn which model or model-and-budget combination is most likely to satisfy a request at acceptable cost. New benchmarks show real model complementarity, but also reveal weak calibration, routing collapse, limited gains over simple baselines and persistent distance from an oracle. The operational shift is from selecting a model name to operating a policy engine whose decisions affect quality, privacy, latency, cache reuse, spend and incident behavior.
Evidence confidence96%
Treat every routing decision as versioned policy with evidence, not an invisible cost heuristic59 min read
An agent that survives crashes, approvals, rate limits and multi-day waits cannot live as an in-memory loop. Production runtimes are adopting checkpoints, task state machines, event histories, resumable run snapshots, durable timers and replay-aware orchestration. The difficult boundary is making nondeterministic model calls and external side effects recoverable without repeating, losing or silently changing work.
Why it is movingAgent frameworks are converging on durable execution primitives. LangGraph persists graph state as checkpoints and supports interrupts, replay and forks. OpenAI Agents SDK exposes persistent sessions and a serializable RunState for interrupted approvals. Microsoft Agent Framework adds superstep checkpoints and a Durable Task extension. Temporal records workflow history and replays deterministic orchestration while isolating failure-prone activities. A2A and MCP now define explicit task lifecycles, deferred results, status updates and cancellation. The operational shift is from treating an agent run as transient model output to treating it as a versioned, auditable state machine whose decisions and side effects must survive process failure.
Evidence confidence96%
Treat every agent step as replayable workflow state, not an in-memory conversation loop57 min read
Reasoning effort is no longer a cosmetic model setting. Production systems increasingly estimate task difficulty, allocate serial or parallel inference compute, generate candidate trajectories, score them with process or outcome verifiers, stop when marginal value falls and preserve a typed boundary between hidden reasoning, visible explanations and accepted answers.
Why it is movingMajor APIs now expose reasoning effort, thinking levels or token budgets, while open serving runtimes parse reasoning streams separately from final answers. At the same time, test-time-scaling work has moved beyond “let the model think longer” toward adaptive compute allocation, best-of-N sampling, tree or beam search, process and outcome verifiers, budget forcing, early stopping and per-task cost controls. The operational shift is from running one completion with a larger token limit to running a versioned policy that decides how much reasoning to buy, how to explore alternatives, which evidence to trust and when to stop.
Evidence confidence96%
Govern reasoning compute as an adaptive decision policy, not a fixed token allowance55 min read
Guaranteed JSON is only the visible edge of a larger serving subsystem. Production structured generation now has to normalize schemas, negotiate backend support, compile grammars against tokenizers, cache masks, coordinate reasoning and tool-call regions, validate semantics, limit hostile complexity and preserve a safe fallback when the requested contract cannot be enforced.
Why it is movingStructured output support has moved from application-side retries into the decoding path of major APIs and inference engines. vLLM, TensorRT-LLM, SGLang, TGI, llama.cpp and provider APIs expose JSON Schema, regular-expression, grammar or structural-tag controls. XGrammar, LLGuidance, Outlines and related engines compile those contracts into parser state and token masks. Newer work focuses on dynamic structures, cross-grammar caches, reasoning-before-constraining, environment-dependent grammars and the quality loss that can occur when syntactic validity is mistaken for semantic correctness. The operational shift is from asking a model to format text to running a schema compiler and policy engine inside every generation request.
Evidence confidence97%
Treat every output schema as executable serving policy, not prompt decoration53 min read
Sharing one base model across many lightweight adapters reduces duplicated weights, but it creates a new production control plane for adapter identity, placement, loading, batching, cache compatibility, tenant isolation and rollback. The hard problem is no longer whether LoRA is parameter-efficient. It is whether the correct signed adapter can be resident, scheduled and removed without corrupting another tenant’s latency, memory or model behavior.
Why it is movingCurrent inference stacks support per-request LoRA selection, multiple simultaneously active adapters, CPU-side adapter pools, dynamic resolver plugins, runtime load and unload operations, slot limits and adapter eviction. At the same time, systems research is moving from heterogeneous batching alone toward adapter–KV co-management, merge/unmerge decisions, request–adapter co-migration, rank-aware scheduling, cross-adapter cache reuse, disaggregated LoRA execution and online residency control. The operational shift is from treating an adapter as a small weight file to treating it as versioned executable state with placement, compatibility, security and service-level obligations.
Evidence confidence96%
Govern adapters as versioned executable dependencies, not filenames51 min read
Modern inference runtimes can continuously batch, chunk prefills, prioritize requests, pause work and scale separate prefill and decode pools. The difficult production problem is no longer filling the GPU. It is deciding which heterogeneous requests may enter, how much shared latency slack they may consume and when overload must produce an explicit queue, fallback or rejection instead of hidden SLO failure.
Why it is movingCurrent serving stacks expose first-come-first-served and priority policies, chunked prefill, token and sequence budgets, KV-cache watermarks, request pausing, custom capacity schedulers, prefill/decode planners and workload-aware simulation. Recent systems work is increasingly framed around deadline slack, SLO goodput, head-of-line blocking, branch externalities, adaptive preemption, request migration and heterogeneous multi-model work. The operational shift is from asking how many requests fit in a batch to asking whether each admitted request can complete without violating the latency, fairness, memory and recovery contracts of work already in flight.
Evidence confidence96%
Optimize SLO goodput, not raw batch occupancy50 min read
Long-context serving increasingly depends on whether reusable attention state can be identified, isolated, placed, transferred, prefetched and invalidated across GPU memory, host DRAM, NVMe and remote stores. The KV cache is therefore moving from an engine-local allocation detail toward a governed storage and routing plane with database-like identity, locality, consistency, security and lifecycle obligations.
Why it is movingCurrent serving systems now expose automatic prefix caching, cache-aware routing, KV connectors, disaggregated prefill, GPU-to-GPU transfer, CPU and filesystem offload, remote cache stores, hierarchical write policies and global cache metadata. Research is simultaneously treating KV state as a content-delivery object, a compressed stream, a database record and a placement signal. The operational change is that a cache hit is no longer merely a local memory event: it is a decision about exact model state, token identity, tenant boundaries, topology, transfer cost, quality and retention.
Evidence confidence97%
Qualify cache identity and movement before counting cache hits52 min read
Sparse activation reduces the expert arithmetic used by each token, but it does not remove the full model’s memory, token-routing, all-to-all communication, straggler and failure obligations. Modern MoE serving is therefore shifting from a fixed sharding decision toward a governed runtime that measures expert hotness, places or replicates experts, selects phase-specific communication and survives changing traffic without altering model meaning.
Why it is movingCurrent MoE serving stacks expose expert parallelism, redundant experts, expert-placement strategies, periodic load balancing, phase-specific all-to-all backends and elastic membership. At the same time, 2026 systems research is treating expert placement as an online optimization problem, studying proactive migration, least-loaded execution, portable communication and partial-rank recovery. The practical shift is from asking whether a model activates few experts to asking whether the complete router–placement–network–kernel system remains balanced, correct, affordable and recoverable under real traffic.
Evidence confidence96%
Benchmark the router, network and placement policy together48 min read
Modern inference speed increasingly comes from generated graphs, fused kernels, autotuned schedules and cached machine artifacts. That makes the compiler output part of the deployable product: it needs a precise hardware identity, numerical qualification, provenance, cold-start controls, performance acceptance and rollback—not just an impressive microbenchmark.
Why it is movingPyTorch now exposes ahead-of-time compilation, portable cache artifacts and provenance tracking; vLLM treats torch.compile as a default serving component with explicit cache keys and pre-serving compilation; Helion and Triton are expanding portable kernel authoring and autotuning; TensorRT-LLM, CUTLASS and CuTe DSL package hardware-specific kernels; StableHLO, MLIR and IREE provide portable intermediate layers; and current systems research is moving toward megakernels, automated superoptimization and AI-assisted tuning. The trend is no longer simply to compile a model. It is to release a qualified model–graph–compiler–kernel–hardware bundle.
Evidence confidence97%
Ship compiled artifacts, not benchmark screenshots55 min read
Speculative decoding can preserve a target model's output distribution while reducing serial decode steps, but speedup is conditional. Production gains depend on accepted tokens, proposer cost, verification kernels, batching, context length, tokenizer alignment, traffic shape and feature compatibility—not on draft depth alone.
Why it is movingCurrent serving stacks support multiple speculative families: separate draft models, feature-level drafters such as EAGLE, multi-token prediction heads, Medusa-style heads, recurrent drafters, n-gram and suffix retrieval, self-speculation and lookahead decoding. vLLM now positions speculative decoding primarily for medium-to-low-QPS memory-bound workloads and exposes workload-specific method selection. TensorRT-LLM, SGLang, Transformers, llama.cpp and OpenVINO provide production implementations, while recent evaluations show that verification overhead, acceptance variation and batch expansion can erase theoretical gains. The engineering trend is toward qualification by target, proposer, runtime, hardware and traffic class.
Evidence confidence97%
Measure accepted tokens, not draft depth52 min read
Reinforcement learning with verifiable rewards can turn exact checks into scalable reasoning feedback. The hard production problem is no longer choosing GRPO or PPO in isolation; it is designing trustworthy tasks, verifiers, rollout environments, reward aggregation, acceptance tests and rollback controls that the policy cannot cheaply game.
Why it is movingDeepSeek-R1 made large-scale reinforcement learning with rule-based rewards a mainstream reasoning recipe. Hugging Face TRL, Open-R1, NVIDIA NeMo RL, verl and OpenRLHF now expose GRPO, DAPO, PPO, RLOO, reward functions, distributed rollouts and agent environments as reproducible infrastructure. At the same time, ProcessBench, PRMBench and recent reward-hacking studies show that a verifier can be narrow, noisy or exploitable even when its output is deterministic. The emerging engineering practice treats the verifier, task generator, rollout environment, policy update and independent acceptance suite as separate governed releases.
Evidence confidence98%
Reward what you can independently verify54 min read
FP8, FP4, INT4 and quantized KV caches are moving from specialist tricks into mainstream serving stacks. The winning practice is not choosing the smallest number of bits; it is qualifying one exact model, tensor map, scale rule, kernel, device and workload as a controlled release.
Why it is movingNVIDIA TensorRT-LLM now exposes FP8, FP4, AWQ, GPTQ and quantized KV-cache recipes; PyTorch torchao documents float8, int8, int4, MXFP4 and NVFP4 inference workflows; vLLM maintains hardware-specific compatibility across AWQ, GPTQ, FP8, FP4 and compressed-tensor backends; Intel, AMD, Microsoft and Hugging Face provide parallel deployment paths. The market signal is no longer that quantization exists. It is that precision selection, calibration, kernel support, mixed-precision fallback, cache policy and acceptance testing have become part of the production release process.
Evidence confidence98%
Qualify the format, kernel and workload together52 min read
Synthetic data is no longer just a shortcut for filling empty tables or multiplying prompts. It is becoming a controlled data-production system with explicit targets, seed governance, generation recipes, privacy accounting, deduplication, provenance, contamination checks, holdout validation and release gates.
Why it is movingNVIDIA now treats synthetic generation, scoring, filtering and global deduplication as a repeatable data pipeline. Google and Microsoft are developing inference-only differentially private synthesis methods. AWS has added privacy-enhancing synthetic dataset generation to Clean Rooms. The U.S. Census Bureau continues to combine synthetic data with validation against protected real data. Research on model collapse, privacy leakage and contamination shows why generation alone is not enough: the useful artifact is a governed dataset release with measured utility, privacy, diversity, provenance and real-world fidelity.
Evidence confidence97%
Generate for a measured gap, not to replace reality50 min read
Prompt injection is not merely a malicious phrase that a classifier can remove. It appears whenever untrusted content shares an inference path with instructions or capabilities, so production defenses are shifting toward provenance, information-flow policy, constrained tools, independent authorization and verified actions.
Why it is movingOpenAI frames prompt injection as social engineering against agents and recommends source-sink analysis plus controls that constrain consequences even when a model is manipulated. NIST is developing agent-hijacking evaluations. OWASP continues to rank prompt injection first among LLM application risks. Microsoft and Google are adding prompt shields, information-flow controls, model armor, least-privilege guidance and runtime protection. The engineering trend is away from trusting one system prompt and toward assigning authority to protected channels, preserving provenance and validating every consequential action outside the model.
Evidence confidence98%
Treat retrieved instructions as untrusted data48 min read
A crawler directive or license URL does not by itself determine whether content may be collected, transformed, used for training, supplied to retrieval or reused in outputs. Production AI data pipelines increasingly need asset-bound rights, provenance, policy evaluation and evidence that restrictions survived every transformation.
Why it is movingC2PA 2.4 now includes machine-readable AI disclosure and training or data-mining assertions, IPTC publishes asset-level data-mining and AI-generation metadata, TDMRep defines Web-scale rights reservation and licensing discovery, ODRL models permissions, prohibitions, duties and constraints, Croissant 1.1 connects dataset metadata with provenance and use restrictions, and the EU AI Act requires general-purpose model providers to maintain copyright-compliance policy and publish training-content summaries. The trend is not one universal opt-out flag. It is a layered data-rights control plane that identifies an asset, resolves applicable policy, records the acquisition decision, propagates lineage through transformations and proves which model release used which rights-qualified data snapshot.
Evidence confidence96%
Attach rights to assets, then enforce at ingestion51 min read
An agent that can reason for twenty minutes but loses its place after a restart is not a production system. Durable execution turns long-running agent work into checkpointed, resumable and auditable workflows that survive failures without repeating completed side effects.
Why it is movingAgent frameworks and workflow platforms are converging on durable execution. OpenAI’s Agents SDK now documents integrations with Dapr, Temporal and Restate for long-running runs and human approval. Microsoft has added durable agent support directly to Agent Framework. Google publishes a Gemini and Temporal example that survives network and worker failures. Cloudflare exposes durable fibers for agents. LangGraph, AWS Step Functions, Azure Durable Task and other orchestration systems already provide checkpoints, retries, waits and recovery. The signal is not that one workflow engine has won. It is that agent loops are moving out of ephemeral process memory and into explicit execution histories.
A web page can be readable, searchable and still be difficult for an agent to use safely. The emerging agentic web adds explicit meaning, capability discovery, structured actions, authentication requirements and verifiable outcomes without abandoning the human interface.
Why it is movingThe web is accumulating a new discovery stack for agents. Traditional layers already expose crawl boundaries, URL inventories, semantic markup, forms and API descriptions. Newer work adds llms.txt for curated inference-time navigation, A2A Agent Cards at well-known locations, MCP registry metadata and server capability discovery, and WebMCP tools registered inside an active browser page. These mechanisms are not one standard and they do not solve the same problem. Together they show a shift from agents reverse-engineering pixels and DOM trees toward sites publishing explicit, governed capability contracts.
Evidence confidence95%
Publish capabilities, not hidden clicks49 min read
A model name can survive while its weights, tokenizer, adapter, quantization or serving code changes underneath it. Production teams are starting to treat model identity as a signed artifact graph with verifiable lineage, evaluation and deployment admission.
Why it is movingSoftware-supply-chain controls are moving into machine learning. SLSA defines verifiable provenance and artifact verification. Sigstore and OpenSSF projects now support signing model directories and datasets. OCI registries can attach signatures, attestations and bills of materials to content digests. SPDX and CycloneDX have AI and machine-learning profiles. Hugging Face, MLflow and major cloud registries expose model versions, cards, lineage and approval workflows. The unresolved issue is that many production systems still deploy mutable names, aliases or provider labels without a complete, independently verifiable record of the exact model graph and runtime that produced an output.
Evidence confidence96%
Admit verified artifacts, not model names48 min read
A colorful trace can show that an agent called a model and three tools. It still may not explain why the wrong customer record changed, which policy allowed it, whether the tool committed the action or how the final state was verified. Production observability is moving from activity capture toward evidence that can reconstruct cause and outcome.
Why it is movingAgent frameworks and cloud platforms now expose increasingly detailed traces for model calls, retrieval, tools, handoffs, guardrails, latency, tokens and errors. OpenTelemetry has separated GenAI semantic conventions into a dedicated project and added agent, workflow, tool and evaluation concepts. Google Cloud, AWS and Microsoft are building agent trace views around OpenTelemetry-compatible data, while MLflow, LangSmith, Phoenix and OpenInference connect traces to evaluation and feedback. The important shift is not that more prompts can be logged. It is that teams are beginning to define an evidence contract across runtime identity, software version, model request, retrieved data, tool proposal, authorization, execution, state mutation, user-visible response and authoritative postcondition.
A name, API key or model session does not establish which agent is running, whose authority it carries or whether a specific action is still permitted. Production systems are moving toward attested runtime identity, short-lived credentials, explicit delegation and per-action policy decisions.
Why it is movingIdentity standards and cloud platforms are converging on a clearer model for agentic systems. OpenID Foundation work now addresses agent authentication, MCP tool authorization, approval prerequisites and cross-enterprise identity propagation. SPIFFE and SPIRE provide attested, short-lived workload identities. OAuth token exchange, rich authorization requests, proof-of-possession and transaction tokens provide reusable delegation building blocks. Google Cloud has introduced lifecycle-bound agent identities, while Microsoft, AWS and Kubernetes continue expanding secretless workload identity. The trend is not a special passport for a model. It is the composition of runtime identity, human or organizational delegation, resource policy and evidence for each consequential action.
Evidence confidence97%
Identify the runtime, then authorize the action46 min read
Natural speech is no longer the hard part. Production voice agents must manage transport, turn-taking, tools, identity, recording, payment data, escalation and post-call truth without confusing a convincing voice with a reliable operation.
Why it is movingThe voice-agent stack has moved beyond a single speech model. OpenAI, Google, Amazon and Microsoft now expose persistent bidirectional audio sessions with turn detection and tool use; Twilio and LiveKit connect those sessions to phone networks and real-time media; and current standards already define WebRTC, SIP, RTP, encryption and caller identity. The engineering bottleneck is the operating system around the model: deciding when a turn is complete, what the caller actually heard, which tools may run, when a human must take over, what may be recorded and whether the promised action happened after the call.
Evidence confidence97%
Optimize the whole call, not just the voice45 min read
AI agents can now discover products, assemble carts and reach payment systems. The difficult part is proving exactly what a person authorized, binding that authority to the final order and preventing a valid credential from becoming unlimited spending power.
Why it is movingAgentic commerce has moved from browser demos into protocol and payment infrastructure. Google and the FIDO Alliance are advancing AP2 mandates; UCP and ACP define machine-readable commerce flows; Visa and Mastercard are adding agent recognition, intent and token controls; and Stripe is exposing seller-, amount- and time-scoped payment tokens. The common engineering problem is no longer whether an agent can call checkout. It is how user authority survives across agents, merchants, credential providers, processors and networks without being broadened, replayed or separated from the final order.
JSON Schema, constrained decoding and strict tool calls can eliminate many formatting failures. They make outputs easier to integrate, but they do not prove that the values are true, authorized or safe to execute.
Why it is movingOpenAI, Anthropic and Google now provide schema-constrained responses or strict tool inputs, while vLLM, SGLang, TensorRT-LLM, llama.cpp, Outlines and XGrammar expose structured generation for self-hosted models. The engineering focus is moving beyond “make valid JSON” toward schema compatibility, semantic validation, explicit unknown states, safe tool execution and versioned contracts.
Agents increasingly use Python, shells, containers and disposable workspaces to inspect files and produce artifacts. The model writes the command; the execution system decides what that command can reach and damage.
Why it is movingOpenAI has added hosted shell environments and native sandbox execution to its agent stack, Anthropic exposes persistent Bash and file workspaces, and Google provides iterative Python execution inside Gemini. Coding and terminal benchmarks now treat the runtime, files, dependencies and resource allocation as part of agent capability. At the same time, vendors and infrastructure projects are emphasizing network suppression, disposable environments, microVMs, user-space kernels, resource controls and reproducible images because generated code must be treated as untrusted.
Evidence confidence96%
Powerful execution, hard boundary required42 min read
Larger context windows help, but they do not decide what an agent should remember, retrieve, compress or trust. Long-running reliability increasingly depends on an explicit context-management system.
Why it is movingOpenAI now supports native Responses API compaction and durable agent harness state. Anthropic provides context editing, tool-result clearing, memory files, tool search and compaction for long-running workflows. Google documents million-token contexts, stateful interactions and context caching while warning that multi-needle retrieval and latency still vary with context. Current benchmarks and research continue to show that position, interference, updates, compression and retrieval design affect long-horizon performance.
Evidence confidence95%
Bigger windows still need active context control41 min read
Model quality no longer determines serving quality by itself. Queueing, KV-cache memory, batching, routing, speculation, parallelism and data transfer increasingly decide whether an AI product is fast and economical.
Why it is movingvLLM, SGLang, TensorRT-LLM and NVIDIA Dynamo now expose continuous batching, paged KV memory, prefix reuse, speculative decoding, cache-aware routing and prefill-decode disaggregation as production serving controls. Kubernetes inference routing, distributed KV stores and phase-specific schedulers are moving these decisions above the individual model server. Current documentation and systems research also show that gains depend strongly on prompt length, output length, arrival rate, cache locality, interconnect topology and latency objectives.
Evidence confidence96%
Serving architecture now shapes the product40 min read
Hardware-isolated execution and remote attestation can protect models and data while they are in use. The technology narrows infrastructure trust; it does not make the application, model or output correct.
Why it is movingConfidential CPU VMs are now established across major clouds, while confidential H100 and newer GPU deployments, composite CPU–GPU attestation, Kubernetes confidential containers and policy-bound model-key release are moving into production architectures. NIST’s 2026 draft guidance specifically applies hardware-enabled confidential computing to cloud AI workloads, while current vendor advisories and attack research show that firmware, policy and application assurance remain active requirements.
MCP, A2A and related standards can reduce custom integration work across tools and agents. They standardize communication, not trust, authority or correct business outcomes.
Why it is movingModel Context Protocol has moved into neutral Linux Foundation governance and is supported across major AI and cloud platforms. Agent2Agent has also entered Linux Foundation governance and is appearing in versioned cloud implementations, including A2A 1.0 support in Microsoft Foundry. The remaining production work is concentrated in identity, authorization, registry trust, schema semantics, task lifecycle, policy and end-to-end auditability.
AI systems can increasingly predict future states and generate interactive environments. The useful question is not whether a rollout looks real, but whether actions, uncertainty and task outcomes transfer to the real system.
Why it is movingGoogle DeepMind, Meta and NVIDIA have released increasingly general world-model systems for interactive environments, latent prediction, robot planning and physical-AI data generation. New diagnostic benchmarks are also showing that visual realism can hide failures in action following, object permanence, physical laws and real-task transfer.
Models can now propose hypotheses, select experiments, control instruments and learn from results. Scientific value still depends on calibration, safety, sample identity, uncertainty, provenance and independent replication.
Why it is movingAutonomous laboratories are expanding from narrow optimization demonstrations into systems that connect scientific agents, simulations, robotics, analytical instruments and active learning. Recent work reports closed-loop chemistry, materials, biotechnology, microscopy and beamline experiments, while NIST and research consortia are focusing on interoperability, provenance, safety and reproducibility.
Leaderboards still matter, but production teams increasingly need claim-specific tests, full-system harnesses, calibrated graders, adversarial review, release gates and post-deployment monitoring.
Why it is movingNIST, frontier-model developers, independent safety institutes and benchmark organizations are converging on a broader evaluation discipline. The measured object is shifting from an isolated model answer toward the complete configured system, its harness, safeguards, operating conditions and behavior after deployment.
AI can now operate browsers and desktop software through screenshots, clicks and typing. The capability is useful, but dependable work still requires isolation, verification, narrow authority and human control at consequential steps.
Why it is movingOpenAI, Anthropic and Google now provide or are integrating browser and desktop control into agent products and developer platforms. At the same time, long-horizon benchmarks, security evaluations and vendor guidance continue to show failures in GUI grounding, constraint retention, prompt-injection resistance, efficiency and final-state verification.
Assistants can now carry preferences, project context and prior experience across sessions. The hard engineering problem is deciding what deserves to persist, when it is still true and whether it is safe to reuse.
Why it is movingOpenAI, Google and Microsoft have expanded consumer and workplace memory controls, personalization and memory-source visibility, while Anthropic supports past-chat search, project knowledge and long-running-agent context patterns. Research is shifting from simple factual recall toward updates, forgetting, workflow experience, action use and persistent security failures.
The next AI infrastructure bottleneck is not only accelerators. Grid connections, rack density, cooling, water, utilization, backup power and flexible scheduling now shape what can actually be deployed.
Why it is movingThe IEA says global data-center electricity consumption rose sharply in 2025 and remains on a path to roughly double by 2030 in its central outlook. U.S. projections have widened, FERC is examining large-load interconnection, and data-center standards and infrastructure groups are updating guidance for higher rack densities, liquid cooling and grid integration.
Vision-language-action models can transfer skills across tasks and robot bodies, but dependable physical work still comes from calibrated hardware, bounded jobs, deterministic safety controls and intervention-aware testing.
Why it is movingGoogle DeepMind, NVIDIA, Physical Intelligence, Figure and open research projects are rapidly improving vision-language-action models, cross-embodiment data, on-device inference and simulation benchmarks. The strongest evidence still comes from bounded manipulation tasks and supervised environments rather than unscripted general labor.
Glasses, earbuds, watches and pins promise help without a screen. The viable design is usually always-ready rather than continuously recording: local activation, selective cloud use, visible sensing and a clear plan for battery, privacy and service failure.
Why it is movingMeta reports millions of AI-glasses users, Google has announced Android XR eyewear for 2026, and on-device models are improving. At the same time, bystander-privacy research, failed standalone hardware and cloud dependence show that the form factor is not a solved product category.
One model for every task is giving way to a governed routing layer that balances capability, privacy, latency, capacity, reliability and cost for each request.
Why it is movingAWS, Microsoft and Google now expose automatic model-routing controls, while AI gateways and Kubernetes inference projects are standardizing policy, quota, observability, fallback and load-aware routing across hosted and self-managed models.
Speaking, showing, uploading and pointing are converging into one assistant experience. The interface feels simpler because the engineering underneath has become more complicated.
Why it is movingCurrent APIs now combine text, images, documents, audio, video, streaming speech and tool calls inside one session, while technical documentation increasingly exposes resolution, sampling, synchronization, context and billing controls that used to be hidden behind separate products.
The difficult work is no longer writing a responsible-AI statement. It is finding every real use, classifying the organization’s role, testing the configured system and preserving evidence that still matches production after the next model update.
Why it is movingThe EU AI Act is moving through active application, guidance and enforcement milestones; management-system standards and state or city rules are already asking organizations for inventories, impact assessments, notices, tests, supplier information and auditable decisions.
A convincing voice or video can make an urgent request feel legitimate. The defence is not perfect media detection; it is a payment, identity and approval process that cannot be bypassed by one persuasive interaction.
Why it is movingFBI and FinCEN alerts now describe AI-generated voice, video and identity material inside ordinary impersonation, account-takeover and payment-fraud schemes, while current identity guidance adds controls for forged media and injection attacks.
Coding tools can produce a convincing patch in minutes. The harder work is proving that it solves the right problem, preserves security and architecture, and can be maintained after the model session ends.
Why it is movingCoding assistants and agents are moving from individual autocomplete into repository-wide implementation and review workflows, making branch controls, test independence, sandbox permissions and software provenance part of ordinary development policy.
Downloadable weights give organizations real control over hosting, adaptation and data location. They also move licensing, security, capacity, monitoring and upgrade responsibility inside the organization.
Why it is movingApache-, MIT- and custom-licensed model families now cover local assistants, reasoning, coding, multilingual work and multimodal tasks, while serving, quantization and adapter tooling have become mature enough for governed production use.
Search is becoming a retrieval-and-synthesis system. The convenience is real, but the answer can hide missing evidence, stale sources and disagreement unless the citation layer is engineered carefully.
Why it is movingGoogle, OpenAI and other search products now turn many questions into multi-query retrieval, synthesis and cited follow-up conversations, while publishers are beginning to receive separate visibility controls and reporting for generative search.
The model is no longer the whole product decision. A serving system can answer quickly, reason for longer, sample several solutions, call tools or verify the work—and each choice changes quality, cost and delay.
Why it is movingMajor model families now expose thinking modes, reasoning effort or inference budgets, while research is moving from ‘does more compute help?’ to ‘which tasks deserve it, and how should the result be checked?’
A synthetic clip no longer needs to be flawless. It only needs to look plausible during a quick scroll, arrive with a persuasive caption and spread faster than anyone can verify the source.
Why it is movingVideo generation, precise editing, generated audio and low-cost distribution are improving together, while most verification still begins with a compressed repost rather than the original file.
The office agents worth deploying today have a narrow job, a short tool list and a clear point where a person can step in. They can save real time. They can also make real mistakes, which is why permissions and recovery matter more than the sales demo suggests.
Why it is movingAgent frameworks are easier to assemble, tool connections are becoming more standardized, and realistic office benchmarks now show both the promise and the failure rate.
Local AI has moved beyond the demo stage. A good laptop can now handle useful, tightly defined jobs on its own—provided the model, memory budget and runtime are chosen with care.
Why it is movingThe pieces needed for practical on-device AI—smaller models, quantized formats, mature runtimes and client benchmarks—are finally starting to line up.