Research Frontiers

The agent environment in 2026 would be largely unrecognisable to someone who last examined it in 2022. Reasoning models spend variable compute on hard problems. Computer use agents navigate real graphical user interfaces. Agentic coding tools write and debug entire features autonomously across multiple files. The A2A (Agent-to-Agent) protocol published by Google in early 2025 enables agents from different organisations to delegate tasks to each other directly.

Understanding where research is heading is not academic for practitioners. The capabilities demonstrated in research papers and limited beta programmes today typically become production tools within 12 to 18 months. Designing your agent architecture without awareness of incoming capabilities means you may build expensive bespoke solutions to problems that will be solved by a model API parameter in six months.

The principle for production architects: design for today's reliable capabilities and build extension points for tomorrow's. Do not bet your production architecture on pre-release features. Do read the research to know which extension points are worth building.

Standard LLMs generate an answer in a single forward pass through the network. Reasoning models generate an extended internal chain of thought before producing their final answer. This thinking is usually visible to the developer as a separate block in the API response. The model explores multiple approaches, identifies errors in its own reasoning, backtracks, and revises before committing to a final answer. Psychologist Daniel Kahneman's dual-process model describes this as the difference between System 1 thinking (fast, automatic, associative) and System 2 thinking (slow, deliberate, effortful). Standard LLMs are System 1. Reasoning models implement a form of System 2.

In practice, extended thinking significantly outperforms standard mode on tasks involving multi-step mathematical proofs, debugging complex code, architectural trade-off analysis, and scientific reasoning. It shows little benefit over standard mode for factual question answering, simple summarisation, translation, or conversational responses, where the answer does not require extended deliberation.

The cost is real: a 10,000-token thinking budget can cost three to five times more than a standard response and take 30 to 60 seconds. For a customer support agent handling 10,000 queries per day with simple questions, enabling extended thinking on every request would increase costs and latency substantially for no quality improvement. Reserve extended thinking for the subset of tasks where accuracy genuinely matters more than speed and cost.

Claude's extended thinking is enabled by passing a thinking parameter to the messages API with a budget_tokens value between 1,024 and 100,000. The budget sets the maximum tokens the model may use for its internal reasoning. A higher budget allows more deliberation on harder problems; it does not guarantee better answers on simple ones.

The API response contains two types of content blocks: thinking blocks (the internal reasoning, with type: "thinking") and text blocks (the final answer, with type: "text"). In most applications you display only the text block to end users. The thinking block is available for debugging and for cases where showing reasoning increases user trust, such as medical decision support or legal analysis tools.

Set max_tokens to the thinking budget plus at least 2,048 additional tokens for the final response. If you set max_tokens equal to the thinking budget, the model may exhaust its token allowance on thinking and produce no final answer. A common mistake is forgetting that the thinking tokens count towards the total output token cost.

Modern frontier models process images and documents alongside text. For agents, this opens workflows that were previously impossible without specialised computer vision pipelines. A document processing agent can read a scanned invoice, extract line items, and populate a database record. A monitoring agent can analyse a dashboard screenshot and identify anomalies. A quality assurance agent can compare a UI mockup against a rendered screenshot and report discrepancies.

As of early 2026, image understanding and PDF processing are production-ready across the major frontier models. Video understanding is emerging: some models can analyse short video clips, but reliability and cost at scale remain limiting factors for most production use cases. Audio transcription is typically handled via a separate specialised model (such as OpenAI Whisper) rather than within the main LLM call.

The practical pattern for multimodal agents is to pass images as base64-encoded data in the messages array, with a media_type declaration. Keep images as small as practical while retaining the relevant detail: a 1080p screenshot of a dashboard adds significant tokens; a cropped 400x300 region containing the relevant chart achieves the same analysis at far lower cost. For document analysis, PDF files can be passed directly on models that support native PDF input, avoiding the need for separate OCR (Optical Character Recognition) pre-processing.

Computer use is the ability of an AI agent to interact directly with a computer interface: web browser, desktop application, or file manager. The agent sees the screen as an image, decides what action to take (click, type, scroll, press a key), and the system executes that action. The agent does not use an API or structured integration with the application. It uses the same visual interface a human would.

Anthropic demonstrated computer use with Claude in October 2024. OpenAI Operator and Google's Project Mariner followed with similar capabilities. As of early 2026, computer use is available in beta and is increasingly reliable for structured, repetitive tasks on stable UIs, such as filling in standardised forms or extracting data from a web page that lacks an API.

Current limitations are significant and must inform any production use decision. Error rate increases substantially on complex UIs with many interactive elements, modal dialogues, or dynamic content that changes between screenshots. Latency is high: each action requires a screenshot, LLM inference, and action execution, which typically takes two to five seconds per step. Security boundaries are unclear: an agent with computer use can access any file or application visible on the screen. Any credential visible on screen is accessible to the agent, which requires strict sandboxing. Determinism is low: the same instruction may produce different action sequences across runs.

Agentic coding tools are AI agents with access to a file system, terminal, test runner, and search tools. They operate over multiple files and iterate based on test results, making them qualitatively different from single-response code generation. Examples include Claude Code (Anthropic), GitHub Copilot Workspace, and Cursor Agent.

A traditional LLM code generation interaction looks like: you describe what you want, the model produces code in a single response, you copy it, test it, and iterate. An agentic coding interaction looks like: you describe a feature, the agent reads the existing codebase, writes the implementation across multiple files, runs the tests, fixes the failures, and reports when the tests pass. The agent iterates autonomously on the feedback loop that was previously the developer's job.

Agentic coding is already production-ready for well-defined, testable tasks: adding a new API endpoint, writing tests for existing functions, refactoring a module to a new pattern. It is less reliable for tasks requiring architectural judgment, deep understanding of existing system behaviour, or tasks where the definition of success is ambiguous. The practical guideline: use agentic coding tools for tasks where you can write a clear definition of done and verify the result programmatically.

Three research directions are most likely to change production agent architectures in the near term. The first is the A2A (Agent-to-Agent) protocol, published by Google in early 2025 as an open standard for agents from different organisations and providers to communicate. As MCP (Model Context Protocol) standardised tool interfaces, A2A standardises how agents delegate tasks to other agents. Early adopters include enterprise software vendors building interoperable ecosystems where, for example, a procurement agent can negotiate directly with a supply chain agent at another company.

The second direction is long-horizon task completion. Current agents reliably handle tasks requiring five to twenty steps. Research in 2025 and 2026 is targeting 100 to 1,000-step tasks with persistent state across sessions. The key technical challenges are reliable error recovery after many successful steps, context management across very long tasks, and cost control at extended scale. When these are solved, the class of tasks that can be safely delegated to agents expands significantly.

The third direction is constitutional agents and reinforcement learning from AI feedback (RLAIF). Research at Anthropic, Google DeepMind, and OpenAI is exploring agents that evaluate and improve their own behaviour against a specified set of principles, without requiring human labelling of every training example. This connects to Constitutional AI and has implications for how agent behaviour is aligned with organisational policies at scale.