Agentic AI comes with its own vocabulary, and that vocabulary keeps shifting as the technology matures. This guide lays out the core terms in plain language: starting with what a model actually is, moving through how models are accessed and sized, and ending with how multiple agents get organized into working systems.

Key Takeaways

• A model is just a function: it transforms one kind of data into another. What varies is the input and output type, such as text to text (a language model), image to text (a vision model), or text to image (an image generation model).
• Open weight and closed describe access, not capability: whether a model's weights can be downloaded and run independently, or are only reachable through a provider's managed API.
• An agent differs from an AI feature mainly in autonomy. An AI feature responds to a person turn by turn, while an agent is handed a goal and works toward it on its own, connected to real systems like email, calendars, or databases.
• An agent harness is the orchestration layer around one or more agents, effectively an operating system for AI.
• A swarm is a fleet of agents with heavy communication and task sharing between them. A fleet on its own doesn't require that level of coordination.
• As a group of agents grows, defining agent roles and agent permissions becomes just as important as picking the underlying models.
• Organizations are splitting between vertically integrated agent stacks (one vendor, tightly integrated, less flexible) and model agnostic frameworks (more control, more assembly required). Both approaches are likely to coexist rather than one replacing the other.
• Guardrails, the built in limits on what a model or platform will do, are a normal part of working at the edge of a system's capabilities, not a sign that something has gone wrong.
• Token maxing, spending heavily on frontier model usage regardless of cost, is largely a phase that has already passed, replaced by more deliberate, cost aware architecture decisions.

What Is an AI Model?

At its core, a model is a function or software transformation: feed it an input, it hands back an output. Feed it an image, get back object labels, and that's an object recognition model. Feed it a sequence of words, get back the next word, and that's a large language model. The result of running that function is called inference. Most models in use today are neural network based, meaning their internal architecture is built from layers of interconnected nodes loosely modeled on neurons, but the underlying definition of a model doesn't require that.

Running a model takes two things: the software that executes it, and its weights and biases (also called parameters), a dataset of numbers that configures the software to behave the way it does. Having only one of the two doesn't produce a working model.

Common Types of AI Models

Models are generally named for the shape of their input to output transformation. Some of the most common types include:

• Large Language Model (LLM): Takes in text and generates text output. This is the transformation behind most chat style AI tools.
• Vision-Language Model: Takes in images, or a combination of images and text, and produces text output.
• Image Generation Model: Takes in text and produces an image as output, the reverse direction of a vision-language model.
• Video Generation Model: Takes in text or other input and produces video as output.
• Forecasting Model: Predicts a future value, such as a cash flow variance, based on patterns in past data. Many forecasting models are autoregressive, meaning they feed their own prior outputs back in as part of the input for the next prediction.
• Anomaly Detection Model: Flags data points or events that fall outside expected patterns.
• Object Recognition Model: Takes in an image and identifies the objects it contains.

Open Weight, Closed, and Frontier Models

Models differ not just in what they do, but in how they can be accessed. Open weight (or open source) models release their weights, and typically the software to run them, publicly, so anyone can download and run the model on their own hardware. Closed models keep their weights and/or software private. They run on the provider's own infrastructure and are treated as proprietary IP.

Closed models are typically reached through a managed API, a programmatic interface that lets other software call the model directly, or through a chat interface, where a person interacts with the model conversationally. Either way, the provider keeps the underlying software and weights on its own infrastructure.

Model size adds another axis. Frontier models are the largest and most sophisticated models available, producing the most capable output, but they typically require hardware that's prohibitively expensive for most organizations to host themselves. Smaller open models can be downloaded and run locally on whatever hardware is on hand, which is why teams facing hardware constraints often lean toward smaller, more specialized open models rather than frontier scale ones.

From AI Features to Agents

The amount of software sitting between a person and a model, sometimes called the business logic layer, can vary widely. In the simplest case, an AI capability is little more than a thin chat interface wrapped around a model: what a person types is nearly identical to what the model receives, and what the model outputs is nearly identical to what comes back. This is often described as AI embedded in software, a model plugged into an existing application with a thin layer of logic around it.

An AI application or AI feature builds on that same idea for one to one, turn based interaction with a person: they type something in, they get a response back, and the exchange repeats.

An agent is different mainly in its relationship to autonomy, meaning it can take a sequence of actions toward a goal without a person approving each individual step. Rather than waiting on a person for every step, an agent is handed a goal and works toward it on its own, typically wired into real systems. A personal agent might touch email, a calendar, or messaging apps. A company agent might touch systems like NetSuite, Workday, or a transactional database. This shift toward goal directed, autonomous software is what people mean by agentic (or agentics), widely considered the biggest change in the space over the past year.

Coordinating one or more agents is the job of an agent harness: the software system that manages what each agent does, how it accesses models, and how agents work together. It functions much like an operating system for AI.

Guardrails are the built in restrictions a model or platform enforces on what it will do or generate, often encountered when someone tries a novel or edge case task and the model declines or limits its response. Hitting a guardrail doesn't necessarily mean something has gone wrong. It's a normal part of working at the edge of what a given model or platform allows.

