An agentic system is the way a company hands repetitive prep work over to AI agents: a note before a client call, a draft proposal, a follow-up after a meeting, a daily review. The agents do this work on the company's knowledge and record the result, and a person decides what happens to that result next. In this post we explain what an agentic system is, what it isn't, and how to tell whether your company needs one. We write as a company that runs on such a system itself.
What is an agentic system: a definition in three sentences
An agentic system is a set of AI agents assigned to specific company processes, such as preparing for calls, proposals and follow-ups. The agents work on a shared company knowledge base and record their results in it, and a person's corrections become rules for next time. Every step that can't be undone, such as sending an email to a client, is approved by a person.
The key word in this definition is "system". A single AI agent can write an email. The system makes sure that email is built from knowledge about the client, in the company's style, taking earlier corrections into account, and that it reaches the person who will approve and send it.
What the team sees is described in six points on the agentic system page: knowledge base, agents, skills, rules, task register, approval. Underneath, there are more parts at work. Below we show what the whole system is made of and how those parts work together.
Agent, skill, rule: three terms worth telling apart
- An agent is a specialized "employee" assigned to a process. The proposals agent doesn't do the daily review, just as a salesperson doesn't do the bookkeeping.
- A skill is a process described step by step: where the agent gets its data, what it checks, what the output looks like. It's the same instruction a new employee would get.
- A rule is a recorded correction. If a salesperson deletes the same sentence from a proposal three times, the rule makes sure they won't see it a fourth time.
Thanks to rules, the system fits the company better over time. That's why a sensible measure of its quality is the share of proposals a person approves without corrections. This is a way of measuring, not a promise of a specific result: in every company this number starts from a different place.
What an agentic system is made of: 24 components
The system we implement, and run on ourselves, has 24 components in its specification. Each one is responsible for one thing and has a documented description of what it produces, what its contract with the rest of the system is, and what it depends on. Grouped by what they are responsible for, they look like this:
| What they are responsible for | Components |
|---|---|
| How the system thinks | core rules loaded at the start of every session · company knowledge in files · stores of rules learned from corrections · roles, meaning agents responsible for their own area · people register: who is responsible for what and how they want to be addressed |
| What it works with | skills (procedures loaded when needed) · tools, meaning scripts for everything a language model shouldn't be doing |
| Work and its trail | task register · housekeeping tasks the system runs on itself · process state recorded as "what is true now" · log of events worth auditing |
| Consistency of work | session lifecycle: start, work and close, after which the next session knows where the previous one left off · synchronization across several computers and parallel sessions |
| Quality and control | gates and steering · diagnostics and run cost · quality evaluation and learning from corrections · the "pulse", meaning system state calculated without the model · register of what breaks when maintenance is skipped |
| For whom and about what | guiding the user through the work · the company domain and "boxes" of ready-made processes (the first one is sales) · the specification and generator the system is built and updated with |
| Contact with people and time | channels the system uses to send messages and wait for replies · rhythms and schedule, meaning processes run at fixed times |
| On our side | deployment register, releases and support, meaning what we need to maintain many deployments at once |
None of these components is new on its own. They only become a system together: rules are loaded at the start, gates enforce the rules, a person's corrections turn into new rules, and the pulse shows whether everything works. Three of these mechanisms are what most often separates an agentic system from "an agent in a chat": hooks, gates and judges.
Hooks: what must always happen
A rule written in an instruction is only a request to the model. The model can forget it, especially in a long session. A hook is a Claude Code platform mechanism that runs a script at a specific moment: at session start, before a tool is used, after a file is saved, before changes are committed to the repository. It works regardless of whether the agent remembers, and it costs nothing, because it doesn't involve the model.
In our setup, hooks load the current rules at session start and check changes before they reach the knowledge base. A hook is not suited to work that requires judgement or takes a long time, though. In that case it at most leaves a trace, and a separate process does the actual work.
Gates: stopping before a step that can't be undone
A gate is a point in a process before an expensive or irreversible action: sending a message, writing to an external system, publishing. Each gate has its own row in the register: what it protects, who rules on it, and which incident it came from. One of three reviewers can rule, always the cheapest one that can handle it:
- A script, when the rule can be checked mechanically: does the file have the required fields, does the quote really appear in the source, do the numbers add up. A script is many times cheaper than a model checking a model, and it gives the same result every time.
- A judge, when the rule requires understanding meaning, but is already mature and no longer changes.
- A person in all other cases, and always for decisions that belong to them alone, such as sending a proposal to a client.
There is also a principle that a generator is never its own judge. The agent that wrote a message doesn't assess whether it's good. Someone else does: a script, a judge or a person.
Judges: a narrow model that enforces one rule
A judge is a language model with one task: it checks whether the output meets one specific rule, for example whether a claim in a proposal follows from what was agreed in the meeting. It doesn't write or correct anything, it only gives a verdict. Before it gets a place in a process, it passes a test on cases a person has already assessed, and it gets certified for the exact wording of that rule. When the rule changes, the judge loses its certification and a person holds the gate again until the judge passes the test anew.
This means a person doesn't have to read everything. The judge filters out outputs that break verified rules, and the person decides on what really needs their judgement.
Why combining the components saves limits
Agents on Claude Team work within the subscription limits, so every unnecessarily loaded file and every unnecessary model call means less work done during the day. The components are arranged so that the model only does what nothing cheaper can do:
- anything that can be calculated or checked against a rule is done by scripts, hooks and the pulse, without the model,
- skills and knowledge are loaded when they are needed, in a fixed order: state first, then the map, details last,
- roles refuse work outside their area instead of loading more files,
- diagnostics measure what went into the context and what a run cost, broken down by skills, hooks, tools and files, so unnecessary cost shows up in the numbers.
The same result can be achieved with less usage, because each component takes off the model work it doesn't need to do.
Agentic system vs multi-agent system
In the literature and among software vendors for large companies, you'll come across the term multi-agent system, meaning a network of agents that cooperate and pass tasks to each other. SAP describes them (in Polish) from the angle of architecture and enterprise use cases. When we talk about an agentic system in a small or mid-sized company, we mean something simpler: a few agents, a shared knowledge base, rules and human approval. The number of agents is not the goal here. The goal is for the work to be done and checked.
What an agentic system isn't
Most misunderstandings come from lumping three different things together: chatbots, automation and agents.
| Chatbot | Automation (Make, Zapier, n8n) | Agentic system | |
|---|---|---|---|
| What it does | answers a question | runs a predefined flow | runs a process that requires judging content |
| Memory | usually ends with the conversation | moves data between fields | records results and agreements in the company knowledge base |
| When the data is unusual | guesses or redirects | stops on an error or does something unintended | prepares a proposal and shows it to a person |
| Who sends to the client | — | often the automation, on a person's behalf | a person, after reading it |
A chatbot is good when someone has a question and needs an answer. When the conversation ends, the work ends too. Nobody has to approve anything afterwards, but nothing stays in the company either.
Automation in Make, Zapier or n8n is good when the flow is always the same: a form goes to the CRM, an invoice to a folder, a notification to the team channel. It works less well where someone has to read meeting notes, understand what the client wants, and write a proposal. You can build an automation with an AI model inside, too, but then the question is: who checks the output before it goes to the client?
Another subscription with a dashboard isn't an agentic system either. The system we build runs on Claude (Anthropic) and on the company's files. The team doesn't log in to a new tool; it works in Claude, which it already uses, and the agents use the same knowledge as the people.
When a chatbot or Make is enough, and when you need an agentic system
A simple test has three questions:
- Does the work require reading and writing content, not just moving data? If not, automation is enough.
- Does the output depend on the client's context: earlier conversations, agreements, order history? If not, a chatbot or a template is often enough.
- Does the output have consequences outside the company: does it reach the client, change terms, create a commitment? If so, you need an approval step that ordinary automation doesn't provide.
Three "yes" answers mean a process for an agentic system. Most often these are call preparation, proposals and follow-ups, which is the work that takes up most of the time of salespeople and owners of service companies outside the conversations themselves.
What a working day with an agentic system looks like
The easiest way to understand an agentic system is through one day in a B2B service company.
In the morning an agent prepares the daily review: tasks with deadlines, meetings, matters waiting for a reply. A person reads it instead of going through five tools.
Before a meeting the salesperson gives the company and person's name. The agent checks what the company already knows about this client, adds public information and prepares a short note: who we're talking to, what we agreed earlier, what is worth asking.
After the meeting the notes or transcript go to the agent, which pulls out the agreements and tasks, records them against the client and prepares a draft follow-up. The salesperson reads it, fixes it and sends it.
For a proposal the agent puts together a draft based on the agreements, the price list and earlier proposals. A person checks the scope and prices, because they are the one committing the company.
When a new person joins, they have access from day one to the same knowledge base as the agents, so they don't have to ask colleagues about everything.
In each of these steps the agent does the prep work, and the person stays with the conversations and decisions. We run our own company on such a system: sales, proposals, the daily review and publishing. We'll describe what it looks like from the inside in a separate post.
Control: the agent prepares, a person sends
The question we hear most often is: will the agent send an email to the client on its own? In the system we build, no. This is not a limitation of the technology but a principle: nothing goes out to a client without a person.
The agent can, on its own:
- gather and organize information,
- write drafts of emails, proposals and follow-ups,
- record agreements and tasks,
- prepare summaries and reviews.
We leave the decision to a person wherever a step is irreversible or commits the company: sending a message to a client, submitting a binding proposal, changing terms of cooperation, legal and financial decisions. This is not about distrusting the agents. It's about making sure there is always a specific person responsible for what the company tells its clients. A similar human-in-the-loop approach is described by, among others, Certusoft (in Polish).
When a company needs an agentic system
An agentic system makes sense when three situations keep coming up in a company:
- Sales depends on the time of a few people. The owner or two salespeople hold the conversations, but in between they spend hours on preparation, proposals and trying to remember what was promised to whom. Hiring another person means months of onboarding.
- Client knowledge lives in heads and inboxes. When someone is on holiday, nobody knows where a conversation left off.
- The team has already tried AI, but "the AI answers, it doesn't work". People use Claude or ChatGPT for individual pieces of text, explaining the context from scratch every time.
If you recognize at least two of these situations in your company, an agentic system can take over the prep work so people have more time for client conversations. It won't replace salespeople, and we don't promise a specific percentage increase in sales. It changes what salespeople have time for.
Where to start
With one process, not the whole company. The best process to start with:
- repeats every week,
- takes time from the person whose time is most expensive,
- has an output that is easy to judge ("this proposal is good or it isn't").
In service companies, this is most often call preparation or follow-ups after meetings. The implementation starts with a meeting where we choose that first process. What happens next and how much it costs is described on the agentic system implementation page. You'll also find the next steps and the most common mistakes in the post on implementing Claude in your company.
Frequently asked questions
How is an agentic system different from a chatbot?
A chatbot answers a question and usually doesn't remember the conversation. An agentic system runs a process, for example preparing a proposal, records the result in the company knowledge base and hands it to a person for approval.
How is an agentic system different from automation in Make or n8n?
Automation runs a fixed flow, often sending something on a person's behalf. An agentic system does work that requires reading and writing content, and the output waits for approval. Both can run side by side in a company.
Does an AI agent send emails to clients on its own?
Not in the system we implement. The agent prepares the email, and a person reads it, corrects it and sends it. Every step that can't be undone requires approval.
What does an agentic system run on?
On Claude by Anthropic, on the Team plan, and on the company's files. The team doesn't need a new dashboard. Current plan prices are on the Claude pricing page.
How much does an agentic system implementation cost?
The implementation starts from PLN 9,000 net, depending on scope. On the company's side, there is a Claude Team subscription for each person working in the system. Details are on the agentic system page, and we break down what that price is made of in the post on AI agent implementation cost.
Summary
An agentic system is not a chatbot and not rigid automation. It's agents assigned to the company's processes, working on its knowledge, corrected by people, and stopping before every step that can't be undone.
Have a process you'd like to hand over to agents? Book a meeting at a time that suits you. The first meeting takes about an hour and ends with choosing the process worth starting with. Prefer to write first? hello@200iqlabs.io.