#ai-agents

A stateless agent makes each decision from the current input only, while a stateful agent carries useful information across steps so later decisions can depend on earlier ones. This distinction affects how you design AI agents, chatbots, workflow automations, and any system that acts over multiple turns or tasks. Use a stateless design when each request is independent, easy to retry, and simple to scale. Use a stateful design when the agent must remember goals, intermediate resul

Agent context compaction, also called context summarization, is the practice of shrinking an AI agent’s conversation or working memory into a shorter representation so it can keep going without exceeding the model’s context window. Agents often run for many turns, call tools, inspect files, and accumulate lots of intermediate state. That history eventually becomes too large to feed back into the model. Context compaction solves two practical problems: Keeps long-running agents usable whe

A supervisor agent, also called a routing agent, is an agent that decides which specialist tool, workflow, or sub-agent should handle a user’s request instead of trying to do everything itself. A single general-purpose agent can get messy when a task spans multiple skills: search, code, database access, summarization, planning, and verification. A supervisor/router agent helps by directing each request to the right worker, which can make systems easier to maintain, safer to control, and cheaper

Agent autonomy is the degree to which an AI agent can decide and act on its own, from simply suggesting actions to fully executing a task with little or no human intervention. “Autonomy” is the main design choice when building agentic systems. It tells you how much responsibility the system has versus the human operator. You reach for higher autonomy when: the task is repetitive, bounded, and low risk speed matters more than fine-grained human control the environment changes often enough that ha

An agent scratchpad is the temporary working area an AI agent uses to keep intermediate notes, steps, or partial results while it solves a task. A scratchpad helps an agent “think through” a multi-step problem instead of trying to answer in one shot. It is useful when a task requires planning, tool use, multi-step reasoning, or keeping track of state across turns. In practice, teams reach for a scratchpad when they want the agent to: break a task into steps, remember what it has already trie

A subagent is a smaller agent that a larger agent delegates a specific task to, instead of doing everything itself. Subagents help break a complex job into manageable pieces. In practice, teams reach for them when one agent would otherwise have to plan, execute, check, and summarize all at once. They are useful when you want: specialization: one agent handles research, another writes code, another verifies results better control: the parent agent can supervise or combine outputs simpler prompts:

An orchestrator-worker agent pattern is a setup where one lead agent plans, delegates, and coordinates work, while several worker agents or tools handle smaller tasks in parallel or in sequence. This pattern helps when a single LLM call is not enough because the job is too broad, too long, or naturally decomposes into parts. The lead agent reduces the problem into sub-tasks, assigns them, and then combines the results. In practice, you reach for it when you want: better structure for complex req

Reflection, or self-critique, is when an AI agent reviews its own output or plan, spots mistakes or weaknesses, and then revises itself before acting. Agentic systems can make more than one kind of error: they may miss a constraint, choose a bad tool, hallucinate a fact, or produce a plan that looks plausible but won’t work. Reflection adds a built-in “check yourself” step, which is useful when you want better reliability than a single pass from the model. In practice, teams reach for reflection

Task decomposition is the practice of breaking a larger goal into smaller, manageable sub-tasks that can be solved one by one. Complex tasks are easier to plan, execute, and debug when they are split into parts. In AI systems, software projects, and agent workflows, decomposition helps you: reduce ambiguity in a broad request assign work to different components or steps catch errors earlier by checking intermediate results make progress on problems that are too large to solve in one shot In prac

A multi-agent system is a setup where multiple autonomous agents work separately or together to complete a task, often with some form of coordination or agent orchestration. A single agent is often enough for simple tasks, but multi-agent systems help when the problem is naturally split into parts: research, planning, execution, review, or parallel exploration. They can also let you assign different roles or tools to different agents, which is useful when one model instance would be too slow, to

Agent memory is the information an AI agent keeps so it can keep working across turns, and it usually means two different things: short-term memory for the current task context, and long-term memory for stored facts or past interactions it can retrieve later. Without memory, an agent is basically reset every time you ask it something new. That makes it bad at multi-step tasks, personalization, follow-up questions, and anything that needs continuity. In practice, memory helps an agent: re

