Overview of Agentic AI - Part 1 - Concepts

Part 2 - Getting Started with Coding Agents

AI agents are currently at the forefront of AI development.

I've been using AI agents at work in the form of GitHub Copilot (the only approved tool there) inside Visual Studio Code, and it's been great. I've also been following the news around the rapidly evolving field of AI. Still, I was curious to try some of the tools and services that have been getting a lot of attention myself, while also taking the opportunity to better understand concepts and terms I've frequently come across without fully understanding.

In this two-part article, I'd like to briefly summarize my understanding of agentic AI while doing just that. In this first part, I'll focus on the concepts behind AI agents and the current landscape, while taking a hands-on approach in the second.

1. From Chatbots to Agents

Although AI research and products had existed long before it, the launch of ChatGPT in 2022 marked the beginning of the mainstream adoption of AI that continues today. Its capabilities may be considered quite limited by today's standards, but it was a revolutionary moment: for many of us, it was the first time a computing system seemed able to communicate in a remarkably human-like way.

The next major shift was from systems that could answer our questions to systems that could take actions on our behalf, leading us to the current era of agentic AI.

As large language models matured and became increasingly good at breaking down abstract goals and planning the steps toward them, people started integrating APIs, code execution environments, and web-browsing capabilities that allowed agentic systems to interact with external software to perform actions such as sending emails and editing source code.

Agentic AI refers to systems in which AI agents work toward a given goal through a feedback loop that involves reasoning and planning, taking actions, and evaluating the results. More sophisticated systems can run multiple agents in parallel, each responsible for an aspect of the solution, and work for hours or even days to complete long-running tasks.

2. The model: the brain

The evolution of LLMs has been a key factor behind the major advances we've been seeing in AI agents. Models have not only become much more capable overall, but AI labs have also increasingly optimized them for capabilities that are particularly important for completing tasks autonomously.

1. Reasoning: reasoning models can spend additional time and computation working through a problem before producing an answer or taking an action. This allows them to break down complex goals, evaluate different approaches, consider constraints, and adjust their plans—capabilities that are especially important when completing multi-step tasks.

2. Context window: the context window determines how much information a model can work with at once. While LLMs have always had a context window, its size has increased dramatically, with context windows of up to 1 million tokens now common among frontier models. This is particularly important for agents, which may need to work with large amounts of source code, instructions, conversation history, and results from previous actions while completing increasingly complex tasks.

3. Tool calling: this is the model's ability to recognize when an external tool is needed, select the appropriate tool, and generate the arguments required to invoke it. This allows the model to request actions that the harness can execute against external systems rather than being limited to generating responses, and it is another capability AI labs have increasingly optimized their models for.

4. Multimodality: multimodality is the ability of models to process inputs other than text, such as images and video, and agentic workflows can take advantage of it to improve the quality of their output. For example, an AI agent can take screenshots of a web page it has created to check whether the design complies with the specifications.

Together, these improvements have made models increasingly capable of working autonomously on longer and more complex tasks, often referred to as "long-horizon tasks." One way this progress has been measured is through the "task-completion time horizon": research by METR suggests that the length of software-related tasks frontier agents can complete with 50% reliability has historically doubled roughly every seven months since 2019.

One interesting trend in the AI model landscape, especially visible since the launch of DeepSeek-R1, is the intensifying competition between the United States and China for leadership in artificial intelligence. While US labs continue to dominate much of the closed-model frontier, Chinese labs have rapidly narrowed the capability gap while placing particular emphasis on aggressive pricing and open-weight releases, helping their models reach broader adoption.

This competition has intensified further in 2026 as Chinese models have continued to improve in capability and move closer to leading frontier systems. At the same time, US labs are increasingly competing not only on raw intelligence but also on efficiency and price. OpenAI's recently launched GPT-5.6 family is a good example: it is offered in three tiers—Sol, Terra, and Luna—targeting different trade-offs between capability, speed, and cost, with Luna positioned particularly aggressively for cost-sensitive workloads.

3. The harness: the orchestrator

A harness, in the context of AI, is the software that orchestrates models, tools, context, and the environment to achieve a desired outcome.

The distinction between a harness and an agent can be confusing, as the terms are not always used consistently. Products such as coding agents include a harness that manages how the model interacts with its context, tools, and environment while working toward a goal. In practice, the product as a whole is often simply referred to as an "agent." For simplicity, I may follow that convention throughout this article.

Generated by AI

The image above shows where the agent sits in the overall flow. It takes user input and interacts with the model to determine the next action to take. The agent then executes tool calls based on the model's requested actions, making the necessary changes to the environment to achieve the desired outcome. It's important to note that the harness is not necessarily the component users interact with directly, although that is often the case.

A prominent example is Claude Code, Anthropic's agentic coding tool. It can inspect a codebase, edit files, execute commands, and work through implementation tasks based on natural-language instructions. Tools like this are part of a broader shift toward creating software through natural-language interaction with AI. One term that emerged for an especially hands-off version of this workflow is "vibe coding," coined by Andrej Karpathy in 2025.

Currently, although we continue to see significant advances in the capabilities of AI models themselves, a lot of attention is also focused on the software layer around them. That's because the same model can produce substantially different outcomes depending on the harness it runs within. As a result, the model is no longer the only meaningful unit of comparison.

Because of this shift, choosing an AI tool now requires more consideration than simply choosing a model based on its intelligence. Since the price difference between the most capable models—the so-called "frontier models"—and more cost-effective alternatives can be substantial, it may sometimes make sense to choose a cheaper, less capable model and pair it with a strong harness that can get the most out of it.

In practice, the best choice may not be the strongest model, but the best combination of model, harness, and cost.

