Four years ago, you could opened ChatGPT, ask a question, and get an answer. Today, you can give an agent a standing job, close the app, and expect it to continue working. Agents like Grok Bot and Muse can use tools, remember previous work, and come back when they need your input. This shift from chatbots to persistent agents didn’t happen overnight. The loop stayed the same, its surrounding evolved.
First, we gave models tools. Then we added memory, reliable execution, background activation, and increasingly configurable environments. Each new capability opened up new use cases and exposed the next limitation. Let’s see them.
1. Tool Calling Agent
Early ChatGPT could tell you what the weather in Paris was typically like in November. But ask whether it was raining right now, and it had no way to check. The model could only answer based on what it had learned during training. To interact with the outside world, it needed tools.
The 2022 ReAct paper demonstrated how a model could take an action, observe the result, and decide what to do next. In June 2023, OpenAI introduced function calling, making this pattern easier to implement. Developers could expose functions to the model, execute the requested tool calls, and feed the results back. This became the basic agentic loop that most agents still use today.
The following Pydantic AI example demonstrates this pattern with predefined weather data:
from pydantic_ai import Agent
agent = Agent("openai:gpt-5-mini", instructions="Use the weather tool for forecasts.")
@agent.tool_plain
def get_weather(city: str) -> str:
"""Look up demo weather for a city."""
return {"paris": "18°C and cloudy"}.get(city.lower(), "No demo data")
print(agent.run_sync("What's the weather in Paris?").output)The same pattern can help a customer support agent look up an order and check its shipping status. But what happens when you follow up with “Can you change the delivery address?”
2. Stateful Agent
To handle that request, the agent needs to remember which order you’re talking about and what it learned from the shipping tool. But the model doesn’t retain this information on its own. Each call starts with the context it receives, so the agent needs a way to carry information from one interaction to the next.
The simplest approach is to pass the conversation history with every model call. That works for a while, but as conversations grow, so does the context. Eventually, the agent has to decide what to keep, what to summarize, and what to discard. Frameworks like LangGraph can save and restore conversation state, while OpenAI’s Responses API can maintain it server-side without requiring developers to resend the full history.
But remembering a conversation is not the same as remembering what matters. A travel agent shouldn’t need to revisit every previous conversation to know that you prefer trains over flights. Google ADK separates session state from long-term memory, while Mem0 can extract and retrieve useful information across sessions.
Memory helps agents continue conversations, but remembering what was discussed is different from remembering what was executed. That distinction becomes important when agents start performing real business operations and when things go wrong.
Sponsored by Oracle
How agents remember across sessions
What should an agent remember, and how much context does it really need? Oracle makes the case for database-native agent memory, reporting 93.8% on LongMemEval and 10.7× fewer estimated input tokens than replaying the full conversation at turn 80.
3. Durable Agent
Now suppose the support agent does more than answer questions about an order. You ask it to process a return. It checks the return policy, looks up the payment, and requests a refund. But what happens if the worker crashes halfway through? Remembering the conversation isn’t enough. The agent needs to know which steps completed and whether the refund was already issued. Starting over could repeat expensive operations or even refund the customer twice.
This is where durable execution comes in. A durable agent records the results of model and tool calls as it progresses. If the worker crashes or restarts, the runtime can reuse completed steps and retry unfinished ones rather than starting from scratch. External side effects still need special care for edge cases. For example, retrying a refund requires an idempotency key supported by the payment provider, or checking whether the payment was already processed.
The Dapr Agents quickstart demonstrates this with a simple agent. You can stop the worker during a slow tool call, restart it, and resume the same workflow without another prompt. I used to contribute to Dapr Agents, and Diagrid now also offers adapters that bring durable execution to 10+ agentic frameworks.
Other frameworks take different approaches. Inngest lets you wrap model and tool calls in step.run(), persisting their results for recovery. It can also suspend execution while waiting for human approval. Restate, DBOS, and Temporal offer other durable execution options for agents.
Sometimes an agent is only one step in a larger business workflow. Kestra can invoke an agent as a task or call a remote agent through the Agent2Agent (A2A) protocol. The workflow can manage the overall process, while recovery within the agent’s own tool loop remains the responsibility of its execution runtime.
These are all variations of durable execution with LLM call in the mix.
With durable execution, agents can survive failures and continue long-running tasks. But so far, someone still has to start the work. What if the agent could also respond to events or run on a schedule?
4. Ambient Agent
So far, a person has started every agent interaction. But agents don’t need a chat interface or a human waiting for a response. They can also run headless (without an UI), triggered by events from other applications or on a schedule.
For example, an order service can trigger an agent whenever a new order arrives, or an agent can periodically check an inbox and draft replies for review, as demonstrated by LangChain’s Ambient Agents. The same agentic loop runs in the background, with results delivered to another system or a human when needed.
5. Harness Agent
A coding agent needs more than a set of predefined tools. It must read repositories, edit files, run tests, and follow project-specific rules. More importantly, with code execution, it can write and run its own scripts to solve problems that weren’t anticipated in advance. This flexibility requires a controlled execution environment, along with instructions, permissions, and reusable capabilities. Together, these form a configurable harness.
Claude Code and Codex made this approach popular. The underlying agentic loop remains the same, but the harness provides the environment in which it operates, including code execution, skills, hooks, MCP connections, subagents, and security guardrails.
For example, a Claude Code repository might contain:
project/
CLAUDE.md
.claude/
settings.json
skills/release-check/SKILL.md
agents/test-investigator.md
.mcp.jsonCLAUDE.md provides project instructions, while Codex uses AGENTS.md. Skills package reusable procedures, MCP servers connect external tools, and subagents handle specialized tasks with their own context. Permissions and sandboxing control what the agent can access and execute.
The same separation is emerging beyond coding agents. In kagent, an AgentTemplate describes what the agent does and which tools it uses, a Harness defines how it runs on Kubernetes, and egress policy controls what the agent can reach. All of these allow creating harness-based agents without touching an agentic framework code.
Harnesses make agents more capable and configurable. But what happens when an agent is given not just a task to complete, but an ongoing responsibility?
6. Persistent Agent
Customer feedback doesn’t arrive as a one-off task. New requests keep coming, and a report next week might change how we understand one from today. Rather than starting a new agent for every report, we can give an agent a standing goal, continuous memory, and the ability to initiate new work on its own. This is the idea behind persistent agents.

