Build a Free AI Agent That Takes Actions (No Code)

Build a Free AI Agent That Takes Actions (No Code)

Piotr Grudzień

on July 9, 2026 • 15 min read

; the original PNG/JPG stays as the fallback and remains the og:image for social scrapers. -->

Most chatbots can only talk. Ask one for a price in your currency, an order’s status, or today’s exchange rate, and it either guesses or tells you to check somewhere else. An AI agent that takes actions does the opposite: it calls a real API in the middle of the conversation, reads the result, and answers with it.

This guide builds one from an empty account, with no code. By the end you will have an agent that answers questions from knowledge you give it and calls a live REST API during the chat, and you will have watched it happen in the Inbox. The action you build here is the master recipe: one described HTTP request. Point it at a different URL and the same recipe logs a lead to a spreadsheet, writes to a CRM, or moderates a chat server. Every integration tutorial at the end of this post is a worked example of it.

Everything below was built and tested on a real agent. Every conversation and API call in the screenshots was produced by the agent running for real; you can reproduce each one.

What you will build

A single support agent for a fictional project-planning tool called Meridian. It does two things end to end, in about ten minutes:

Answers from knowledge you give it: Meridian’s plans, prices, and features.

Calls one live API mid-conversation to convert a price into the visitor’s currency, then uses the result in its reply.

The action calls Frankfurter, a free, keyless exchange-rate API, so you can finish the whole thing with only a Quickchat account and nothing to sign up for. The point is the pattern, not currencies: once you have built this action, you have built the shape of every integration.

What you need:

A free Quickchat AI account (sign up here).

No code, no server, no API key.

What is an AI agent, and how is it different from a chatbot?

A chatbot answers. An agent answers and acts. In Quickchat, you build an agent from three parts.

The first two parts make a chatbot. The third, Actions, makes it an agent.

Identity is who the agent is: its name, role, and instructions. This is the AI Main Prompt.

Knowledge is what it answers from: your docs, pages, and facts.

Actions & MCPs is what it can do: call an API during the conversation.

The first two make a good chatbot. The third makes it an agent. This post spends most of its time on the third.

What an AI Action really is

An AI Action is a described HTTP request. You fill in the request once (the method, the URL, and the values to send) and write a description of when to use it. During a conversation the model decides whether to call it and fills in the parts you left open, Quickchat sends the request, and the model reads the response back.

The clearest way to understand why this is reliable is to split every value in the request into two kinds.

You fix the deterministic values; the model fills the judgment ones from the chat. The parameters are the only values it has to get right.

Deterministic values are the ones you fix: the method, the URL, a base currency. The model cannot get them wrong because it never touches them.

Judgment values are the ones the model fills from the conversation: which currency the visitor asked for, which price to convert. These are the only values that need any thought, and the only ones you tune.

You insert judgment values with the Add AI Data menu, which drops a {{...}} chip into any field. That menu offers exactly the three things an action ever needs to pull in:

Parameters you define (the judgment values the model fills, like {{currency}}).

Conversation metadata the channel sets (like {{conversation_channel}} or {{metadata_visitor_email}}).

System Tokens: secrets Quickchat stores and injects, shown as a badge, never given to the model.

The Add AI Data menu inserts a value as a chip: a parameter you defined, a visitor or conversation value, or a built-in variable.

The conversation-metadata values are ready to use without asking for them. A few worth knowing:

VariableWhat it holds

{{conversation_channel}}The channel the chat is on (widget, telegram, whatsapp, and so on)

{{conversation_url}}A link to this exact conversation in your Inbox

{{language}}, {{country}}The visitor’s language and country, as two-letter codes

{{metadata_visitor_email}}The visitor’s email, once they have shared it

{{scenario_id}}, {{conversation_id}}Ids for this agent and this conversation

For this action you only need the first kind (the parameters). The others matter once you connect a real service; the HubSpot and Discord guides at the end lean on all three.

Step 1: Create the agent and give it knowledge

Sign up and open a new agent. On the Identity page, set the AI Agent Name to Meridian and paste this into the AI Main Prompt. This is the always-available prompt field every plan has; you do not need the separate AI Guidelines list.

The agent’s instructions go in the always-available AI Main Prompt, not the separate AI Guidelines list.

You are the support assistant for Meridian, a project planning tool for product teams. You answer questions from visitors on Meridian's website about plans, pricing, features, and getting started.

Answer using your knowledge. Every price in your knowledge is in US dollars (USD).

When a visitor asks what a plan or price costs in another currency, or mentions their own country or local currency, call the "Convert price to currency" action with the US dollar amount and the 3-letter code of the target currency, then give them both the USD price and the converted amount at today's rate.

If you do not know the answer, say so honestly and offer to pass them to the team. Never guess.

Two lines earn their place. The one about US dollars tells the model what the knowledge prices mean, so it knows what to pass to the action. The last line, say so when you do not know, is what produces an honest refusal instead of a guess. We test both later.