4. From prompt engineering to agent engineering

As artificial intelligence has evolved, so has the way we interact with it.

When large language models started becoming commonplace, prompt engineering became a prominent practice: designing and refining instructions to guide models toward more accurate, relevant, and useful outputs. This involved providing clear goals and relevant context, assigning roles or personas when useful, and specifying constraints and the desired format of the final output.

Later, people started talking about context engineering: the set of strategies used to curate and maintain the information provided to an LLM during inference. This becomes particularly important for agents, which continuously accumulate instructions, tool results, conversation history, source code, and other information as they work. Common strategies include retrieving relevant information only when needed through techniques such as Retrieval-Augmented Generation (RAG), and compacting or summarizing accumulated context to preserve the most relevant information.

Source: https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents

As coding agents became more capable, spec-driven development (SDD) also gained attention. In this approach, structured specifications serve as the primary source of truth for coding agents. Humans define intent, requirements, constraints, and acceptance criteria upfront, while agents use them to plan and implement the software. It provides a more structured alternative to the loosely defined approach commonly associated with "vibe coding."

More recently, the term loop engineering has emerged to describe the practice of designing automated workflows that repeatedly prompt, check, and guide agents toward a goal with minimal human intervention. Instead of manually prompting the agent at every step, engineers design feedback loops in which agents take actions, evaluate the results, and adjust their approach until the task is complete.

Several mechanisms have also emerged for giving agents the instructions, capabilities, and feedback they need to operate effectively:

• AGENTS.md: a project-level instruction file written for coding agents, containing information such as repository conventions, commands, architecture, and development guidelines.
• Skills: reusable packages of instructions and resources that teach agents how to perform specialized tasks or workflows. A skill typically contains a SKILL.md file and may also include scripts, references, and other resources.
• MCP (Model Context Protocol): a standard that allows agentic applications to connect to external tools and data sources, such as APIs, databases, web-search services, and other systems.
• Subagents: additional agent instances that can be delegated specialized tasks, sometimes working independently or in parallel with the main agent.
• Automated verification: tests, linters, builds, browser checks, and other deterministic mechanisms that give agents objective feedback about whether their work is correct.

As we can see from this transition, rather than trying to find one "magical" prompt, we are increasingly concerned with giving agents good specifications, useful context, the right tools, and reliable feedback.

In other words, the focus is gradually shifting from engineering prompts to engineering the entire system in which the agent operates.

5. The agent landscape

Finally, let's look at the main types of agents available today. Although the boundaries between them are often blurry, we can roughly group them into three categories based on their primary use case:

• Coding agents - agents specialized in software development. They can take a goal expressed in natural language and work toward completing it by repeatedly inspecting source code, editing files, running commands and tests, and evaluating the results.
  • A simplified loop might look like this: the agent sends the user's request and relevant context to an LLM, receives a requested action or tool call, executes it, and feeds the result back to the model. Instead of simply generating code snippets, coding agents can run shell commands, inspect error logs, modify files, and attempt to fix their own mistakes without requiring a new prompt at every step.
  • Popular examples include Claude Code, Codex, Cursor, and OpenCode.
• Computer-use / general-purpose agents - these agents are not limited to software development. Some, such as Claude’s Computer Use capability, can interact with graphical interfaces by seeing the screen and operating the mouse and keyboard. Others, such as Hermes Agent and OpenClaw, combine tools, browser access, memory, automation, and integrations to perform a wide range of tasks across a user’s computer and online services.
  • These can handle high-level user instructions such as "find a suitable flight and book it after receiving approval" or "compile this data from three apps."
• Automation agents - agents primarily designed to execute recurring or event-driven workflows across applications and services, combining traditional automation with LLM-based reasoning where needed. An example might be: “Every morning, check these dashboards, summarize any anomalies, and send the results to Slack.”
  • Automation agents typically place less emphasis on open-ended reasoning than general-purpose agents, but the boundary is fuzzy. General-purpose tools such as Hermes or OpenClaw can also behave like automation agents depending on the task.
  • n8n and Zapier Agents are examples of platforms focused on this kind of agentic automation.

These categories are not strict: the underlying architecture can be very similar, and increasingly capable general-purpose agents may perform coding, computer-use, and automation tasks depending on the tools and environment available to them.

Conclusion

AI agents represent a shift from using language models simply to generate answers toward building systems capable of working toward goals and taking actions on our behalf. As we have seen, their capabilities depend not only on the intelligence of the underlying model, but also on the harness, tools, context, environment, and feedback mechanisms surrounding it.

The landscape is evolving extremely quickly, and many of the concepts and boundaries discussed here will certainly continue to change. In Part 2, we'll move from concepts to practice and explore the different ways developers can actually get started with coding agents, comparing several setups in terms of cost, quality, and speed.

References

METR — Measuring AI Ability to Complete Long Software Tasks
https://metr.org/blog/2025-03-19-measuring-ai-ability-to-complete-long-tasks/

Andrej Karpathy's post in which he coined the term "vibe coding"
https://x.com/karpathy/status/1886192184808149383

Hugging Face — One Year Since the “DeepSeek Moment”
https://huggingface.co/blog/huggingface/one-year-since-the-deepseek-moment

OpenAI — GPT-5.6: Frontier intelligence that scales with your ambition
https://openai.com/index/gpt-5-6/

Qiita — SDD (Spec-Driven Development) and its relationship with Loop Engineering
https://qiita.com/nogataka/items/b78d9d8cd39967df4119

Posit — AGENTS.md vs Skills vs MCP servers
https://opensource.posit.co/blog/2026-07-03_ai-newsletter/