A planner-executor agent is an AI system that first makes a plan, then carries out that plan step by step, usually by delegating the “thinking ahead” to one component and the “doing” to another. This pattern is useful when a task is too complex to solve in one shot. Instead of asking a model to answer, browse, call tools, and self-correct all at once, you split the work into two roles: Planner: decides the sequence of steps, subgoals, or tool calls. Executor: follows those steps and prod

Human-in-the-loop for agents means a person stays in the decision loop to review, approve, correct, or stop an AI agent before it takes important actions. Agentic systems can plan, call tools, and act across multiple steps. That is useful, but it also creates risk: a wrong tool call, a bad assumption, an unsafe side effect, or an action the user never intended. Human-in-the-loop adds a control point so the agent does not fully act on its own when the cost of a mistake is high. You reach for it w

An agent harness or agent runtime is the software layer that runs an AI agent, manages its loop of thinking and acting, and connects it to tools, memory, and external systems. An LLM by itself just returns text. An agent needs more than that: it has to decide when to call a tool, pass results back into the model, stop at the right time, handle errors, and keep track of state. That is what the harness/runtime does. It is the scaffolding around the model that turns “generate a response” in

An AI agent, also called an LLM agent or autonomous agent, is a system that can pursue a goal by deciding what to do next, taking actions, and using the results to keep going. Most AI systems just answer a prompt once. An agent is useful when one answer is not enough and the system needs to act over multiple steps: search, call tools, inspect results, retry, and stop when the goal is met. You’d reach for an agent when the task is: open-ended, not a single fixed response dependent on external

An agentic workflow is a workflow where an AI system can decide and take multi-step actions toward a goal, instead of only producing a one-shot answer; you may also hear this called an agentic system. Use an agentic workflow when the task is not just “generate text,” but “figure out what to do next.” That includes tasks like investigating an issue, pulling together information from multiple tools, retrying after failure, or following conditional branches based on intermediate results

A ReAct agent is an LLM-driven system that alternates between reasoning and acting—often called reason + act or ReAct prompting—so it can decide what to do next, use tools, and update its plan from the results. ReAct is useful when a model should not just produce an answer, but also take steps in the world: search a document set, call an API, inspect a database, or ask for more information. In practice, teams reach for it when: a plain chat completion is too static, the task

The agent loop, also called the perceive-plan-act loop, is the repeated cycle where an AI agent observes its situation, decides what to do next, and then takes an action. This is the basic control pattern behind many agentic systems. Instead of asking a model for one one-off answer, you let it keep checking the world, updating its plan, and acting until the task is done or it should stop. You reach for it when the task is dynamic, multi-step, or depends on intermediate results: calling tools, br

Tool use in AI agents is when an LLM-based agent can call external functions, APIs, or programs—often called a tool calling agent—to get information or take actions it cannot do reliably from text alone. A plain language model is good at generating text, but it does not reliably know live facts, cannot directly query a database, and should not guess at actions like sending email or creating tickets. Tool use solves that by letting the model delegate specific steps to purpose-built systems. Y

Goal-directed behavior in agents is behavior where an agent chooses actions to achieve a specific objective, rather than just reacting passively to the latest input. Goal-directed behavior is the core of what makes an “agent” useful for real work. If a system can keep a goal in view, it can plan, prioritize, and recover from interruptions instead of only producing one-off responses. You reach for this idea when you want a system to: complete multi-step tasks, make tradeoffs between possible acti

OpenUsage Community is a lightweight desktop app that pulls your usage and quota from 25+ AI coding services — Claude, Copilot, Cursor, Codex, Gemini, Grok and more — and shows them together in your menu bar or system tray, so you never have to open a single provider dashboard to know where you stand. It is an independent, community-maintained continuation of the original OpenUsage project. The community fork was created after the original moved toward a Swift / macOS-first direction; this versi