AI agent dem types: which one fit your work?

AI agent dem types

AI agent dem types come from one taxonomy: simple reflex, model-based reflex, goal-based, utility-based, and learning agents. Each name describe one thing: how much the agent remember and how far ahead e plan before e act. Two more terms, multi-agent and hierarchical, describe how dem wire several agents together, instead of how any one agent make decision.

That list old pass every model wey you don use. E come from the standard AI textbook, and e survive the arrival of large language models because e still ask the question wey decide your design: wetin this thing need know before e act? If you still dey work out where agent end and chat assistant begin, read the difference between AI agent and the LLM wey e run on first. This page start after that line.

Simple reflex agents: one condition, one action

Simple reflex agent dey map current input go one action, and e no keep memory of anything wey happen before. If temperature pass 25, turn on fan. Na the complete mechanism be that.

You don almost surely run one before. A webhook wey trigger n8n workflow, read form submission, then write one row for database, na simple reflex agent. E still remain one even when language model dey middle choose category for that row. Ask am wetin e do one hour ago, e no fit tell you, because nothing keep the answer.

This type dey work correctly pass wetin people expect. E cheap to run, and e failure dey easy to understand: condition match, or e no match. When the real job na “when X arrive, do Y”, memory dey add more ways to fail without adding any benefit. A webhook-triggered n8n agent na this part of the taxonomy, with user interface on top.

E go break immediately when correct action depend on history. Reply bot wey no get thread state go contradict itself for the third message, because the first two messages never enter the input.

Model-based reflex agents: how dem dey keep state between events

Model-based reflex agent dey hold an internal picture of its environment, and e dey update that picture as new input dey come in. For here, “model” mean model of the world, not neural network. This term don exist about forty years before the current meaning, and e dey confuse almost everybody for first reading.

A home automation rule wey dey switch lights off after twenty minutes without motion na model-based. E must be. “No motion right now” and “no motion since 21:40” na the same input for simple reflex agent, so na stored state alone fit show the difference.

The LLM version na any agent wey get memory store behind am: rolling conversation summary, or plain markdown file wey the agent dey read at the start of every run. Local memory service for agent na this idea packaged. The mechanism no change. The agent’s picture of the world dey survive beyond the event wey create am.

State get cost. Stale fact worse pass no fact, because agent go act on am with full confidence and no warning. Anything wey you store need way to expire or way to check am again, otherwise agent go continue reason about server wey you decommission for March.

Agents wey dey work toward goal: planning reach state wey you fit check

Goal-based agent dey receive a target state, then search for sequence of actions wey go reach am. E dey work backward from where e need end, so nobody write the path down before time.

Coding agent na the clearest example wey you fit run by yourself. “Make the failing test pass” no name any file or step. The agent go read the test, form plan, edit something, run the test, read the error, then try again. The loop go end when e reach check wey e fit actually execute. Na why that instruction dey work, while “improve this code” no dey work. Goal wey agent fit evaluate na goal wey agent fit reach. Goal wey e no fit evaluate go become endless loop with bill attached. Run coding agent for your own VPS put that loop for place wey e fit keep running without occupying your laptop.

Cost dey inside this process. Every planning step na another model call wey carry all the history so far, so ten-step task no cost just ten times one step; e cost more. The engineering wey matter na the shape of the loop and the condition wey go stop am. Na that loop engineering dey discuss.

Agents wey dey use utility: how to choose between several good answers

Goal na binary result. Utility na score. Agent wey dey use utility dey face several acceptable outcomes, then e go pick the one wey get the highest score under function wey you write.

Backup job wey must finish before working day start without saturating the uplink na utility problem. No be one answer dey correct; na trade-off dey. Router wey dey decide which model go handle each request, while e dey weigh price against answer quality, get the same pattern.

Algorithm no be the difficult part. Na to write utility function wey honest be the difficult part. If you score only cost, you go get the cheapest model for every request, including the one request wey need the expensive model. System go optimise exactly wetin you measure. This one na problem when you choose wetin to measure because e easy to measure.

Learning agents: di type wey most people think say dem already get

Learning agent dey change e own behaviour based on feedback from past results. E need something wey go judge the outcome, and something wey go change the policy based on that judgement.

Very few self-hosted systems qualify. Agent wey dey read notes wey e write last week na model-based agent with memory file. E weights remain the same. E policy remain the same. Retrieval no be learning, and this difference matter for practical use: memory-based system go repeat mistake forever unless something edit the memory, while learning system suppose stop making the mistake.

If you want the learning part, build the evaluation first. Scored test set, one run of your change against am, and decision to keep or discard the change form closed loop where you be the learning component. This slower pass than e sound, and na the only version wey dey work today with self-hosted parts. Self-hosting eval harness na where you go start.

Multi-agent and hierarchical systems: arrangements, not types

Dis no be sixth and seventh type. Dem just describe how agents dey arranged.

A multi-agent system dey run several agents at the same time inside one shared environment, like a queue or a git repository. Because dem dey share the environment, dem fit clash inside am. Two agents dey edit one file na the standard failure, and lock or work queue na the fix. No prompt fit solve am.

A hierarchical system dey put one supervisor above workers. The supervisor dey split task, give out the different parts, and join together wetin come back. E popular because e match how people dey divide work, but e cost plenty because supervisor context dey grow with every report wey e read. A multi-agent harness dey show how to wire am for real.

