For years, AI assistants acted as oracles: you asked, they answered. In 2026 the paradigm changed. Now autonomous agents can plan, execute tools, evaluate results, and correct their own course without constant human intervention.
Main architectures
ReAct (Reasoning + Acting)
The most widespread pattern. The model alternates _Thought_ and _Action_ steps until reaching a final answer.
from langchain.agents import create_react_agent
from langchain_openai import ChatOpenAI
from langchain import hub
llm = ChatOpenAI(model="gpt-4o", temperature=0)
prompt = hub.pull("hwchase17/react")
tools = [search_tool, code_interpreter, file_reader] # [!code highlight]
agent = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True) # [!code highlight]
result = executor.invoke({"input": "What is the current price of BTC in USD?"})Plan-and-Execute
Separates planning from execution. More robust for complex tasks with many steps.
from langchain_experimental.plan_and_execute import (
PlanAndExecute,
load_agent_executor,
load_chat_planner,
)
planner = load_chat_planner(llm) # [!code ++]
executor = load_agent_executor(llm, tools) # [!code ++]
agent = PlanAndExecute(planner=planner, executor=executor)Multi-agent (Crew/Graph)
Several specialized agents collaborate: one researches, another writes, another reviews. Frameworks like CrewAI or LangGraph facilitate this coordination.
from crewai import Agent, Task, Crew
researcher = Agent(
role="Technical Researcher",
goal="Gather accurate information on a topic",
llm=llm,
tools=[web_search, arxiv_search],
)
writer = Agent(
role="Technical Writer",
goal="Transform research into a clear article",
llm=llm,
)
task = Task(
description="Write a summary about WebAssembly in 2026",
agent=writer,
)
crew = Crew(agents=[researcher, writer], tasks=[task])
crew.kickoff()Real use cases
| Use case | Agent involved | Estimated savings |
| ———————— | ———————————— | ———————————- |
| Automated code review | Static analysis agent + LLM | 60% of review time |
| Test generation | Plan-and-Execute over codebase | 40% effortless coverage |
| Incident response | Monitor + Reasoner + Actuator | MTTR reduction by 70% |
| Living documentation | Agent that reads commits & makes docs| Non-stop updated documentation |
Security considerations
> Golden rule: an agent should never have more permissions than strictly necessary to complete its task.
The main risks are:
- Prompt injection: a malicious input convinces the agent to execute unauthorized actions.
- Tool misuse: the agent invokes a destructive tool (e.g., `DELETE` on a database) due to flawed reasoning.
- Infinite loops: without an iteration limit, the agent can consume tokens and money indefinitely.
Mitigate these risks with:
executor = AgentExecutor(
agent=agent,
tools=tools,
max_iterations=10, # [!code highlight]
handle_parsing_errors=True, # [!code highlight]
return_intermediate_steps=True,
)The future is agentic
The transition from “AGI” (General Purpose AI) to “Agentic AI” is redefining what it means to be a developer. It’s not about agents replacing programmers, but about programmers who know how to orchestrate agents replacing those who do not.
The next step is persistent memory: agents that remember past conversations and projects, accumulate context, and improve over time, like a colleague who learns from every sprint.
Leave a comment