Imagine a customer feedback agent called Scout:
You are Scout, my customer feedback assistant. Group related requests, link them to existing issues, and flag anything that needs a roadmap decision. Remember those decisions for future reports. Keep this assignment unless I change it. Leave roadmap decisions to me.
Scout can monitor feedback for weeks without someone starting a new conversation each day. A new report or scheduled check-in activates it. It can start separate sessions to investigate issues, compare findings with previous reports, and bring the results back together. As it works, it updates its memory with new information, decisions, and lessons from its environment.
This Activate, Act, Adapt cycle allows the agent to maintain a continuous responsibility across independent runs. Individual sessions may end, but its goal, memory, and unfinished work carry forward.
We’re starting to see this model in products like Grok Bot, Meta Muse, and Kiro Crew Bots. They support ongoing goals and memory across interactions, while Kiro Crew Bots can also start and coordinate multiple worker sessions autonomously. Rather than managing individual tasks, you assign a responsibility and review progress as the agent works toward its goal.
Persistent agents can learn from experience and adapt their memory. But what if they could also improve the tools, skills, and workflows they use? That brings us to the next evolution: self-improving agents.
What’s Next? Self-Improving Agents
The next evolution is agents that improve how they work, not just what they remember. We’re starting to see this in different forms, from optimizing memory to learning new skills and modifying the agent’s own execution environment.
For example, Anthropic’s recent research on agent memory explores how Claude can use a dreaming cycle to review past interactions, correct mistakes, consolidate memories, and reorganize knowledge for future sessions. Other agents, such as Hermes Agent and OpenClaw, can learn from experience and update their skills. Letta Code takes this further by allowing agents to extend their own harness at runtime.
Agents should test changes to their tools and skills and measure whether those changes improve their work before adopting them. Humans should retain control over the agents’ goals and permissions.