One agent wey dey work pass four wey mostly dey work.

Every handoff na place where information fit lost. Start with one loop. Only split am when you fit name the step wey dey cause the bottleneck.

Why almost every real system dey hybrid

Make we look deployment agent wey you fit run by yourself. A webhook dey start am, so e be reflex. E dey read the current release state, so e dey model-based. E dey plan the steps from the running version go the target version, so e dey goal-based. E dey choose rollout window from current load, so e dey utility-based. E no dey edit im own policy, so e no be learning.

One system fit get four taxonomy rows at the same time. Taxonomy useful pass as design checklist, no be label for the finished product. When system dey misbehave, the useful question na which layer get problem. Trigger wey fire for wrong event, state wey become stale, goal check wey no fit ever pass, and score wey dey reward wrong outcome na four different bugs, and each one get different fix.

Which type fit which work

• Fixed trigger, fixed response, and no history needed: simple reflex.
• The correct response depend on wetin happen before: model-based reflex.
• You fit check the final state, but you no know the path ahead of time: goal-based.
• Several outcomes fit work, but you get real trade-off between dem: utility-based.
• You need results to improve over time: build an eval loop, and accept say na you be the learning component.

You fit host these agents by yourself, and how much e go cost?

Yes, and the cost dey split into two parts. Orchestration cheap. An n8n instance or an agent loop for Python dey spend most of e time waiting for network calls, so 2 vCPU and 4 GB of RAM fit carry am. Na the model dey take the money.

If the agent dey call hosted API, the server need almost nothing and the bill dey scale with tokens. For goal-based agent, this mean say e dey scale with how many planning steps you allow, so cap the loop.

If you run the model for your own hardware, RAM go decide wetin you fit run at all. The figures below na typical published file sizes for 4-bit quantised weights as of August 2026, together with planning figure for total RAM, because the context window and the runtime both need extra space beyond the weights.

[
  {
    "label": "3B model",
    "weights_gb": 2,
    "ram_needed_gb": 6
  },
  {
    "label": "8B model",
    "weights_gb": 4.9,
    "ram_needed_gb": 10
  },
  {
    "label": "14B model",
    "weights_gb": 9,
    "ram_needed_gb": 16
  },
  {
    "label": "32B model",
    "weights_gb": 20,
    "ram_needed_gb": 32
  },
  {
    "label": "70B model",
    "weights_gb": 43,
    "ram_needed_gb": 64
  }
]

An 8B model for 4-bit na about 4.9 GB of weights, and a box with 10 GB of RAM fit run am without swapping. A 70B model for the same quantisation na 43 GB of weights and e need around 64 GB. Notice wetin those numbers no include: speed. For VPS wey no get GPU, an 8B model for 4-bit fit produce single-digit tokens per second. This dey okay for agent wey dey process queue overnight, but e go slow for anything wey person dey wait for. Keep local inference for batch work, and use GPU or API for the interactive parts. The shortlist of self-hostable AI agents cover which projects worth the disk space, and a study path for agents in 2026 cover wetin to learn and the order to learn am.

Wia taxonomy stop to help

E no talk anything about tools or permissions. The textbook agents dey perceive and act. Nobody wey write that chapter dey worry about agent wey hold production API token. Goal-based agent wey get shell access and goal-based agent wey get just one read-only database connection dey for the same row of the table, but the risk wey dem carry dey completely different. Decide wetin agent fit touch before you decide how clever e suppose be, and read how to keep secrets away from an AI agent before you give am credential.

E still no talk anything about wetin go happen when one step fail. Real agents dey spend most of their runtime to handle errors: rate limit, or tool wey return something wey model no expect. Na that code dey decide whether your system go usable, and no row for the taxonomy describe am.

FAQ

Wetin be the five types of AI agents?

Simple reflex, model-based reflex, goal-based, utility-based, and learning agents. Dem arrange dem according to how much the agent know before e act. Simple reflex agent dey see only the current input. Model-based agent dey keep state about e environment. Goal-based agent dey plan toward target state. Utility-based agent dey score several acceptable outcomes and pick the highest one. Learning agent dey change e own policy from feedback, but almost no self-hosted setup really dey do this.

Which type of AI agent I suppose use for simple automation?

Simple reflex agent. For practice, this mean webhook or schedule wey trigger fixed sequence. If the correct response depend only on the input wey just arrive, memory dey add failure modes without adding capability. Move to model-based design when you fit name one decision wey need know wetin happen before.

I fit run my own AI agents for VPS?

Yes. The orchestration layer dey light, so 2 vCPU and 4 GB of RAM fit run workflow engine or agent loop comfortably. The real decision na where the model go run. Hosted API keep the server small and move the cost to tokens. Local model need RAM according to e parameter count, and without GPU e dey generate single-digit tokens per second. This one suit queued batch work pass chat window.

Large language model be AI agent by itself?

No. Model dey map input text to output text, then e stop. E become agent when something wrap am inside loop wey fit act on the world and feed the result back into the loop. This need tools wey e fit call and condition wey tell the loop when to stop. The wrapper na the agent. The model na one component inside am.

I need multi-agent system?

Usually, no. One loop with several tools fit handle most work and e much easier to debug. Multiple agents dey help when parts of task truly independent and fit run at the same time, or when one part need different model. The cost na coordination: shared state, plus supervisor wey e context dey grow with every worker report wey e read. Add the second agent when you fit point to the step wey slow.