# Activepieces AI Agents: How to Build Them (2026 Guide)

By Ossian Kettunen · 2026-10-24 · Source: https://www.activepieces.com/blog/activepieces-ai-agents-how-to-build-them-2026-guide

---
<aside class="tldr"><p class="tldr-label">Summary</p><p>Build Activepieces AI agents as constrained steps in fixed workflows, with clear prompts, limited tool access, and approval before irreversible actions.</p><ul><li>2% of 1,500 organizations surveyed by Capgemini operate agents at full scale.</li><li>Model costs vary widely: Haiku at $0.10–$0.50, Fable at $10–$50 per million tokens.</li><li>61% of surveyed organizations are exploring agents but have not yet deployed them.</li></ul></aside>

An [Activepieces](https://www.activepieces.com/pricing) AI agent is a language-model step inside a workflow you build and can inspect.

You give it instructions and a set of connectors to use as tools, chosen from the **771 integrations in the open source monorepo**, so you likely have an integration available for your use case.

The workflow decides when the agent starts and what happens with its output. The agent decides only which of its permitted tools to call while it works.

## Activepieces AI agents are workflow steps, not free-roaming bots

### What an AI agent is, in one definition

Strip away the marketing and **an agent is a loop**. The model reads its instructions and the input, picks a tool, looks at the result, and picks again until it judges the task done.

![Loop diagram of model, tool and result cards with an exit arrow](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/b6637838-0734-4e08-9b12-062211aacce7/activepieces-ai-agents-how-to-build-them-2026-gu-8fe34d8a.webp)

In Activepieces the tools are the same integrations (the app connectors) you would otherwise drag in as ordinary steps, so the agent's reach is the list you hand it, no wider, out of the 771 that exist.

If you didn't connect it to your billing system, it can't touch billing.

### Agent, fixed workflow and single AI step compared

The table below sorts three ways of putting a model into automation by who chooses the next action and how much the model is allowed to do.

| | Who decides the next action | Can it call tools | Model calls per run | Example |
|---|---|---|---|---|
| Fixed workflow | You, at build time | Only as steps you placed | None | New form submission is added to a spreadsheet, then a Slack message is sent |
| Single LLM call | You; the model only returns text | No | One | Classify an incoming email as billing, support or sales, then route by a fixed branch |
| Agent step | The model, within the tools you gave it | Yes, from its allowed list | One or more, varying by run | Read a support ticket, look up the customer in the CRM, draft a reply for review |

_Prices and plan limits checked against [docs.claude.com](https://docs.claude.com/en/docs/about-claude/models/overview) and [claude.com](https://claude.com/pricing) and [openai.com](https://openai.com/chatgpt/pricing) and [gemini.google](https://gemini.google/subscriptions) on October 23, 2026._

### What was checked, and when

I took the product facts in this article from Activepieces' own pages and documentation. The model names come from each vendor's own model page, and all of it was checked on 23 October 2026.

## How an Activepieces agent works from trigger to finished task

In a flow, the agent is one step, placed in the same flow definition as the fixed steps around it. One trigger starts one run, the agent calls only the tools you gave it, and its output becomes data for the steps after it.

Follow the support-email case and you see the whole path:

1. An incoming email fires the trigger.
2. The agent step receives the message and its prompt, with its chosen tools attached.
3. The agent calls the CRM lookup tool (the CRM being the system that holds customer records) to find the sender.
4. The agent drafts a reply from the email and the customer record.
5. A person approves or rejects the draft.
6. The flow sends the approved reply.

![Email, trigger, agent step and CRM records connected in a row](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/25807822-1450-47b9-961d-64ce55930c7e/activepieces-ai-agents-how-to-build-them-2026-gu-7055a4ea.webp)

Pick the email trigger that matches your inbox. Check which fields it hands over, such as sender, subject and body, because the agent only knows what you map into its prompt.

### Step 2: give the agent instructions and tools

Write the prompt like a job description: classify the email, look up the sender, draft a reply, never promise a refund. Attach only the CRM lookup tool.

Place an approval step between the draft and the send, so the flow pauses until a person responds.

Open the run and read each step's input and output: what the trigger delivered, which tool the agent called and with what arguments, what came back, and the draft.

When a reply is wrong, the log shows whether the prompt, the lookup or the field mapping failed, so you fix that step instead of guessing.

## How to choose agents over workflows

Use an agent step where the input is messy and a wrong answer is cheap to catch, and a fixed workflow wherever the path is already known.

| | Predictability | Cost per run | Setup effort | Typical failure mode |
|---|---|---|---|---|
| Fixed workflow | Same input, same path | Lowest, no model calls | Low: map fields once | Breaks when input shape changes |
| Agent step | Bounded: the path is fixed, the step's choices are not | Higher, varies with tool calls | Moderate: prompt, tools, test cases | Wrong tool choice or confident wrong answer |
| Code-first agent framework | Whatever you build and test | Depends on your design | Highest: you own the plumbing | Failures you did not instrument |

When the input is messy, the case for an agent step is clearest: free-text support emails, forwarded threads, inconsistent form answers.

If the trigger, the fields and the action never change, such as copying a paid invoice row into a spreadsheet, an agent only adds cost and variance.

The same goes for anything that moves money, deletes records or sends external messages without review. Write those as explicit steps with explicit conditions.

Choose a code-first framework when you need custom memory or multi-agent coordination. You gain control and give up the visual run log, so budget engineering time for tracing and tests.

## Ways to control AI agents that use tools

Whatever the platform, the problem is the same: a model that chooses its own actions can choose wrongly, and the more of the job it owns, the more a wrong choice costs.

### Why agent loops compound small errors

The trouble starts with the loop itself. Each pass feeds the model's last choice back in as context, so an early wrong tool call shapes every later one, and a long run can drift far from the task before anything looks broken.

Untrusted text makes it worse, because the model cannot reliably tell the data it is reading from the instructions it is following. Every control below is a way of limiting how far that drift can travel.

### Limit an AI agent's path, tools or output

The oldest answer is a fixed pipeline with one model call inside it, which is how most classification and extraction work is still done.

The model never chooses an action, so the only thing that can go wrong is the text it returns, and a schema check catches most of that.

Orchestration libraries and code-first frameworks go the other way, letting the model plan across many steps, then recover control with tool allow-lists, step limits and schema-checked outputs.

Graph libraries such as LangGraph express this as explicit nodes and edges, so the model's freedom is drawn on a diagram.

A third family constrains the output rather than the path. Structured-output modes force the model to answer in a fixed shape, and a validator rejects anything outside it before the next step reads it.

![Activepieces workflow showing an AI sales research flow with Google Sheets data, loop processing, and Perplexity AI…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/99fb70d9-f10c-4df0-81e9-70b7feb183b1/activepieces-ai-agents-how-to-build-them-2026-gu-543bb194.webp)

This is cheap and works well, but it proves the answer is well formed, not that it is right.

### Restrict agent permissions, not just the prompt

**Instructions are a request, not a barrier**. A prompt that says "never delete records" can be argued out of it by a hostile email, whereas a credential that has no delete permission cannot.

![AI agent configuration screen for SEO Blog Writer agent showing instructions, tools section, and structured output settings.](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/b3963394-eaa1-4915-9aa6-1b3909755880/enterprise-ai-security-framework-for-automation-56056e24.webp)

So the stronger designs scope access at the connector: read-only API keys, per-task credentials, and separate tools for reading and writing.

### Add human approval before irreversible agent actions

Every serious approach converges on the same rule: let the model propose and let a person or a deterministic check commit.

Durable execution engines such as Temporal make that practical by checkpointing a run, so it can wait days for an approval or resume after a crash.

<blockquote class="pull"><p>Every serious approach converges on the same rule: let the model propose and let a person or a deterministic check commit.</p></blockquote>

Teams also keep a small set of recorded test cases and rerun them whenever the prompt or model changes, the same discipline as regression tests.

Other visual builders, n8n and Zapier among them, now offer agent steps too, and the same rule holds there: the safety comes from what surrounds the step, not from the product.

![A workflow automation flow with five steps including email trigger, AI processing, Slack approval, and routing logic.](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/57ac0ae0-3335-432a-afff-ffb303b7667d/model-security-vs-data-security-in-ai-workflows-f3455e93.webp)

Tracing tools from the observability world, whether hosted or open source, make the same point from the other side, since you can only constrain what you can replay.

That is why a bounded step in an inspectable workflow is a defensible default rather than a timid one.

## What Activepieces AI agents cost and require

You can self-host the MIT-licensed Community Edition for free, paid plans add hosted convenience and enterprise controls, and whichever provider you connect bills the AI model's tokens separately.

### Community Edition versus paid plans

You can run, read and modify the code without paying the platform, because it is MIT-licensed. What you give up is the vendor's hosting and its paid-tier features.

If you need single sign-on (SSO) beyond the Team tier, audit logs or embedding the builder in your own product, those go through the [sales form](https://www.activepieces.com/sales), so budget a conversation rather than a checkout.

SOC 2 is in progress, not certified, so a procurement team that needs the report today can't have it yet.

Run it yourself and the operations land on you: you provision the servers, apply upgrades, run backups and secure the instance.

### Model provider costs sit outside the platform fee

Whichever plan you pick, the agent step calls a model you pay for separately. The figures below, from [Anthropic's pricing page](https://platform.claude.com/docs/en/about-claude/pricing), show how far apart one vendor's own tiers sit, per million tokens:

![What Claude models charge per million tokens](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/7e78a46e-5bef-4104-ae56-d21a930d6a43/activepieces-ai-agents-how-to-build-them-2026-gu-af1e3b7a.svg "Source: Anthropic")

- Fable 5.1 runs $10 to $50, so a reasoning-heavy step on it can cost many times more than the same step on a smaller tier.
Opus 5.5 runs $4 to $20, which suits long-running work where the price is justified, making cost estimates dependent on task scope, so without clear scope parameters, you'll face unpredictable bills.
- Sonnet 5.5 runs $2 to $10, a sensible default for most tool-using steps.
- Haiku 5.5 runs $0.10 to $0.50, so high-volume steps such as classification or routing cost pennies.

Start on the cheapest tier that passes your test cases, because the model choice moves run cost far more than the platform plan does.

Before you commit, confirm these at the [pricing page](https://www.activepieces.com/pricing):

- MIT Community Edition and self-hosting terms
- Free and Plus plans, including the flat $20 Plus price
- SSO, audit logs and embedding, which go through sales
- SOC 2 status

## Common problems with AI agents

Start with the sceptic's case, because it is strong. **Agents vary between runs**, fail without raising errors, cost more per run, can be hijacked through their tools, and are often unnecessary.

For non-determinism, fix the steps around the agent and validate its output against a schema. For silent failure, log every run and alert on empty or malformed results.

For higher cost per run, cap iterations and tokens, and price a run before enabling it. For tool access and prompt injection, grant only the tools the task needs, read-only where possible.

At scale, few organisations have tested this. In [Capgemini's survey](https://www.capgemini.com/insights/research-library/ai-agents/) of 1,500 organisations, **61% are still exploring agents** and 23% are running pilots, so most organizations won't have a local success story to emulate.

![How far organisations have taken AI agents](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/503e8dbe-048c-417e-85ff-5c134061df6c/activepieces-ai-agents-how-to-build-them-2026-gu-c281307f.svg "Source: Capgemini - Rise of agentic AI (1,500 surveyed)")

Only 12% have reached partial scale, and 2% operate at full scale, which means scaling agents is still an exceptional achievement.

### Inconsistent results and silent AI agent failures

On different days, the same input can produce different tool calls. Worse, a wrong answer looks like a right one: no error, just a plausible record written to the wrong place.

![Same input on two days, one card correctly filed and one neatly misfiled](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/a40d7f0d-7c84-4539-b23c-40bf5e42bc60/activepieces-ai-agents-how-to-build-them-2026-gu-4314780b.webp)

Where a fixed step throws an exception, an agent returns confident text. So check outputs inside the workflow, route low-confidence cases to a human, and keep run history you can replay.

If an agent reads untrusted messages and can also send email, it is a data-leak path, because every tool is something an attacker can steer with text in an email or support ticket.

## How to avoid agent mistakes

Trace nearly any failure back and you find one move: someone took the fixed workflow away from the agent and let it improvise across the whole job.

| Mistake | What goes wrong | Fix |
|---|---|---|
| Too many tools | The agent picks the wrong action, or an adjacent one | Give it only the tools this one step needs |
| Vague instructions | Output shifts between runs and breaks downstream mappings | Name the task, the allowed outputs, and the stop condition |
| No approval on irreversible actions | A wrong email, refund, or deletion goes out before anyone sees it | Put a human approval step before the action |
| One happy-path test | Edge cases appear first in production | Test empty, malformed, and hostile inputs |

Sending and paying can't be taken back. **Place an approval step ahead of each one, so the agent proposes and a person confirms.** Reversible actions, such as writing a draft or tagging a record, can run unattended.

### Judging the agent on one good run

Feed the step an empty field, a malformed payload, and an input that tries to redirect it, then read the run logs for what it did with each.

On Monday, pick one workflow, cut its tools to the minimum, and add one approval step. [Start free](https://cloud.activepieces.com/sign-up) to build it, or see [the pricing page](https://www.activepieces.com/pricing) for plan limits.

## Frequently asked questions

### Is Activepieces free to self-host for AI agents?

Yes, the MIT-licensed Community Edition is free to self-host, and you can run agent steps inside your own flows on it. What it doesn't include are the paid-plan features, such as SSO beyond the Team plan and audit logs.

If you need any of the paid features on your own infrastructure, that's a conversation with sales, not a setting you flip. Check the pricing page for what each plan includes before you commit to a rollout.

### Can an Activepieces agent use any app I connect?

No. An agent can only call the tools you hand it, and each tool is a specific integration action, such as one trigger or one action with its fields mapped. A connected app isn't automatically an agent-usable app.

Before you build around an app, read what actions its integration exposes and whether they cover your case. A long catalogue says little about whether the one action you need exists.

Does Activepieces hold SOC 2 certification? Not yet. The SOC 2 programme is in progress, so don't write "SOC 2 certified" into a vendor questionnaire or a procurement form.

If your security review requires the report today, ask sales where the programme stands, and consider self-hosting so your data stays in your own environment while you wait.

### Which language models can an Activepieces agent use?

That depends on which AI providers you connect. The list changes as vendors release models, so check the agent step's model setting in your own workspace rather than trusting an article's list.

Pick the model per step. A cheap, fast model suits a classification step, and a stronger reasoning model suits a step that has to plan across several tool calls.

Because the agent is one bounded step, you can swap the model and see the effect in the run history.

### When should I talk to sales instead of starting free?

Talk to sales when you need self-hosted enterprise, SSO beyond Team ($200 a month, 25 users included), or audit logs, or when you want to embed [Activepieces](https://www.activepieces.com/pricing) in your own product, which starts from $36,000 a year.

Free, Plus and Team are self-serve, so only Embed, Ultimate (which adds audit logs and SSO beyond Team) and self-hosted enterprise control go through sales.

If you are one builder or a small team wiring up your first agent step, [start free](https://cloud.activepieces.com/sign-up) and see whether the flow holds up.

For plan limits, see [the pricing page](https://www.activepieces.com/pricing). For the enterprise items above, use [the sales form](https://www.activepieces.com/sales).

## Related reading

- [Build Fillout Forms Automations with Activepieces (2026)](https://www.activepieces.com/blog/building-more-powerful-forms-fillout-form-activepieces)
- [5 MCP Flows You Can Build With Airtable MCP on Activepieces (With Templates)](https://www.activepieces.com/blog/5-mcp-flows-you-can-build-with-airtable-mcp-on-activepieces-with-templates)
- [SAP Business One AI Agents: Build a Chat Automation](https://www.activepieces.com/blog/sap-business-one-ai-agents-build-a-chat-automation)

## References

- [Anthropic](https://platform.claude.com/docs/en/about-claude/pricing)
- [Capgemini](https://www.capgemini.com/insights/research-library/ai-agents/)
