There was a time, not very long ago, when getting help from the internet mostly meant learning how to find the right human answer. If I encountered a programming problem, the instinctive workflow was to search Google, open several Stack Overflow threads, compare different answers, check documentation, inspect GitHub issues, and sometimes continue the investigation on Reddit when the problem was too subjective or obscure for a conventional Q&A site. Students had their own version of the same behavior through platforms such as Brainly, while countless communities existed for everything from troubleshooting hardware to understanding mathematics. The internet already contained an extraordinary amount of knowledge, but accessing that knowledge usually meant discovering where somebody else had already written the answer and then adapting it to the problem in front of you.
Artificial intelligence obviously did not begin in 2022. Transformers had already existed for years, large language models were advancing quickly, GPT-3 had demonstrated remarkable few-shot capabilities, GitHub Copilot had introduced generative coding assistance, and retrieval-augmented generation had already appeared in research. What changed near the end of 2022 was not the existence of the underlying technology, but the way an enormous number of ordinary people encountered it. When OpenAI released ChatGPT on November 30, 2022, the interface was simple enough that almost anyone could understand its value immediately. Instead of searching for a page and trying to reconstruct an answer from fragments written by other people, users could describe a problem directly, ask follow-up questions, request clarification, challenge the response, change the level of explanation, and continue the conversation without starting the information search again from zero.
The behavioral shift that followed was much larger than a new website becoming popular. For many kinds of questions, the first instinct gradually moved from finding a page to asking a model. Developers who previously searched for an exact Stack Overflow question could paste an error into an AI assistant and ask what was wrong with their specific code. Students could ask for an explanation adapted to their level instead of hoping an existing answer happened to match what they needed. Writers could ask for revisions rather than searching for general writing advice, and people learning unfamiliar technologies could continue asking questions even when they did not yet know the vocabulary required to formulate a good search query.
That period marked the beginning of the modern AI boom as most people experienced it, but what happened afterward was far more significant than the original chatbot moment. In less than four years, we moved from systems that primarily generated text to systems that can reason across modalities, browse the web, execute code, manipulate files, call external tools, interact with software interfaces, retrieve private and current information, maintain useful state across sessions, delegate tasks to other agents, and continue working for far longer than a single conversation. The remarkable part is not one benchmark, one model release, or one company winning a particular month. It is how quickly the abstraction changed from asking AI for an answer to delegating an outcome to a system that can increasingly participate in the work required to produce it.
2022 Changed the Default Interface to Knowledge
Before conversational generative AI became mainstream, search engines were effectively routers for human knowledge. A search query rarely solved a problem by itself. It helped locate a document, forum discussion, video, documentation page, academic paper, or community answer where another person had already explained something relevant. The quality of the result depended partly on the quality of the information available, but it also depended heavily on the user's ability to formulate the correct query, distinguish trustworthy sources from weak ones, combine fragmented explanations, and adapt generic information to a specific situation.
Developer culture made this especially visible. Stack Overflow became one of the defining knowledge infrastructures of modern programming because millions of developers could search for an error and discover that somebody else had already encountered something similar. Reddit filled another role by capturing opinions, edge cases, recommendations, debates, and experiences that did not fit cleanly into formal question-and-answer formats. Documentation remained the authoritative source for many technologies, but documentation often assumed that the reader already understood what to look for. A surprisingly important technical skill was therefore not simply knowing how to program, but knowing how to navigate the distributed memory of other programmers.
Conversational AI compressed several stages of that workflow into a single interaction. Instead of searching for the right page, reading multiple answers, reconstructing the surrounding context, and manually adapting the information, users could describe the actual situation and request an explanation shaped around it. The model could simplify an answer, expand it, translate it, generate an example, compare alternatives, explain an error message, or change its teaching style without forcing the user to restart the search process. The information experience moved from retrieval-first toward interpretation-first, with the model increasingly becoming the layer that translated a messy problem into something understandable.
This did not eliminate the reliability problem. Early generative systems could confidently produce incorrect information, invent references, misunderstand technical details, and generate plausible code that failed when executed. OpenAI documented significant limitations in the original ChatGPT release, including plausible but incorrect answers and sensitivity to phrasing. The revolutionary part was therefore not that a perfect replacement for human knowledge had appeared. The change was that generative AI introduced a new way to access, manipulate, and interact with information that felt dramatically more flexible than traditional search.
The effect on existing knowledge ecosystems appeared quickly. Similarweb reported substantial declines in Stack Overflow traffic during the early generative AI period, although the decline had begun before ChatGPT and cannot reasonably be attributed to a single cause. Even so, the broader direction was difficult to miss. Developers were increasingly obtaining initial coding assistance from AI systems rather than beginning every problem in a traditional message board, while educational platforms such as Brainly began integrating AI-powered tutoring and answer generation into their own products. Search engines, forums, documentation, and human communities did not disappear, but their position in the workflow began changing as AI increasingly became the first interpreter of the problem and traditional sources became places to verify, deepen, or correct what the model produced.
2023 Turned the Model Into a Software Component
The first wave of conversational AI was compelling precisely because the interaction was simple. Text went in and text came back. During 2023, however, the industry rapidly discovered that a language model became substantially more useful when it could connect to systems outside its static training data. The model did not need to remain a destination where prompts ended. It could become an active component inside a larger software architecture.
GPT-4 arrived in March 2023 as a multimodal model capable of accepting both text and image inputs, demonstrating that the interface to a large language model did not need to remain purely linguistic. Only days later, OpenAI introduced experimental ChatGPT plugins designed to give models access to current information, computational capabilities, web browsing, and third-party services. Code Interpreter pushed the idea even further by allowing ChatGPT to actually execute Python against uploaded files, analyze datasets, generate charts, transform documents, and perform computational work rather than merely describing how a human could do those things manually.
The more important architectural change for developers came through function calling. OpenAI's June 2023 API update allowed models to receive descriptions of functions and generate structured arguments for calling them. Compared with modern agent systems, function calling can look almost primitive, but it fundamentally changed the role of the model inside an application. An LLM no longer needed to be treated only as a text generator at the end of a pipeline. It could interpret natural-language intent, determine which external capability was relevant, construct structured parameters, receive the result of the operation, and continue reasoning from that result.
A user could ask for the weather without knowing anything about the underlying weather API. The model could determine that an external tool was necessary, construct the required arguments, receive the returned data, and translate it into a useful answer. The same pattern could be applied to databases, calendars, payment systems, search engines, enterprise services, internal APIs, or almost any capability software could expose programmatically. This was one of the foundational transitions from a chatbot that generated information toward a system capable of selecting actions.
Retrieval became another major part of the emerging stack. Retrieval-augmented generation itself predated the generative AI boom, with Meta researchers describing the architecture in 2020 as a method for combining generation with external retrieval. After generative AI applications exploded in popularity, RAG became central to production systems because companies immediately encountered a limitation that larger models alone could not solve. Models did not automatically know private company documents, new information created after training, internal databases, or the constantly changing state of a business. Retrieval pipelines offered a practical way to locate relevant information and inject it into the model's working context at inference time.
By the end of 2023, applied AI engineering had already expanded far beyond writing clever prompts. Developers were discussing embeddings, vector databases, retrieval quality, chunking strategies, function schemas, structured outputs, tool selection, model routing, application state, and the reliability of increasingly complex AI pipelines. In approximately one year, the model had moved from being treated as the application itself to becoming one component inside a much larger application architecture.
2024 Expanded What AI Could Perceive and Operate
If 2023 was the year language models started connecting to external systems, 2024 was when the boundaries around the model itself began expanding aggressively. Context windows became dramatically larger, multimodal interaction became substantially more natural, inference-time reasoning became a major capability, and public demonstrations of computer-using agents showed that AI systems could begin interacting with software originally designed for humans rather than only with clean developer APIs.
Google's Gemini 1.5 was one of the clearest signals of how quickly context capacity was changing. In February 2024, Google announced Gemini 1.5 Pro with a standard 128,000-token context window and experimental support for up to one million tokens, allowing a single interaction to process quantities of text, code, audio, and video that would have been impractical for mainstream systems only a short time earlier. Larger context windows did not solve every information-management problem, but they dramatically increased the size of the working environment models could reason over and made repositories, long documents, transcripts, and multimodal archives more practical as direct model inputs.
In May, OpenAI introduced GPT-4o as an omni model designed around more natural interaction across text, audio, images, and video. The model represented an important transition away from interfaces where different modalities felt like separate features bolted onto a text model. Increasingly, AI systems could perceive the kinds of mixed information humans naturally move between while solving a task, such as looking at an image, listening to audio, reading text, and responding conversationally without treating every modality as a completely separate product.
The next major change came from reasoning. In September 2024, OpenAI introduced the o1 series, explicitly designed to spend additional computation reasoning through difficult problems before answering. This helped establish inference-time reasoning as a major axis of model development. Developers increasingly had to think not only about which model to call, but also about how much reasoning effort a task deserved, how long an answer could take, how much additional computation improved reliability, and whether the cost of deeper reasoning was justified by the problem.
Only a month later, Anthropic introduced computer use in public beta for Claude 3.5 Sonnet. Developers could direct the model to inspect a computer screen, move a cursor, click interface elements, and type into applications. This was conceptually different from function calling because APIs provide clean machine-readable interfaces designed specifically for software, while computer use allows an agent to interact with existing interfaces designed for humans. If a model could understand a task, perceive the interface, and operate a mouse and keyboard, then a huge amount of existing software became potentially accessible without waiting for every product to expose a dedicated AI API.
The final months of 2024 made the direction even clearer. Anthropic introduced the Model Context Protocol as an open standard for connecting AI systems with external data sources and tools, reducing the need for every integration to become a completely custom implementation. Google introduced Gemini 2.0 while explicitly describing the transition toward an agentic era, highlighting native tool use and experimental systems such as Project Mariner for operating inside Chrome and Jules for software development. The conversation had moved far beyond asking what a model could say. Developers were increasingly asking what the model could perceive, how long it could reason, which tools it could discover, what external systems it could access, and which actions it could safely perform.
2025 Was When Coding Agents Became Real Development Environments
Software development became one of the clearest demonstrations of the next transition because programming gives agents something unusually valuable: an environment in which actions can be executed, tested, and evaluated. Source code can be inspected, commands can be run, tests can fail, error messages can be read, patches can be applied, and the agent can observe whether its own actions improved or damaged the system. This creates a feedback loop that is much richer than simply generating code in response to a prompt.
In February 2025, Anthropic released Claude Code as a research preview alongside Claude 3.7 Sonnet. Unlike editor autocomplete systems that primarily predicted code near the cursor, Claude Code was presented as a command-line agent capable of receiving larger engineering tasks and operating directly inside a development environment. Anthropic later published detailed guidance for agentic coding workflows in which the agent explored repositories, planned modifications, implemented features, ran tests, inspected failures, and used external tools as part of the same task.
OpenAI moved in a similar direction. In March 2025, the company introduced the Responses API together with built-in web search, file search, computer-use tooling, and an Agents SDK intended for orchestrating single-agent and multi-agent workflows. Two months later, OpenAI introduced Codex as a cloud-based software engineering agent capable of working on multiple tasks in parallel, each inside an isolated environment containing the relevant repository. The agent could implement features, investigate codebases, fix bugs, run validation, and prepare changes for human review.
The important change was not that AI had suddenly learned how to write code. Language models had been generating code for years. What changed was the unit of delegation. Instead of asking for an individual function or snippet, developers increasingly began assigning tasks such as investigating a bug, understanding the failure, implementing the fix, running tests, and preparing the patch. The agent became responsible for a larger portion of the path between intent and outcome.
This changed the role of the human developer as well. The developer increasingly moved upward from implementing every detail toward defining intent, specifying architecture, providing constraints, reviewing outcomes, challenging incorrect assumptions, and deciding when the agent had completed the task satisfactorily. Coding remained a technical discipline, but the distribution of effort shifted from producing every line manually toward orchestrating increasingly capable execution systems.
The open model ecosystem accelerated during the same period. DeepSeek released R1 in January 2025 together with openly available reasoning-focused models and distilled variants, demonstrating that advanced reasoning capabilities would not remain confined to one proprietary provider. The competitive environment was no longer merely producing better chatbots. It was producing increasingly interchangeable reasoning engines that could be embedded inside larger agent runtimes, coding environments, research systems, and automation platforms.
By this point, asking which model was best was becoming an incomplete question because the surrounding architecture increasingly mattered almost as much as the model itself.
The Engineering Problem Moved Outside the Model
One of the most important conceptual changes between the original chatbot era and modern agent systems is that developers gradually discovered how many failures occur outside the model. An agent needs good instructions, but it also needs the right files, relevant history, useful tool definitions, current application state, retrieved documents, memory, previous observations, and information generated during its own execution. Give it too little context and it operates blindly. Give it too much and the useful information becomes buried beneath noise.
Tool design introduced another layer of complexity. Tools need names the model can understand, schemas that encourage correct usage, outputs that contain enough information without overwhelming the context window, and permission boundaries appropriate to the consequences of the action. Terminal output may need to be summarized or compressed. Long-running work needs state that can survive context boundaries. Failed actions need recovery strategies. Dangerous actions may require explicit approval. Agent behavior needs tracing because evaluating the final answer alone no longer reveals what actually happened during execution.
This is why the conversation gradually moved from prompt engineering toward context engineering. Anthropic described context engineering as the process of curating and maintaining the optimal information available to a model during inference. In an agent system, that information can include system instructions, conversation history, retrieved documents, tool schemas, application state, memory, previous tool results, MCP resources, and information generated by the agent throughout its own work. A better prompt cannot compensate for an environment filled with irrelevant files, stale memories, poorly designed tools, or hundreds of thousands of tokens of unnecessary output.
The next abstraction was the agent harness, meaning the surrounding software architecture that determines how a model actually operates over time. A harness can determine how tasks are decomposed, which tools become visible, when context is compacted, how state persists, what happens after a failed command, how work is delegated, how outputs are evaluated, and what information survives between sessions. By late 2025 and into 2026, research and production engineering increasingly focused on these surrounding structures because highly capable models could still behave dramatically differently depending on the harness in which they operated.
The original applied-AI problem was often framed as asking the model correctly. The modern problem increasingly looks like designing an information and execution environment in which a model can operate reliably. Prompt engineering still matters, but it has become one component inside a much larger systems engineering discipline that includes context management, tool design, orchestration, observability, evaluation, permissions, memory, and long-running state.
Agents Turned Answers Into Actions
The term AI agent has become broad enough that it can describe everything from a chatbot calling one API to a system operating independently for hours. The useful distinction is not the label itself, but the execution loop. In a conventional chatbot interaction, the model generates a response and the user decides what to do with it. In an agentic system, the model can receive an observation, decide what action should happen next, invoke a tool, inspect the consequence, revise its understanding, and continue until the broader task reaches an acceptable state.
That loop changes what intelligence means inside software. A language model can explain why a deployment might be broken, but an agent connected to the relevant infrastructure can potentially inspect the deployment, read logs, identify a failed process, modify configuration, restart a service, test the endpoint, and report what changed. A model can explain how to perform research, but a research agent can search multiple sources, follow references, compare contradictory information, retrieve supporting evidence, and produce a synthesis grounded in what it actually found. A model can draft an email, while an agent connected to a communication system can inspect the relevant thread, understand prior context, prepare a response, and potentially deliver it after the appropriate approval.
This is why tool access became so important. Reasoning without action produces recommendations, while reasoning connected to tools can produce consequences. MCP helped standardize part of this transition by giving agents a common mechanism for discovering and interacting with external capabilities. OpenAI expanded its agent infrastructure around web search, file search, computer use, background execution, and orchestration. Anthropic developed its own tool ecosystem, MCP integrations, coding environments, and multi-agent research patterns. Google pursued browser-operating systems, development agents, and broader agentic product experiences. The architectures differed, but the direction was remarkably consistent: AI systems were moving from producing information about work toward participating in the workflows where work actually happened.
My Own Workflow Mirrors the Broader Transition
The change becomes easier to understand when I compare the industry timeline with the way my own behavior evolved during the same period. Before generative AI became the first place I asked technical questions, my programming workflow looked much more like the traditional internet workflow. A problem often started with Google and eventually led to Stack Overflow, Reddit, documentation, GitHub issues, or another developer who had encountered something similar. The skill was discovering the correct source and reconstructing the answer from whatever fragments were available.
Conversational AI changed the first stage. Instead of beginning every idea with search, I increasingly began with conversation. AI became a brainstorming layer where an incomplete thought could be expanded, challenged, reorganized, compared against alternatives, and transformed into something concrete enough to build.
01 /Think IdeaBrainstorming with ChatGPT02 /Build VS Code & TerminalCoding Agent03 /Ship RepositoryDeploy
Coding agents changed the implementation stage. Instead of asking AI only how I should write something, I could give an agent access to the repository and ask it to inspect the project, implement features, run tests, debug failures, and revise actual code. The editor remained important, but my role increasingly moved toward specification, architectural decision-making, evaluation, and review rather than manually producing every implementation detail.
By 2026, the workflow had moved another layer outward. I now run Hermes Agent continuously on a VPS and use Telegram as my primary interface, although Telegram itself is only one gateway through which the persistent agent can be reached. Hermes can operate across terminal and filesystem tools, browser environments, memory, reusable skills, MCP integrations, scheduled execution, subagents, and multiple messaging platforms, which means the agent exists independently of the device I happen to be using at a particular moment.
That changes when work can begin. An idea does not necessarily need to wait until I open my primary computer, reconstruct the development environment, or manually initialize a repository. I can describe what I want remotely, provide a detailed specification when the project requires one, let the agent execute inside its own environment, review the implementation, request revisions, and eventually discover that a working repository already exists before I have personally opened an editor.
ArchRouter is the clearest example. I designed the idea, requirements, architecture, constraints, and review direction, while Hermes executed the implementation from zero and iterated based on my feedback until the project became a functioning repository. ArchRouter itself is a headless control, automation, and lifecycle management layer for 9Router and Hermes Agent, which gives the project an interesting recursive quality because I used Hermes to implement infrastructure that extends the environment around Hermes itself.
The progression in my own workflow therefore mirrors the broader evolution of the industry. The path moved from searching for an answer, to asking a model, to giving the model tools, to giving the agent an execution environment, and finally to delegating larger outcomes rather than individual steps.
- Search for an answerFind existing human knowledge
- Ask a modelGenerate a tailored response
- Give the model toolsConnect reasoning to software
- Give the agent an environmentLet actions produce feedback
- Delegate the outcomeDescribe intent instead of every step
That entire transformation happened within a period short enough that many of the habits from the beginning of the AI boom still feel recent.
The Pace Matters More Than Any Individual Model
Technology usually evolves slowly enough that users have time to normalize one abstraction before the next becomes important. The modern web matured over decades. Smartphones reorganized consumer computing over many years. Cloud infrastructure changed how software was deployed through a migration that is still continuing. Generative AI has felt different because the dominant abstraction has repeatedly shifted within intervals measured in months rather than decades.
At the end of 2022, simply maintaining a convincing conversation with an AI system was enough to feel transformative. During 2023, tool calling and retrieval became central application patterns. In 2024, long context, multimodality, reasoning models, computer use, and MCP broadened what AI systems could perceive and interact with. In 2025, coding agents, agent SDKs, cloud sandboxes, multi-agent workflows, and increasingly sophisticated reasoning systems made task-level delegation practical. By 2026, the engineering frontier increasingly revolves around context engineering, agent harnesses, persistent memory, skills, long-running execution, observability, evals, permission systems, subagents, and decisions about how much authority an agent should receive.
The expectation baseline moved just as quickly. In late 2022, receiving a coherent explanation from a language model felt extraordinary. Today, developers can become frustrated because an agent failed to understand an entire repository, forgot a previous decision, selected the wrong tool, stopped before running the tests, failed to recover from a terminal error, or lost state after operating across several sessions. Capabilities that once looked futuristic become invisible surprisingly quickly once they enter the baseline.
This expectation inflation makes it easy to underestimate how unusual the underlying progress has been. Comparing today's frontier model with the previous month's frontier model can make progress look incremental, especially when the differences appear as benchmark points, pricing changes, latency improvements, or slightly better task completion. The longer historical comparison tells a different story. The interaction model of 2026 is fundamentally different from the interaction model that felt revolutionary in November 2022, even though less than four years separate them.
AI Is Changing More Than Software
Developers naturally experience the AI boom through code because software development has become one of the most visible laboratories for agentic systems, but the underlying transformation is much broader. Search is changing because users increasingly expect synthesized answers rather than only lists of links. Education is changing because students can request explanations adapted to their level, ask unlimited follow-up questions, generate practice material, and receive interactive guidance without waiting for another person to respond. Writing is changing because drafting, editing, rewriting, translation, summarization, ideation, and research can all happen through the same conversational interface.
Research workflows are changing because AI systems can search, extract, compare, classify, and synthesize information across sources at a scale that would previously have required far more manual effort. Customer support is changing because models can reason across long interaction histories, retrieve documentation, interact with business systems, and increasingly perform actions instead of only generating responses. Office work is changing because an AI connected to documents, spreadsheets, email, calendars, project-management systems, databases, and internal knowledge bases is fundamentally different from a chatbot that only answers generic questions.
Creative work is undergoing a similarly rapid transformation. Image generation, video generation, speech synthesis, music systems, multimodal editing tools, and AI-assisted design are reducing the distance between an idea and a usable artifact. This does not eliminate expertise, because producing an artifact and producing a good artifact are different problems. As generation becomes cheaper, skills such as taste, judgment, direction, evaluation, curation, and understanding the intended audience often become more important rather than less important.
The same pattern appears repeatedly across disciplines. AI reduces the cost of producing an initial result, and as that cost declines, human value increasingly moves toward deciding what should be produced, whether the result is correct, whether it is useful, and what consequences follow from using it. AI has not transformed every profession equally, nor has it replaced every existing workflow, but it is increasingly touching the interface through which knowledge work, communication, creativity, software, research, analysis, automation, and decision support happen.
That is why saying AI is changing almost everything does not feel like empty exaggeration. The important point is not that every activity has been replaced by AI, but that AI is rapidly becoming a general-purpose layer through which an enormous range of activities can be interpreted, accelerated, automated, or delegated.
AI Usage Grew Faster Than Trust
Rapid capability growth does not mean reliability improved at the same pace. Stack Overflow's 2025 Developer Survey illustrates the contradiction clearly. The survey found that 84 percent of respondents were already using or planning to use AI tools in their development process, while 51 percent of professional developers reported using AI tools daily. At the same time, trust in AI-generated output was declining, with a substantial portion of developers reporting that they distrusted the accuracy of the systems they were nevertheless using regularly.
The contradiction becomes even more interesting when agents enter the picture. Developers express serious concerns about agent accuracy, privacy, and security, while many of the same users report meaningful productivity gains from agentic tools. That tension is probably one of the most accurate descriptions of the current state of AI adoption. The systems are useful enough that people continue incorporating them into real work even when they do not completely trust the outputs.
This is fundamentally different from deterministic software. When a compiler processes the same source under the same environment, developers expect reproducible behavior. An agent can take different paths across repeated runs, select different tools, interpret an ambiguous instruction differently, or arrive at the correct answer through an unexpected sequence of operations. Evaluation therefore becomes more complicated than checking whether the final paragraph sounds convincing or whether one benchmark score increased.
Modern agent systems increasingly require outcome-based evaluations, transcript inspection, environment checks, regression suites, security boundaries, and visibility into the sequence of actions that produced the result. Autonomy increases both usefulness and risk because every additional action creates another opportunity for a mistaken assumption to propagate. A chatbot that hallucinates produces a bad answer. An agent with authority over a real environment can turn a bad assumption into a real action.
The progress is real, but so is the blast radius, and serious AI engineering increasingly has to account for both.
More Context Did Not Eliminate the Need for Better Context
Another assumption that repeatedly appeared during this period was that larger context windows would eventually eliminate most context-management problems. If a model could ingest an entire repository, a long document collection, or years of interaction history, perhaps developers could simply provide everything and allow the model to decide what mattered. The industry gradually learned that context capacity and context quality are different engineering problems.
A long context window determines how much information can technically be included in an inference, but it does not guarantee that every token receives equal attention, that stale information will not interfere with the current task, or that contradictory instructions will be resolved correctly. An agent working for hours can generate enormous amounts of terminal output, search results, intermediate plans, failed hypotheses, retrieved documents, logs, tool responses, and state changes. Preserving all of that information indefinitely can make the working context less useful rather than more complete.
This is why context engineering became a distinct discipline. Modern agents increasingly need mechanisms for retrieving information only when relevant, summarizing historical state, externalizing persistent memory, compacting verbose tool outputs, isolating unrelated work in subagents, and reconstructing enough state to continue across multiple context windows. Long-running agents begin to resemble distributed systems in the sense that useful state must be stored, transferred, compressed, invalidated, and reconstructed deliberately rather than simply remaining inside one continuously expanding conversation.
The broader lesson is that bigger models and larger context windows do not eliminate architecture. In many ways they make architecture more important because the model can now interact with much larger environments and therefore has more opportunities to receive irrelevant, stale, or contradictory information. The model remains enormously important, but the model alone is no longer the system.
The Emerging Unit of Computing Is Intent
The most interesting consequence of this evolution may be what it does to the interface between humans and computers. Graphical user interfaces taught people to manipulate visible objects. Search engines taught people to formulate queries. Smartphones compressed computing into touch interactions. Traditional automation required humans to explicitly encode operations through code, scripts, APIs, workflow builders, or application logic.
Agents introduce a different abstraction because the user can increasingly describe the desired state rather than every operation required to achieve it. A request such as "find the cause of this failing deployment and fix it" does not specify which logs to inspect, which commands to run, which configuration file might be relevant, or how the service should be verified afterward. A request such as "research these companies and compare their strategies" does not enumerate every search query, source, comparison criterion, or intermediate note. The user describes the outcome and constraints, while the agent determines part of the path through the tools and environment available to it.
This does not mean natural language replaces software engineering or that computing becomes magic. If anything, agent systems make architecture, specification quality, security, evaluation, observability, and permission design more important because more of the execution path is delegated. A vague instruction given to a text generator may produce a weak paragraph, while a vague instruction given to an agent with access to infrastructure can produce a weak action with real consequences.
The shift is therefore not from programming to not programming. It is from explicitly controlling every operation toward designing systems that can safely determine some of those operations themselves. For technical users, this changes the distribution of valuable skills. Writing code remains important, but so do decomposition, architecture, requirement design, evaluation, context management, tool design, agent debugging, review discipline, and deciding which operations should never be delegated automatically.
The human role moves upward in abstraction without disappearing.
Less Than Four Years Later We Are Solving a Different Problem
When conversational generative AI became mainstream near the end of 2022, the central question for most users was whether a machine could produce an intelligent enough response to be useful. Prompt engineering became popular because the interaction boundary was still primarily a conversation, and much of the practical craft involved learning how to communicate with the model effectively. Better prompts often produced better answers, and the model largely remained the place where the workflow ended.
By August 2026, that question feels incomplete. We now care whether a model can retrieve the correct information, understand images and audio, reason for long enough to solve difficult problems, select the right tool, interact with software, preserve useful memory, recover from failed actions, delegate work to another agent, maintain progress across context windows, operate safely for extended periods, and expose enough observability for a human to understand what actually happened during execution. We care about context engineering because the prompt is only one part of what the model sees, harness design because the model is only one part of how the agent behaves, evals because a convincing answer is no longer sufficient evidence of successful task completion, and permissions because AI systems increasingly have the ability to change state instead of merely describing it.
Persistent personal agents are one of the clearest examples of where this trajectory has arrived. Hermes Agent, for example, combines persistent memory, reusable skills, terminal and browser tools, scheduled execution, MCP integrations, isolated subagents, multiple messaging gateways, and execution environments that can continue operating independently of the user's primary device. A system with that collection of capabilities would have sounded excessive if described during the original chatbot boom, yet by 2026 those features increasingly resemble the natural continuation of everything that happened during the previous four years.
The extraordinary part is not that every problem has been solved. Hallucination remains a problem, long-horizon reliability remains difficult, security becomes more complicated as agents gain authority, autonomous execution can become expensive, benchmarks can misrepresent real-world usefulness, context can degrade, external tools can fail, and agents can confidently pursue the wrong objective for several steps before a human notices. The extraordinary part is that these are now the engineering problems receiving serious attention. Four years ago, the mainstream problem was getting a language model to produce a useful answer. Today, the problem is building an entire execution environment around models capable of doing useful work.
From Finding Answers to Delegating Outcomes
Looking back at the beginning of the AI boom, I do not think the most important transformation is that conversational models became better alternatives to search, that coding models became better autocomplete, or that reasoning benchmarks climbed higher. Those developments matter, but they are manifestations of a broader shift in the boundary between human intent and computer execution.
The old internet taught us to find information created by other people. Search engines made that information discoverable, Stack Overflow organized technical knowledge, Reddit organized conversations and experiences, Brainly organized educational answers, and countless other communities turned collective human knowledge into something searchable. Conversational AI inserted a generative reasoning layer between the user and that information, while tool use connected that reasoning layer to software and external systems. Multimodality expanded what AI could perceive, reasoning models increased the amount of computation available for difficult problems, MCP and other integration systems expanded what agents could access, and coding agents gave models environments where actions could be executed and tested.
Context engineering made the information environment part of the architecture. Memory and skills allowed useful knowledge and procedures to persist across sessions. Subagents allowed independent work to be isolated and delegated without forcing every intermediate detail into one context. Harness engineering made it possible to structure increasingly long and complex agent trajectories, while persistent agents began separating AI work from the particular device where the human happened to be sitting.
The progression can therefore be understood as a change in abstraction:
01 Access knowledgeFrom finding pages to continuing a conversationSearchDiscover informationChatInteract with knowledge02 Expand capabilityFrom generating text to choosing and using softwareToolsConnect to softwareReasoningSpend compute on decisions03 Delegate workFrom assisting a step to carrying an outcome forwardAgentsExecute complete tasksPersistent DelegationContinue beyond a conversation
Each stage did more than make the previous interface faster. It changed what users expected the computer to do on their behalf and moved another portion of the execution path away from direct manual control.
I still search the web, read Stack Overflow, browse Reddit, inspect documentation, open GitHub issues, read research papers, use an editor, work in a terminal, and review code manually. None of those layers disappeared, and AI did not suddenly make traditional sources or technical expertise irrelevant. What changed is the point at which I need to enter those layers myself. Increasingly, the first interaction can happen at the level of intent, while parts of the investigation, execution, and synthesis that follow can be delegated.
Less than four years after conversational AI became mainstream, we are no longer asking only whether AI can answer our questions. We are learning how much of the path between an idea and a real outcome can safely be delegated to systems capable of reasoning, using tools, maintaining state, and acting inside real environments.
That is why AI is not merely changing software.
It is changing almost everything.