A chatbot answers questions, an AI agent gets a task done. It plans the steps itself, looks up data, uses your systems and prepares the result. We develop and deploy AI agents for businesses with fixed rules, checkpoints and human approval wherever a mistake would cost money or customer trust.
Webforte designs, develops and deploys AI agents for businesses. An AI agent is a program built on a language model that breaks a task into steps itself and carries it out with tools: it searches documents and reads from and writes to a database, email, an accounting system or customer records (CRM). A chatbot only answers. An agent acts and writes the result where it belongs. Classic automation needs input in a fixed format, while an agent can also handle an enquiry written in the sender's own words. For larger tasks, we build several specialised agents that work together under one controller (orchestration). We build agentic AI with safeguards: the agent has only the permissions it needs, passes through checkpoints in code, important actions are approved by a person and every step is saved to a record (a log). The service is provided by Webforte Technologies s.r.o., Prague, company ID (IČO) 23364343. Pricing is set by a non-binding quote after a consultation.
Agentic AI is the general term for systems in which AI plans and carries out steps itself. When several agents work together under one controller, this is called a multi-agent system, and coordinating them is called orchestration.
Understands instructions in everyday language and decides which step to take next.
Access to documents, databases and systems through an API, the interface programs use to talk to each other.
What the agent has already done, what it has found out and the context of the task.
Permissions, checkpoints, limits and human approval.
AI agentA model on its own only answers. It becomes an agent only with tools, memory and rules.
All three are sold as AI, but they solve different problems. Before you decide, check which type your task actually needs.
Swipe the table sideways to see all columns.
| Chatbot, automation or AI agent? | Chatbot | Automation | AI agent |
|---|---|---|---|
| What it does | Answers questions | Runs a fixed sequence of steps | Completes multi-step tasks and chooses how |
| How it decides | Based on the question and your documents | Based on rules someone wrote in advance | Based on the goal, the rules and the results of earlier steps |
| What input it handles | A question in everyday language | Data in a fixed format | An email, a document or an enquiry in the sender's own words |
| Where it works | In a chat window on a website or in an app | In the background between systems | Inside your systems, through tools it has permission to use |
| Example | Tells a customer the delivery time | Transfers every paid order to the accounting system | Reads an enquiry, looks up prices and stock and prepares a quote for approval |
| When it fits | Recurring questions from customers or staff | A stable process with inputs in a fixed format | Varied inputs that need judgement and work across several systems |
An AI agent is not always the better choice. When classic automation can handle the task reliably, it is usually cheaper to run and easier to check. We recommend the simplest option that solves the task.
An agent makes sense where someone currently retypes and looks up data across several systems and the inputs have no fixed form.
The agent reads an enquiry from an email or form, looks up the customer in the CRM, prices in the price list and stock in the e-shop, and prepares a draft quote. A salesperson checks it and sends it.
It extracts data from invoices, orders and delivery notes, compares it with the order and prepares the accounting entry. It flags discrepancies and hands them to a person.
It goes through the sources, internal data and documents you specify, summarises what has changed and prepares a brief or report with links to the sources it is based on.
Behind a chatbot that answers, there can be an agent that also acts: it checks an order's status, prepares a claim or opens a ticket. Anything outside the rules goes to a person.
An employee asks in everyday language and the agent finds the answer in policies, contracts or the database, always with a link to the source. We set it up so that it sees only the data the person asking has access to.
It compares a contract, policy or quote with your rules and suggests changes, each with a reference to the specific rule. A person decides whether to accept a suggestion.
A larger task is not handled by one all-purpose agent but by several agents with narrow roles. A planner directs them (this is called orchestration), and the harness holds it all together: the software around the model that sets what the agents may do, what they remember, when they stop and who checks their work.
Harness
Input
An email enquiry, a document or a request from your system.
Orchestration
Breaks the task into steps, assigns them to agents and tracks what is done.
Specialised agents
A narrow role is easier to test and check than one agent for everything. Steps that do not depend on each other run in parallel.
Finds the customer, order history and documents.
Tools
Works out the price from the price list and checks availability.
Tools
Writes the quote using your templates and tone.
Tools
Check in code
An ordinary program verifies the rules: the totals add up, the customer exists, the claim has a source and the agent has not exceeded a limit.
Human in the loop
Before the agent sends a quote or writes to the accounting system, a person reviews and confirms the result.
Output
The output is written to your system. Every step, every tool used and every human decision stays in the log.
A language model does not police itself. Reliability depends on the harness we build around it.
Precisely defined functions through which the agent works with your systems. If it is not among the tools, the agent cannot do it.
Set per tool, with reading kept separate from writing. Sensitive actions always go through approval.
The state of the task and context from your data, so the agent does not repeat finished steps and picks up where it left off.
Every step, tool and output. You can trace why the agent did what it did and fix the mistake in the rules.
A set of test cases from your own work. We check every change to the model or rules against it before it goes live.
A cap on the number of steps, time and cost per task. When the agent reaches it, it stops and hands the task to a person.
Not sure which of these you need? Write to us and we will recommend the simplest solution.
An agent's reliability does not come from the model alone but from the system you build around it. Checks in code, sources for claims and human approval are also what we use in our own AI tools.
First we describe the task as a person does it today: inputs, decisions, systems and the places where mistakes happen. Only then do we decide whether automation, a single agent or several agents working together is the right fit.
One agent for everything is hard to check. We split the task among agents with narrow roles and their own tools and hand control to a planner. Where the order of steps is always the same, we keep it in code, because that is cheaper and more predictable.
The agent works with your systems through an API or through MCP (Model Context Protocol), an open standard for connecting AI applications to data and tools. We describe each tool so that the model knows what it is for and what it must not do with it.
Whatever a program can check, we do not leave to the model: totals, whether the customer exists, required fields, a source for every claim. Our article generator works the same way: the code discards research findings that have no source, and the program, not the model, compiles the list of sources with citation numbers.
Before an agent goes live, it runs through a set of test cases from your own work, and again after every change to the model or rules. In operation we set limits on steps, time and cost per task and monitor where the agent makes mistakes.
An agent that acts in company systems needs rules like a new employee, only stricter. We set this up for every agent we build.
We do not build agents blind. Every step produces an output you can see and comment on.
We discuss where you lose the most time and choose the task where an agent pays off first. We also assess whether simpler automation would do.
Output: Recommended solution and a non-binding quote
We describe the inputs, steps, systems and decisions. We design the agents' roles, tools, permissions, checkpoints and the points where a person approves.
Output: Agent design including permissions and checkpoints
From your real cases we put together a set to measure the agent against. We define what a correct result is and which mistakes are unacceptable.
Output: Set of test cases and success criteria
We build a first version and run it on the test set. We show you the results, mistakes included, and adjust the rules.
Output: Evaluation of the prototype on the test set
The agent runs live, but a person approves everything important. The log shows us where it makes mistakes, and we fine-tune the rules.
Output: Agent in pilot operation with a record of steps
Based on the pilot results, we expand what the agent may do on its own. Sensitive actions are still approved by a person. After every change we re-check the agent on the test set and keep an eye on costs and limits.
Output: Agent in operation with regular evaluation
The article generator in this website's admin works in several steps: research, an article plan, writing section by section and checks in code. It discards findings without a source, checks internal links against the site map and publishes nothing on its own: a person decides whether an article stays a draft or goes live. Our products are built on the same principles.
Describe a task that someone currently does by hand across several systems. In a consultation we assess whether automation is enough or an agent is needed, where a person has to decide, and prepare a non-binding quote. We communicate in English.
