Every type of AI agent explained (and when to use each one)

AI agents are everywhere right now. New frameworks launch almost daily, each promising to automate your work, run on autopilot, and act like a digital team. But most of them sound the same from the outside, and it’s hard to know what actually matters or which one to use.

This guide cuts through the noise. You’ll learn what an AI agent really is, the core building blocks they all share, and how six powerful open-source agent frameworks compare in practice—so you can match the right agent to the right job.

What an AI agent actually is

Chatbots and agents are not the same thing.

A chatbot answers a question and stops. You ask, it replies. End of story.

An AI agent is given a goal and keeps working until that goal is done. It decides what step to take next, executes that step, checks the result, and then plans the next move—repeating this loop autonomously.

In other words, a chatbot is reactive; an agent is proactive and goal-driven.

The core building blocks of any AI agent

Even though agent frameworks look very different on the surface, under the hood they’re made of the same basic components. Understanding these pieces makes it much easier to compare tools.

The model: the agent’s “brain”

The model is the large language model (LLM) that powers the agent’s reasoning and generation. This could be Claude, GPT-style models, DeepSeek, Gemini, a local LLM, or a mix of several.

Most modern frameworks let you:

• Swap models in and out
• Use different models for different tasks (e.g., a cheaper model for routine work, a stronger one for complex reasoning)

Tools: the agent’s “hands”

Tools are how the agent interacts with the outside world. Examples include:

• Running code or shell commands
• Browsing the web and calling APIs
• Reading and writing files
• Sending messages and emails

Many frameworks now support tool standards like MCP and CLI-based tools, so you can plug in almost anything your workflows require.

Memory: what the agent can remember

Memory determines how much context the agent can retain over time: past actions, user preferences, previous tasks, and long-running projects. Different frameworks implement memory very differently—and this is one of the biggest factors separating simple agents from truly useful ones.

If you want to go deeper on this topic, it’s worth understanding the four types of memory every AI agent needs and how they show up in real systems.

Interface: how you talk to the agent

The interface is simply where and how you use the agent. Common options include:

• Web dashboards
• Terminals and CLIs
• Chat apps like Telegram, WhatsApp, Slack, or Discord
• Desktop apps

The same engine can feel completely different depending on whether you access it from a browser, your phone, or your IDE.

Runtime: where the agent actually runs

Finally, you need to decide where the agent lives:

• Your laptop – free and easy to try, but not isolated, and the agent dies when your machine is off.
• Dedicated local hardware (e.g., a Mac mini) – powerful but expensive and more complex to manage.
• Virtual Private Server (VPS) – cheap, isolated, always-on, and easy to wipe if something goes wrong.

For agents that are meant to run 24/7 in the background, a small VPS is usually the best balance of cost, safety, and reliability.

Why open-source agents matter

This guide focuses on open-source agent frameworks. That means:

• You’re not locked into a single company’s ecosystem or pricing.
• You can choose your own models, tools, and infrastructure.
• You can audit and customize the code.

Closed systems like proprietary “agent modes” inside big-model platforms can be powerful, but you’re tied to their pricing, policies, and feature roadmap. Open-source agents give you much more control and are better suited for serious long-term workflows.

Security considerations for always-on agents

Autonomous agents often get access to:

• API keys
• Your file system or repositories
• The open internet

That makes security non-negotiable. You should:

• Run agents in isolated environments (containers, separate VPS instances, or sandboxes)
• Limit what each agent can access (principle of least privilege)
• Rotate and scope API keys
• Monitor logs and usage

If you’re planning to deploy multiple agents that touch sensitive data or systems, it’s also worth looking at broader security frameworks such as CAI, an all-in-one AI cybersecurity framework.

How to host and deploy AI agents

Most of the agents covered here are designed to run on a VPS using containers (often Docker). A typical setup looks like this:

• Pick a VPS plan (even $6–$10/month is enough for many agents).
• Use a prebuilt image or one-click installer where available.
• Configure environment variables (API keys, model providers, database URLs).
• Secure the instance (firewalls, SSH keys, HTTPS, etc.).

