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
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
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
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
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 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.
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
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.
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 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.