The current agent architecture is straightforward to describe. A language model receives a system prompt and a context window. It generates text. Tool calls let it read files, run commands, and query external systems. Memory lets it persist state across sessions. A loop lets it take multiple steps. An external orchestrator — a cron, a user message, an event — triggers the next run.

This architecture works. It is debuggable, composable, and extensible. It is also early. The patterns that are standard today — the flat context window, the single-model loop, the file-based memory — are not the architecture's final form. They are where the architecture is right now.

This piece is a map of where the architecture is heading. It covers the trends that are being deployed today, the trends that are in research and early deployment, the trends that are speculative, and the open questions that are genuinely unresolved. The goal is to be useful to someone making architecture decisions today without hyping what is not ready.

The current architecture

The current architecture is language model plus context window plus system prompt plus tool calls plus memory plus external orchestration. Each component has a known job and a known failure mode.

The language model generates text. It is good at reasoning, planning, and text generation. It is bad at persistent state, precise counting, and anything that requires holding information across calls without memory.

The context window holds what the model sees in this call. It is fast and authoritative. It is bounded — a 32k context window holds roughly 24,000 words, and filling it requires careful management.

Tool calls let the model interact with the world. The tool interface is defined by the platform; the model calls tools by name with typed arguments. Tool calls are reliable when the tool is well-defined. They fail in unexpected ways when the tool's interface changes or when the model misinterprets what the tool will do.

Memory is file-based. The agent writes decisions and context to files; future sessions read them. This works and is debuggable. It does not scale well — a memory file that is unreadable is as bad as no memory.

The external orchestrator triggers runs. A cron fires at 5am. A user sends a message. A webhook arrives. The orchestrator is outside the agent's loop — it starts the loop, not part of it.

The piece on what is an LLM covers the model layer. The piece on inside the agent loop covers the current loop structure.

The trend: longer context

Context windows have grown dramatically. A 4k context was standard three years ago. 32k was a premium feature. 128k is common today. Several providers offer experimental 1M-token contexts.

Longer context enables new agent patterns. A research agent can read a hundred documents in a single call instead of summarizing each one separately. A coding agent can hold an entire codebase in context instead of reading files one at a time. A conversation agent can reference a long history without summarization.

Longer context does not solve every problem. The model still has to attend to the right part of the context — a 1M-token context full of irrelevant text is harder to use than a 32k context with the right information. Longer context is also more expensive. Most providers charge per token, and a 1M-token input costs significantly more than a 32k input.

The open question is whether context length will keep scaling at the rate of the last three years. The hardware requirements for serving very large contexts are substantial. Whether the economics support 10M-token contexts as a standard feature, rather than a premium offering, is not yet settled.

The trend: multi-modal

Multi-modal models see, hear, and generate across modalities. A model that can process an image as input can answer questions about a diagram, a photograph, or a UI screenshot. A model that can generate audio can produce voice responses. A model that can generate images can produce diagrams and illustrations on demand.

For agents, multi-modality expands the perception pipeline. A coding agent that reads a UI screenshot sees what the user sees. A physical agent that processes camera images directly needs no separate perception system.

The limitations are real. Multi-modal understanding is not the same as visual reasoning in humans. A model that can describe what is in an image may not catch subtle inconsistencies in a diagram. A model that can generate images may generate ones that look plausible but are technically wrong. Multi-modality is expanding rapidly, but it has not closed the gap with human perception.

The trend: graph-based memory

The current memory architecture is mostly flat files — a MEMORY.md, project notes, session logs. Graph-based memory represents facts as nodes in a graph and relations as typed edges. Queries become traversals: "what projects is this person working on?" becomes a one-hop traversal from the person node to the project nodes.

The shift from flat files to graphs changes what queries are cheap. A flat file memory requires reading everything or running semantic search. A graph memory allows precise traversal along known relations. "Find all decisions made in sessions about project X" is a graph query. "Find all sessions that mentioned project X" is a semantic search. Both are useful; they answer different questions.

The graph-based memory glossary entry covers the current state. The knowledge graphs piece covers the primitive. The limits are graph quality — a graph with stale or missing edges gives wrong answers — and traversal cost. Graph queries that require many hops are expensive and can return irrelevant results.

The trend: smaller specialist models