Once deployed, you can often manage everything from a web dashboard: view logs, open a terminal, restart containers, and access the agent’s UI.

OpenClaw: a personal assistant in your existing chats

Best for: a simple, always-on assistant you can message from apps you already use.

OpenClaw is a personal AI assistant that lives inside chat apps like WhatsApp, Telegram, Slack, Discord, Signal, and more. The chat channels come first; the agent sits behind them.

You rarely need to touch the dashboard. Instead, you:

• Pair your chat app (e.g., Telegram) with the agent.
• Message it like a human assistant.
• Optionally set up automations and scheduled tasks (cron-like jobs).

OpenClaw also supports a large plugin ecosystem, with hundreds of integrations you can enable from its dashboard.

Pros:

• Fast to set up and start using.
• Works with many models via providers like OpenRouter.
• Huge community and lots of existing integrations.

Cons:

• Doesn’t really “learn” or improve on its own over time.
• Complex setups with many channels and skills can get messy.
• Historically had a large attack surface; early versions saw real-world vulnerabilities.

Use OpenClaw if you want a chat-first assistant that can run a few recurring tasks and answer ad-hoc questions from your phone or chat apps. Skip it if you need deep learning of your workflows or long-term self-improvement.

Hermes: a self-improving, workflow-learning agent

Best for: recurring workflows that you want an agent to get better at over time.

Hermes looks similar to OpenClaw on the surface, but it’s built around a different idea: a learning agent that evolves its own skills.

After Hermes finishes a task, it:

• Reviews what it did and what worked.
• Saves that process as a “skill” (a simple markdown file).
• Reuses and refines that skill the next time you ask for something similar.

For example, if you ask Hermes to create a weekly YouTube idea brief, it will:

• Do the research and generate the brief.
• Save the process as a reusable skill.
• Use that skill to run the task faster and cheaper next time.

Hermes also maintains richer long-term memory about you—your preferences, projects, and context—stored in files it can search and update.

Pros:

• Self-evolving skill system that gets more efficient with use.
• Stronger long-term memory than basic assistants.
• Great fit for power users who run similar workflows every week or month.

Cons:

• More setup and more ongoing interaction required to get the most out of it.
• Can “teach itself” bad habits if you don’t review or correct skills.

Use Hermes if you have recurring, evolving workflows (content creation, research, reporting, ops) and want an agent that learns your style. Skip it if you just need a quick assistant with minimal configuration.

Agent Zero: a general-purpose agent with its own computer

Best for: complex, open-ended tasks that require coding, data processing, or custom tools.

Agent Zero gives the agent its own Linux machine inside Docker. Instead of shipping with a huge list of prebuilt tools, it often:

• Writes the tools it needs on the fly (scripts, programs).
• Runs them in its own terminal inside the sandbox.

For example, you can ask it to build a research report based on what developers are saying about AI on Hacker News over the last 30 days. Agent Zero can:

• Spin up sub-agents (writer, analyst, data collector).
• Write code to scrape or query data.
• Analyze the results and assemble a final report.

Everything happens inside its isolated environment, separate from your main server.

Pros:

• Very flexible and powerful for technical, multi-step tasks.
• Transparent: you can see what each sub-agent is doing.
• Sandboxed: safer for running code, shell commands, and experiments.

Cons:

• Can wander or overcomplicate vague tasks.
• Token-hungry, since it often writes and reasons about code.
• No built-in “text me from my phone” experience—you’d need to wire that up.

Use Agent Zero if you want a powerful, general-purpose agent that can use its own computer to solve big, fuzzy problems. Skip it if you just want a quiet background assistant running simple scheduled jobs.

OpenHands: an AI software engineer for your GitHub repos

Best for: turning GitHub issues into real pull requests on an existing codebase.

OpenHands (formerly OpenDevin) is built specifically as an AI software engineer. You connect it to a GitHub repository, give it tickets or issues, and it works in a sandbox to produce a pull request.

For example, you might ask it to:

• Migrate a to-do list API to SQLite.
• Add tags and search.
• Add a delete endpoint.
• Write tests for everything.

