What Is a Macha AI Agent? Instructions, Tools, Triggers & Knowledge Explained
Everything in Macha is built around one idea: the agent. If you understand how an agent is put together, the rest of the platform clicks into place. The good news is it's only four parts — instructions, tools, triggers, and knowledge — and once you've seen how they fit, you can build just about any support workflow you can imagine.
Here's what an agent actually is, and how it decides what to do.
The 90-second version
An agent = instructions + capabilities + knowledge
Think of an agent as a teammate you configure. You tell it what to do (instructions), give it the abilities to do it (tools and triggers), and the information to do it well (knowledge). That's the whole model.
The configuration screen mirrors this exactly: the left panel shows the agent's full setup — Instructions, Triggers, Tools, Data Sources, Sub-Agents — and the right panel shows the details of whatever you select. Let's take the four parts one at a time.
1. Instructions — what you want it to do
This is plain text. You write, in normal language, what the agent should do — for example, "Read each incoming ticket, write a short summary, and update these three fields." No code, no flowchart. The instructions are the single most important part of an agent, because they're what the AI actually reads to decide how to behave. Clear, specific instructions make a good agent; vague ones make a flaky one.
2. Tools — the actions it can take
Tools are the things an agent is allowed to do. Get a ticket, update its fields, set tags, post a reply, look up an order in Shopify, issue a refund in Stripe. You give each agent exactly the tools it needs from your connected apps — and only those. The available tools come from your connectors, plus any custom tools you've built. Tools are what turn a chatbot that talks into an agent that acts.
3. Triggers — when it runs on its own
Triggers are events from your connected apps. When one fires — a ticket is created, a comment is added, a status changes — the agent starts working automatically. Triggers are what make an agent autonomous: instead of you asking it to do something, the event does. An agent with no triggers only runs when you chat with it; add a "Ticket Created" trigger and it runs on every new ticket without you.
4. Knowledge — what it can read
You can point an agent at data sources — your Zendesk Help Center, a crawled website, uploaded docs, Notion. The agent can search the entire source, or you can pin it to specific documents if you know exactly what it should use. Knowledge is what lets the agent answer accurately from your content instead of guessing.
How an agent actually decides what to do
Here's the part that makes "agent" more than a buzzword. When an agent gets a request, it doesn't follow a fixed script — it reasons:
- It reads the request (a chat message, or a triggered ticket).
- It looks at the tools and knowledge it has.
- It decides the next step on its own — maybe search knowledge, maybe call a tool.
- It acts, looks at the result, and decides what to do next, until the job's done.
So a ticket-summarizer agent, asked to help with a ticket, will pick the get ticket tool itself, retrieve the ticket, write the summary, and then move to update the fields — all without you spelling out the sequence.
Confirmation vs. autonomous
There's one important safety distinction in how agents act:
- In chat (interactive), any write action — editing, updating, deleting — pops a confirmation first. The agent says "I'm about to update these fields, okay?" and waits for you. Nothing changes without your nod.
- In autonomous mode (the agent running from a trigger), there's no human in the loop — the agent decides and acts on its own. That's the point of autonomy, which is why you scope an autonomous agent's tools carefully and test it first.
(More on this in autonomous mode vs. interactive chat.)
Why this model is powerful
Because the four parts are independent, you can compose almost any workflow:
- A triage agent: instructions to classify + tools to tag and assign + a "ticket created" trigger.
- A WISMO agent: instructions to answer order-status + a Shopify lookup tool + your Help Center knowledge.
- A summarizer: instructions to summarize + an internal-note tool + a "ticket created" trigger.
Same four building blocks, different combinations. And you can run many agents side by side, each focused on one job — even have one agent hand off to specialist sub-agents.
A real agent, end to end
To make the four parts concrete, here's a "where's my order?" (WISMO) agent:
- Instructions: "When a customer asks where their order is, find the order number in the ticket and look it up. Reply with the current status and tracking link. If there's no order number, ask for it. If the order looks lost or badly delayed, escalate to a human."
- Tools: a Shopify get order tool (to look it up) and the Zendesk public reply tool (to respond).
- Knowledge: your shipping-policy help-center articles, so it explains timelines accurately.
- Trigger: Ticket Created — so it runs on every new ticket; per its instructions, it only acts on the order-status ones.
Four parts, one job, fully automated. Swap the instructions and tools and the exact same structure becomes a refund handler, a triage agent, or a billing assistant — which is why "agent" is the only concept you really need to learn.
Frequently asked questions
What is a Macha AI agent? A configurable AI worker built from four parts: instructions (what to do), tools (actions it can take), triggers (events that start it), and knowledge (what it can read).
How is it different from a chatbot? A chatbot follows a script and mostly talks. An agent reasons over your tools and knowledge and takes real actions — and can run autonomously on triggers.
Do I need to code to build one? No. Instructions are plain text, and tools/triggers/knowledge are toggles and connections.
Will an agent change things without asking? In chat, no — write actions ask for confirmation. In autonomous mode (triggered), yes — it acts on its own, so you scope its tools deliberately.
Can one agent do everything? It can, but focused agents (one job each) are easier to tune and trust — and they can delegate to sub-agents.
The bottom line
A Macha agent is just four parts working together: instructions tell it what to do, tools let it act, triggers decide when it runs, and knowledge keeps it accurate. Get those right and the agent reasons through the rest — which is what lets you turn "I wish something handled this automatically" into a working agent in minutes.
Build your first agent: describe what you want and Macha sets it up. 7-day free trial, no credit card required. Start free.