The current trend is toward larger, more capable models for everything. The counter-trend is smaller specialist models that do one thing well at lower cost and lower latency.

The architecture is changing from "one large model for all tasks" to "a large model as orchestrator plus small specialist models for specific capabilities." A triage agent that routes requests to specialized sub-agents. A small fast model for real-time control. A specialized code model for code generation. A small language model for simple extraction tasks.

The economics are compelling. A 7B-parameter model inference costs roughly 10x less than a 70B-parameter model. For tasks that a small model handles correctly, the cost saving is real. The complexity is orchestration — deciding which model handles which request, managing the consistency of outputs across models, and evaluating whether a small model is actually good enough for the task.

The unknown is whether small models will continue to close the gap with large models on agent tasks specifically. Small models are competitive on well-defined tasks. They are less reliable on tasks that require multi-step reasoning or that have edge cases the training distribution does not cover well.

The trend: agent-to-agent standards

Every agent platform has its own tool interface, its own memory format, and its own orchestration model. An integration written for one platform does not work on another without rewriting.

MCP (Model Context Protocol) is the most visible attempt to define a common interface. MCP defines how a client connects to a server that exposes tools, resources, and prompt templates. A tool written to the MCP spec works with any MCP-speaking client.

The MCP glossary entry covers the protocol in detail. The open questions are not technical — the protocol is defined and adoption is growing. The open questions are about market structure: who runs the routing, who pays for inference when agents call each other, and who owns the data that passes between them.

The speculative question is whether agent-to-agent protocols will converge the way HTTP standardized web communication, or whether the market will sustain multiple competing standards with translation layers between them.

The trend: shared cognition

Current agents are mostly solo. One agent, one context, one goal. Shared cognition is the case where multiple agents share a working memory and a goal — they reason together rather than independently.

The architecture is a multi-agent system with shared state. Multiple agents read from and write to a shared memory layer. They work on parts of a problem simultaneously. They can see each other's intermediate results and build on them.

The piece on multi-agent orchestration covers the current patterns. The open questions are not about the architecture — the architecture is straightforward. The open questions are about behavior: how do agents resolve disagreements? how do they negotiate when they have conflicting partial views of the goal? how do they audit each other's reasoning?

These are social and organizational questions more than technical ones. They are the same questions that arise in any team of humans working together, translated into an agent context.

What is speculative

Popular writing about AI often treats whole-brain emulation, artificial general intelligence, and sentient agents as if they are on the near-term roadmap. They are not.

Whole-brain emulation requires scientific advances that have not happened — a complete map of the human connectome and the computational infrastructure to simulate it at speed. This is a research program measured in decades, not years. AGI is not a technical milestone with a clear definition; systems that appear to show AGI characteristics in benchmarks often fail on tasks humans find trivial. Sentient agents are not something current AI systems demonstrably are; the question of machine consciousness is not settled science.

The roadmap is what is being deployed in production today and in the next 12 to 24 months.

What remains unknown

Five things that are genuinely open:

Whether context length will continue to scale economically. The hardware requirements for very large contexts are substantial, and the economic model for 1M-token contexts in production has not been established.

Whether smaller specialist models will beat larger generalist models on the full range of agent tasks. They are winning on cost and latency. Whether they will win on reliability across edge cases is still being determined.

Whether agent-to-agent standards will converge. MCP is the current front-runner but the market may converge, fragment, or sustain translation layers between incompatible standards.

Whether the safety frameworks that work for software agents will scale to physical agents. The reversibility of software mistakes does not extend to physical mistakes; the governance frameworks for physical AI are early and incomplete.

Whether the evaluation methods that work for software agents will transfer to physical agents. An eval suite that runs in minutes is not available for a system that drives a car. The problem is open.

What this is not

This piece is not a prediction. The trends described here are real, but their trajectories are not determined. A trend that looks inevitable at the research stage sometimes stalls at the engineering stage.

This piece is not a recommendation to wait. The current architecture works for production workloads today. The trends are reasons to build with modularity — to design memory, tools, and orchestration so components can be swapped as the architecture evolves. They are not reasons to stop building.

This piece is not a comprehensive survey. There are hundreds of active research directions; this covers the ones most likely to affect how agents are built and operated in the near term.

See also