Fleets, Swarms, and Multi-Agent Architecture

Once more than one agent is in play, two related terms come up. A fleet is simply a collection of agents, each potentially with its own purpose, specialty, and access to different resources. It doesn't require tight coordination between them. A swarm is a fleet with heavy crossover communication and task sharing between agents: a swarm is usually a fleet, but a fleet is not necessarily a swarm. Multi-agent architecture is the broader design pattern of building systems around several agents, and often several models of different sizes and specializations, rather than routing everything through one model or one agent.

As a group of agents grows, two more decisions matter just as much as picking the models involved. Agent roles divide responsibility so that different agents focus on different specialties or parts of a task. Agent permissions set the level of autonomy and system access each agent is granted. Getting both right is what allows a group of agents to get meaningful work done inside defined boundaries, rather than each one needing constant human sign off.

A few concrete situations show where this kind of architecture earns its complexity:

1. Cybersecurity defense: when an organization is under active attack, breaches can surface across multiple systems faster than a human team can track. Assigning different agents to different parts of the defense, each responsible for its own slice, keeps pace with an attack that no longer waits for people to catch up.
2. Robotics and drones: physical agents operating in the real world need to handle mission objectives and safety at the same time, often without reliable contact back to a cloud provider, which pushes more decision making onto the agent itself rather than a central orchestrator.
3. Manufacturing and supply chains: a supplier notification can trigger one agent to flag a vendor problem, a second to research replacement vendors, and a third to draft the resulting purchase orders into a system like NetSuite, all without a person manually relaying information between steps.

Building a Digital Workforce: Vertical Stacks vs. Model-Agnostic Frameworks

One useful way to think about a growing team of agents is as a digital workforce, similar to how a Formula 1 pit crew works. Instead of one person handling many tasks, each crew member does exactly one thing, such as moving a single tire from one spot to another, and nothing else, which is how pit stops dropped from roughly twenty seconds to two. In a digital workforce, a team of agents plays that same role, each handling one task well, while the person overseeing them moves up a level to become the strategist, setting outcomes and goals rather than executing each task directly.

Building that workforce raises a structural question: how tightly should it be tied to a single vendor? A vertically integrated agent stack is an opinionated, all in one setup where one vendor supplies the compute, the models, the agent harness, and the interface together. Think of agent features built directly into a platform like Google Workspace or Microsoft 365, or cloud provider offerings such as AWS's Agent Core or IBM's Watson branded agent tools. These are convenient and tightly integrated, but locked to that vendor's roadmap, pricing, and platform choices.

The alternative is a model agnostic agent framework: an open harness, such as LangGraph, Pydantic AI, Hermes Agent, or OpenClaw, where the underlying model, the brain, is interchangeable. A closed model, an open one, or several can be swapped in without being locked into a single vendor's full stack. Both approaches tend to persist rather than one winning out. Vertical stacks fit well for tasks already anchored in a specific ecosystem, while a vendor agnostic digital workforce protects an organization's flexibility, intellectual property, and ability to pivot under market or vendor pressure.

A useful comparison here is a business's relationship with a consulting firm. Firms like Accenture or McKinsey bring a highly opinionated way of getting things done, and plenty of businesses hire them for specific engagements, but almost no company staffs its entire workforce through a single consulting firm. That's partly a cost issue, and partly because doing so would leave the business with little of its own distinct value or control. The same logic applies to a digital workforce: leaning on a single vendor's opinionated stack for everything trades away flexibility, intellectual property, and the ability to pivot if that vendor's pricing or priorities change.

One trend that has largely already run its course is token maxing, a period of spending heavily on frontier model usage regardless of cost. The current mindset has shifted toward finding the most cost effective architecture that still gets the job done, and with the right guardrails and policy enforcement at runtime, rather than maximizing usage of the most powerful model available.

The Agentic Economy and the Rise of the AI Strategist

The combined effect of more capable models, more autonomous agents, and organizations rethinking how their workforce is structured is sometimes called the agentic economy: a shift happening gradually across global business, creating a growing competitive advantage for organizations that adopt agentic systems early, and a growing disadvantage for those that don't.

Making sense of the resulting choices, which models, which agents, which stack, for which task, has become enough of a distinct discipline that a new kind of role has emerged: the AI strategist, someone whose job is to match the right combination of models, agents, and architecture to a business's specific needs inside an increasingly complex and fast moving ecosystem.

Frequently Asked Questions

Is a swarm the same thing as a fleet of agents?

No. A fleet is just a group of multiple agents, each potentially with different purposes and access. A swarm is a fleet where the agents communicate heavily and share tasks with each other. Every swarm is a fleet, but not every fleet reaches the level of coordination that makes it a swarm.

What actually separates an agent from an AI feature?

Autonomy. An AI feature, like a chat interface, is built for turn based interaction: a person prompts it, it responds, they prompt again. An agent is given a goal and works toward it on its own, connected to real systems, without needing a person to approve every step.

What is the difference between agent roles and agent permissions?

