From Rules to Self-Improving: 5 AI Agent Archetypes (With Practical Examples)

“AI agent” is one of those terms that gets used for everything—from a simple chatbot to a system that can plan, act, and improve.

If you’re building anything serious (like a website support + sales assistant), the difference matters.

Because not all agents decide the same way.

Some agents just react.
Some remember.
Some plan.
Some optimize trade-offs.
And some learn over time.

This guide breaks down five widely used agent archetypes (often described as the “types of AI agents”), with examples you’ll recognize and a simple way to choose the right approach for your product.

---

What makes something an AI agent (not just an AI model)?

A language model generates text.

An agent is a system that:

• observes an environment (messages, clicks, CRM data, catalog, policies),
• decides what to do next (answer, ask, fetch info, route, escalate),
• and acts (responds, triggers a workflow, updates a system).

If it can’t take actions (or at least choose between actions), it’s usually not an agent—just a chat UI on top of a model.

---

The agent loop (the simplest mental model)

Every agent, no matter how advanced, boils down to:

1) Sense: read signals (user message, page URL, cart items, account status)
2) Decide: pick the next step (answer / ask a clarifying question / handoff / trigger tool)
3) Act: execute (respond, fetch data, open ticket, log lead)
4) Update: store state/feedback (optional)

The “types” below differ mainly in how the Decide step works.

---

The 5 AI agent archetypes (Rules → Learning)

1) Rule / Reflex Agents (fast reactions, no memory)

How it decides: “If X, then do Y.”
No context. No history. No planning.

Real examples

• Simple keyword chat (“refund” → show refund policy)
• Website popups triggered by behavior (“exit intent” → show offer)
• Basic ticket routing rules (“billing” → finance queue)

Where it shines

• Predictable, repetitive flows
• Low risk answers (hours, contact info, shipping policy link)

Where it breaks

• Anything ambiguous (“I was charged twice” vs “I want a refund”)
• Anything that needs context (“the same issue as yesterday”)

If you’re building Whizzy-like experiences

• Use this for triggers + guardrails (when to show chat, when to escalate, what never to guess)

---

2) Stateful / Model-Based Agents (react + remember)

How it decides: reacts like a reflex agent, but keeps an internal state (a lightweight memory of what happened).

Real examples

• A support bot that remembers your order ID in the conversation
• A shopping assistant that remembers preferences (“no leather”, “under ₹3,000”)
• Systems that keep track of steps completed in a flow

Where it shines

• Multi-turn conversations where the user doesn’t repeat details
• Any flow with steps: identify → diagnose → resolve → confirm

Where it breaks

• If the stored state is wrong or stale (agent assumes something that changed)

Whizzy mapping

• Session memory: current page, cart contents, last user intent
• Safe “short memory” beats pretending to know everything

---

3) Goal-Driven Agents (plan to reach an objective)

How it decides: chooses actions based on a goal (“resolve the issue”, “book a demo”, “help user pick a plan”).

It doesn’t just answer—it can sequence steps.

Real examples

• A travel assistant that plans an itinerary
• A support agent that follows a troubleshooting path
• A “setup assistant” that gets you from signup → live widget

Where it shines

• Workflows with an end state
• Tasks that require multiple actions (ask → fetch → confirm → proceed)

Where it breaks

• When the goal is vague (“make my business better”)
• When it lacks tools/data to act (it can plan but can’t execute)

Whizzy mapping

• “Goal: resolve shipping ETA” → ask order ID → fetch status → explain → offer next step
• “Goal: qualify lead” → ask 2–3 questions → capture details → route

---

4) Utility / Trade-off Agents (optimize, don’t just reach a goal)

How it decides: assigns scores to outcomes and picks what’s best overall, not just “good enough.”

This is where you balance things like:

• speed vs accuracy
• automation vs human handoff
• strict policy vs customer delight

Real examples

• Product ranking systems (“best for budget + durability”)
• Smart routing (“send VIP customers to human faster”)
• Dynamic recommendations (optimize conversion + satisfaction)

Where it shines

• When multiple “correct” actions exist
• When you want consistent decisions under uncertainty

Where it breaks

• If your scoring logic is wrong (garbage score → garbage decisions)

Whizzy mapping

• Decide whether to: answer instantly, ask one question, or escalate
  based on confidence, policy sensitivity, and customer value.

---

5) Learning Agents (improve with feedback over time)

How it decides: uses feedback loops to get better—either by updating rules, tuning prompts, improving retrieval, or retraining components.

Real examples

• Recommendations that improve as you watch/click
• Fraud detection that adapts to new patterns
• Support bots that reduce escalations over time by learning what failed

Where it shines

• Environments that change (policies, product catalog, common issues)
• Teams that can review conversations and feed improvements

Where it breaks

• If feedback is noisy or biased
• If “learning” is left unattended (it drifts)

Whizzy mapping

• Weekly review of “failed” chats → add missing docs → fix prompt → add guardrails
• Use thumbs-up/down and “was this helpful?” to prioritize improvements

---

Which agent type do you actually need?

Ask these four questions:

1) Is the environment predictable?
Yes → reflex/stateful may be enough.
No → goal/utility helps.

2) Do you need multi-step flows?
Yes → goal-based.
No → stateful + good retrieval might be enough.

3) Are there trade-offs (risk, policy, user value)?
Yes → utility-based decisioning (even simple scoring rules help).

4) Will the content change often?
Yes → you need a learning loop (even if “learning” is just continuous improvement + retraining).

Rule of thumb:
Start with stateful + goal-based, then add utility scoring for routing, and a learning loop for improvement.

---

How this maps to a website agent like Whizzy

A strong website agent is usually a hybrid system:

• Reflex layer: triggers, safety rules, hard “don’t guess” constraints
• State layer: session memory (page, cart, last question, chosen plan)
• Goal layer: guided flows (resolve issue, recommend product, capture lead)
• Utility layer: decide when to ask vs answer vs escalate
• Learning layer: transcript review, retraining, gap tracking, KPI improvement

That’s how you get an assistant that feels fast and reliable.

---

Closing thought

“AI agent” isn’t a single thing.
It’s a spectrum—from reactive automation to self-improving systems.

Pick the simplest type that can solve your real problem today, then layer in planning, scoring, and learning only where the ROI is obvious.