OpenHands will:

• Plan the work.
• Modify the code in its sandbox.
• Run commands and tests in a terminal.
• Open a PR with all the changes.

You can inspect the code changes, terminal logs, and browser output directly from its interface.

Pros:

• Excellent end-to-end coding performance for scoped tasks.
• All work stays inside your environment; only model calls leave.
• Supports multiple models and parallel sandboxes.

Cons:

• Focused on coding only; not a general-purpose assistant.
• Heavier on resources; needs a more capable VPS plan.
• Best with well-defined tickets, not vague “build me an app from scratch” prompts.

Use OpenHands if you have a backlog of GitHub issues and want autonomous help shipping features and fixes. Skip it if you prefer coding side-by-side with AI inside your editor.

Paperclip: a company of agents working toward one goal

Best for: orchestrating many agents as if they were a full company.

Paperclip doesn’t focus on doing the work itself. Instead, it manages other agents like a manager or COO.

You start by:

• Defining a company (e.g., “Agent Builders HQ”).
• Setting a high-level goal (e.g., get 1,000 new members into a community).
• “Hiring” a team of agents with different roles (CEO, engineer, researcher, etc.).

Paperclip lets you:

• Configure which models each agent uses.
• Set spending limits and budgets per agent.
• See an org chart and task assignments.

Tasks flow through an inbox, get broken into subtasks, and are assigned to different agents. You can view dependency graphs, blocking tasks, reviewers, and more. Agents can even hire additional agents if needed.

Pros:

• Extremely autonomous and scalable across many tasks.
• Great for long-running projects with many moving parts.
• Budget and org-structure controls built in.

Cons:

• Complex to configure effectively; easy to get lost in the orchestration.
• High token usage if you let a large “company” run continuously.
• Best results often require careful prompt design and constraints.

Use Paperclip if you want a network of agents working semi-independently toward a big shared goal. Skip it if you’re just starting with agents or have a tight token budget.

Buzz: a shared workspace for humans and agents

Best for: teams that want agents embedded into their daily collaboration.

Buzz, from Block, is like a self-hosted Slack where agents are teammates. Buzz itself is not the agent—it’s the shared workspace that connects humans and agents.

In Buzz, you can:

• Create channels like you would in Slack.
• Add multiple agents with different roles, personalities, and model providers.
• Include external agents (for example, an OpenClaw-based assistant) inside channels.

Humans and agents can:

• Chat in channels.
• Reply in threads.
• Delegate tasks to each other.

This only becomes powerful if your team actually uses Buzz as a real workspace. Over time, you end up with a mixed human–agent team collaborating in the same place.

Pros:

• Brings agents into your team’s daily communication flow.
• Supports different agent types and providers in one space.
• Great for multi-agent, multi-human collaboration.

Cons:

• Very new; still early-stage and evolving.
• Doesn’t do anything without agents plugged in.
• Not worth it if you’re working solo or don’t need structured channels.

Use Buzz if you have a team and want agents to participate in projects as first-class collaborators. Skip it if you’re solo or not planning to centralize your communication.

How to choose the right AI agent framework

Here’s a quick way to decide which agent to start with based on your main need:

• “I want a personal assistant in my existing chat apps.”
  Use OpenClaw.
• “I have recurring workflows that I want to get better and faster over time.”
  Use Hermes.
• “I need a general-purpose agent that can ‘go do this on a computer’.”
  Use Agent Zero.
• “I have coding tickets and want actual pull requests back.”
  Use OpenHands.
• “I want many agents working together like a company.”
  Use Paperclip.
• “I want my whole team and our agents in one shared workspace.”
  Use Buzz.

All of these frameworks are open source, and all of them can be deployed on affordable VPS instances. The best one for you depends less on raw capability and more on where you live (chat apps vs. GitHub vs. Slack-like workspaces) and how structured your tasks are.

If you’re unsure where to start, a self-improving assistant like Hermes is often the most practical day-to-day choice, with specialized tools like OpenHands or Agent Zero added later for coding-heavy or complex technical work.