Agent roles describe what an agent is responsible for, such as a specific task or area of specialty within a larger system. Agent permissions describe what an agent is allowed to do or access while carrying out that role. Together they set the boundaries within which a group of agents can operate with autonomy.

Should a business build on a vertically integrated agent stack or a model agnostic framework?

There isn't a single right answer. Both approaches tend to coexist. A vertical stack, for example agent features built into Google Workspace or Microsoft 365, makes sense when the work already lives inside that ecosystem. A model agnostic framework tends to make more sense for a company's core digital workforce, where flexibility, cost control, and the ability to pivot away from a single vendor matter more.

Are multi-agent systems just a workaround for models that aren't good enough yet?

Not really. That framing treats two different problems as one. Even as individual models improve, multi-agent architectures solve a separate problem: breaking work into specialized, coordinated pieces. Multi-agent systems are expected to become so pervasive that they eventually stop being a distinct topic of conversation at all.

How should a team evaluate its own agentic AI efforts?

Start small and iterate quickly rather than committing to one architecture up front. Be deliberate about vendor lock in, since a single vertical integration changing its terms can disrupt a business that depended on it, and go in with a backup plan, or several, since hitting model limitations and guardrails along the way is expected, not a sign something has gone wrong.

Quick-Reference Glossary

Every term covered above, in one place:

Agent. A piece of software tasked with accomplishing a goal in the world, typically with some degree of autonomy and access to real systems such as email, calendars, or business databases.

Agent Harness. The software system that manages and orchestrates one or more agents, including how they access models and how they work together. Functions much like an operating system for AI.

Agent Permissions. The level of autonomy and system access granted to a given agent.

Agent Roles. The division of responsibility across multiple agents, so each one focuses on a specialty or part of a larger task.

Agentic / Agentics. The shift toward goal directed, autonomous software, as opposed to software that only responds turn by turn to a person.

Agentic Economy. The gradual, global shift in business created by the adoption of agentic AI, which creates competitive advantage for early adopters and disadvantage for those who lag behind.

AI Application / AI Feature. A model powered capability built for one to one, turn based interaction with a person, such as a chat interface or a single prediction feature.

AI Embedded in Software. A model plugged into an existing application with a thin layer of logic around it, rather than a standalone system pursuing a goal on its own.

AI Model (Model). A function or software transformation that converts one kind of data into another, such as text into text, or an image into a set of labels.

AI Strategist. A role focused on matching the right combination of models, agents, and architecture to a business's specific needs.

Anomaly Detection Model. A model that flags data points or events that fall outside expected patterns.

Autonomy. The ability of an agent to take a sequence of actions toward a goal without a person approving each individual step.

Autoregressive Model. A model, often used for forecasting, that feeds its own prior outputs back in as part of the input for its next prediction.

Business Logic Layer. The software and logic sitting between a person (or system) and a model, which can range from a thin chat wrapper to a much more complex application.

Chat Interface. A conversational way of accessing a model, where a person types input and receives a response directly.

Closed Model. A model whose weights and/or software are not publicly released. Typically reached only through a managed API or chat interface controlled by the provider.

Digital Workforce. A team of agents, each handling a specific task well, that a person oversees at a strategic level rather than performing each task directly.

Fleet. A collection of multiple agents, each potentially with its own purpose, specialty, and access to different resources, without necessarily requiring tight coordination between them.

Forecasting Model. A model that predicts a future value based on patterns in past data.

Frontier Model. The largest and most sophisticated class of model available, producing the most capable output, but typically requiring expensive hardware to run.

Guardrails. The built in restrictions a model or platform enforces on what it will do or generate.

Image Generation Model. A model that takes in text and produces an image as output.

Inference. The output produced when a model is run on a given input.

Large Language Model (LLM). A model that takes in text and generates text output.

Managed API. A programmatic interface, hosted and controlled by a provider, used to call a closed model directly from other software.

Model-Agnostic Agent Framework. An open agent harness in which the underlying model can be swapped in and out, rather than being locked to one vendor's stack.

Multi-Agent Architecture. A system design built around multiple agents, and often multiple models of different sizes and specializations, working together.

Neural Network-Based Model. A model whose internal architecture is built from layers of interconnected nodes loosely modeled on neurons.

Object Recognition Model. A model that takes in an image and identifies the objects it contains.

Open Weight / Open Source Model. A model whose weights, and typically its software, are publicly released so it can be downloaded and run independently.

Programmatic Interface. A way of accessing a model through code, rather than through a conversational chat interface.

Swarm. A fleet of agents with heavy crossover communication and task sharing between them.

Token Maxing. A period of spending heavily on frontier model usage regardless of cost, largely superseded by more cost aware architecture decisions.

Vertically Integrated Agent Stack. An opinionated, all in one setup where a single vendor supplies the compute, models, agent harness, and interface together.

Video Generation Model. A model that takes in text or other input and produces video as output.

Vision-Language Model. A model that takes in images, or a combination of images and text, and produces text output.

Weights and Biases (Parameters). The dataset of numbers that configures a model's software to behave the way it does.