From chatbots to doers: what agentic AI changes
An early ChatGPT could explain how to solve a math problem but not reliably compute one. Connect the model to an external tool, though—say an online calculator—and its practical abilities jump. That lesson, familiar to anyone who has watched a robot vacuum’s sensors and wheels work together, is the seed of the shift now underway in generative AI: large language models (LLMs) are becoming the brains of AI agents that pursue multi-step goals with limited human supervision.
In such systems, the LLM handles reasoning while additional algorithms and tools take on tasks like drafting software development plans or booking flights. Experimental projects such as AutoGPT demonstrate the pattern, for example a marketing agent that finds Reddit comments about a product and answers them on its own. When agents are wired together into multi-agent systems, the scope of what can be automated grows further. Expect agentic AI to show up in more developer tools, which makes it worth understanding what these systems are, how they work, and where they still struggle.
What defines an AI agent?
Agentic AI refers to artificial intelligence that can make decisions, plan, and adapt to new information in real time. Agents learn and improve from feedback, using algorithms and sensory inputs to execute tasks within their environments. Lilian Weng, head of safety systems at OpenAI, breaks an agent down into three core characteristics:
- Planning: The agent turns a prompt into a step-by-step plan with discrete milestone goals and uses a reward system to learn from mistakes and improve future outputs.
- Memory: It combines short-term memory for chat context with longer-term data retention and recall, often through retrieval augmented generation (RAG).
- Tool use: The agent calls APIs to fetch more information or execute an action based on a user’s request.
A spectrum of agent designs
AI agents span a range from simple reflex agents to sophisticated learning agents, each with trade-offs. As the field evolves, new types will keep appearing, but these are the variants you are most likely to meet today:
| Characteristics | Examples | |
|---|---|---|
| Reflex agent | Uses a model of the world to make decisions. They can remember some past states and make decisions based on both current and past experiences. | Linting tools like ESLint or Pylint that apply a set of predefined rules to evaluate code. |
| Goal-based agent | Achieves specific goals using their knowledge and the stated goal (or prompt) to make decisions. | Advanced IDEs with AI-powered code completion such as GitHub Copilot. |
| Utility-based agent | Aims to achieve a goal in the best way possible, as determined by evaluating different possible approaches. | Tools that prioritize and assign bugs based on severity, impact, and developer workloads. |
| Learning agent | Improves performance over time by learning from experiences. They consist of a learning element that makes improvements to the AI agent’s outputs based on user feedback and a performance element that uses the learned knowledge. | Code completion tools, such as GitHub Copilot, that improve over time. |
Where agentic systems still stumble
Despite the promise, two industry-wide technical problems complicate development of agentic AI:
- Model outputs cannot be deterministically predicted, making it hard to explain how a particular combination of prompt and training data produced a response.
- Models cannot fully explain their own outputs, although ongoing work aims to give agents greater transparency about how they arrived at a solution.
Both issues make debugging and evaluation difficult. Agents are prone to reach solutions in unexpected ways—a nuance familiar from chess, where machines sometimes make moves that look wrong to humans yet win games. The more sophisticated the agent and the longer it runs, the harder it is to trace what happened, especially as logs grow quickly.
Repeatable evaluation is equally tricky. Since the underlying LLMs keep improving, it is hard to tell whether better results came from your approach or simply from a stronger foundation model. Developers also wrestle with choosing the right metrics, benchmarking against a set heuristic or rubric, and collecting end-user feedback and telemetry to judge real-world effectiveness.
Multi-agent systems in practice
For platforms like GitHub, the goal is to rethink the developer “inner loop” as collaboration with AI: agents that reliably build, test, and debug code while lowering the effort required to get started. That means tackling friction across the whole workflow, which is where multi-agent systems such as Copilot Workspace and code scanning autofix play a role.
Copilot Workspace, launched as a technical preview, is a multi-agent system—a network of specialized agents that communicate and coordinate toward a larger objective. A developer can ask Copilot to help create an application, and the system will generate not just a software development plan but also the code, pull requests, and other artifacts needed to execute it.
Why agents matter for developers
The buzz around AI agents is justified. As they mature, agents will collaborate on increasingly complex tasks, reducing the upfront effort users must invest in prompt engineering. For developers specifically, the practical payoff is more time spent on higher-value work.
When LLMs are given tools, memory, and planning abilities, they behave like modular, adaptable components that can be assembled into larger systems. That modularity is what makes multi-agent architectures possible—and for coding, tools like Copilot Workspace and code scanning autofix point toward software that is built faster and more securely. The trajectory from chatbots that describe rooms to agents that actually clean them is only beginning.