Now give it something to answer from. On the Knowledge Base page, add a few short articles with Meridian’s facts. The one the demo leans on is pricing:

Meridian has three plans, billed per user per month in US dollars (USD):

• Starter: $19 per user per month. Unlimited projects, timeline and board views, up to 3 integrations.
• Pro: $49 per user per month. Adds sprint planning, task dependencies, custom fields, and unlimited integrations.
• Business: $99 per user per month. Adds portfolio roadmaps, advanced permissions, SSO, and priority support.

Annual billing costs 17% less than monthly. Every plan starts with a 14-day free trial, no credit card required.

The demo’s facts, added as short articles and marked Ready. The agent answers pricing questions from these.

That is enough for the agent to answer pricing questions. Deliberately leave one thing out, a security certification, so we have a genuine question the agent should not be able to answer.

Step 2: The master AI Action recipe: call any REST API

This is the reusable part. Open Actions & MCPs, and under Custom Actions click Add Action, then API Action.

Under Custom Actions, Add Action lists API Action first: a described HTTP request to any REST API.

Every API Action uses the same form, in the same order. Learn it once here and every later recipe is the same boxes with different values. It has two halves: what to collect from the visitor, and the request to send.

The values to collect

The top of the form: the API Action Name, and the two required parameters the model fills, currency and amount.

API Action Name. A short name the model uses to refer to the action.

Convert price to currency

What to ask the user first. The judgment values, one row each. Give every one a Format, a Name, and a Description that tells the model how to fill it, and mark it Required so the model never calls the action without it.

FormatNameDescriptionRequired

TextcurrencyThe 3-letter ISO code of the currency to convert to, for example EUR, GBP, or JPY. Work it out from the currency or country the visitor mentions.yes

Decimal NumberamountThe amount in US dollars to convert, taken from the plan or price the visitor asked about.yes

“What to ask the user first” is the product’s label, but the agent rarely stops to ask. When the visitor writes “how much is Business in euros”, the model already has both values (amount from your knowledge, currency from “euros”) and fills them straight in.

The request to send

The request: a GET to Frankfurter, with base fixed to USD and the currency and amount chips added under Query Params.

API request method and endpoint URL. A GET to Frankfurter’s latest-rates endpoint:

GET https://api.frankfurter.dev/v1/latest

Query Params. This is where the deterministic and judgment values meet. Add three rows under the Query Params tab. Type USD for the base, and for the other two click Add AI Data and pick the parameters you defined, which drops in the {{currency}} and {{amount}} chips.

KeyValue

baseUSD

symbols{{currency}}

amount{{amount}}

Headers and Body: none. This is a GET with everything in the query string.

API Action Description. The single most important field. It is what the model reads to decide whether to call the action, so tie it to a clear signal rather than describing the mechanism.

Convert a US dollar amount into another currency at today's exchange rate. Call this whenever the visitor asks what a price or plan costs in a currency other than US dollars, or gives their country or local currency. Pass the amount in US dollars and the 3-letter ISO code of the currency to convert to.

Save it and switch the action on. That is the whole recipe: a name, the values to collect, a request, and a description.

The finished action, switched on. The card shows its call count and success rate at a glance.

Nothing here is specific to currencies. Swap the URL and query for your own API and you have a different action.

Point it at your own API

The Frankfurter action is a read: a GET with public data. Your own API is usually the same form with a few more fields filled in.

To write, not just read, set the method to POST, PATCH, or DELETE, and put the data in the Body tab as JSON. The same {{...}} chips work inside the body, so { "email": "{{email}}" } sends whatever the model collected.

For an API that needs a key, add a row under the Headers tab (for example Authorization) and insert the key with Add AI Data, choosing a System Token. Quickchat stores the secret and injects it at call time, so it shows as a badge and is never given to the model or written into the prompt.

Everything else is identical: the name, the parameters to collect, and the description that decides when it fires.

The HubSpot guide builds four POST actions this way with an injected OAuth token, and the Discord guide builds seven against the Discord API with a bot token in the header. Both are the same form you just filled in, with a different URL and body.

Step 3: Test it and watch the call happen

Here is the whole round trip in one picture: the visitor asks, the model fills the judgment values, Quickchat adds the fixed ones and makes the request, and the reply carries the result back.

One call, end to end: the model fills the judgment values, and Quickchat adds the fixed ones and makes the request.

Chat with your agent in AI Preview (at the top of the left menu), or on your live widget, then open the conversation in your Inbox. Ask a plain pricing question first, then ask for it in another currency:

Visitor: How much is the Business plan? Meridian: The Business plan is $99 per user per month.

Visitor: What’s that in euros? Meridian: The Business plan is $99 per user per month, which is about €86.81 per user per month at today’s rate.

The first answer comes from knowledge. The second is the action firing. You do not have to

[truncated for AI cost control]