Editing AI Agents Through Conversation with Macha's AI Editor

Macha's AI Editor removes that cliff. You can open it from any agent's configuration page and change anything about that agent — its instructions, the tools it can call, the triggers that wake it up, the sub-agents it delegates to, even which model it runs on — by typing what you want in plain English. It's the same conversational surface you used to build the agent, pointed at an agent that already exists. Tell it "stop auto-replying to angry customers and tag them for a human instead," and it rewrites the instruction, adds the tag tool if needed, and shows you exactly what it changed.

This post is a hands-on look at how the AI Editor actually works, what it can and can't touch, where it fits next to manual editing, and the guardrails that keep a conversational editor from quietly breaking a production agent. One thing to keep front of mind throughout: Macha agents run on top of the helpdesk you already use — Zendesk, Freshdesk, Gorgias, or Front — so editing an agent here changes how automation behaves on your existing queue, not the helpdesk itself.

Build with AI, then keep editing with AI

Macha has two sides to its conversational agent surface, and they're deliberately symmetric:

• Build agents through conversation — describe what you need and the AI assembles a fully configured agent: instructions, tools, triggers, sub-agents, and a model. This is available on all plans.
• Edit with AI — open the AI Editor from any agent's configuration page and modify any aspect of that agent through conversation.

The important word is symmetric. The thing that builds your agent is the thing that maintains it. You're never handed a finished artifact and then told "now go learn the settings." Whatever you could say to create the agent, you can say again to change it.

That matters because real support agents are never "done." A returns agent that worked in March needs a new edge case in April. A triage agent built for two ticket categories needs a third when you launch a product line. The cost of those changes — how fast and how confidently you can make them — is what actually determines whether an agent stays useful or quietly rots. The AI Editor is Macha's answer to keeping that cost near zero.

Opening the editor and making a change

From an agent's config page, you open the AI Editor and just describe the change. A few examples of the kinds of requests it handles:

• "Add a Stripe tool so this agent can look up the customer's last payment before replying."
• "Set up a trigger that runs this agent whenever a ticket is tagged billing."
• "Rewrite the instructions so it always asks for an order number before offering a refund."
• "Create a sub-agent that handles shipping questions and let this one delegate to it."
• "Switch the model to something cheaper for this low-stakes auto-tagger."

You type the request the way you'd describe it to a teammate. The editor interprets it against the agent's current configuration and your connected integrations, then makes the edit.

Because the editor is context-aware, it already knows which integrations you've connected — so when you say "add a refund tool," it reaches for the Stripe or Shopify tools you actually have wired up rather than inventing a generic one. Macha also surfaces suggestion pills for relevant configurations; hovering a pill previews the prompt it would send, so you can see what a suggestion will do before you commit to it.

Artifact cards: see exactly what changed

The risk with any "just tell the AI what to do" interface is that you lose track of what it actually did. Macha's answer is artifact cards. Every created or updated agent, trigger, and tool shows up as an interactive card right in the chat. The card isn't decorative — it's clickable. Click an agent card and you jump straight to that agent's configuration; click a trigger or tool card and you land on the thing it just changed.

This turns the conversation into an auditable changelog. Instead of a wall of prose claiming "I've updated your agent," you get a concrete object you can open, inspect, and verify. If the editor added a trigger you didn't expect, the card is right there to click into and adjust — or undo by hand.

It's the same pattern on the build side, which keeps the mental model consistent: whether the AI is creating an agent from scratch or editing an existing one, the output is a set of cards you can drill into.

What the AI Editor can actually touch

The editor isn't limited to instructions — that's the part worth being precise about, because plenty of "AI assistants" in other tools only rewrite a system prompt. Macha's AI Editor can modify the full surface of an agent:

That last column on sub-agents is worth a beat. Macha agents can delegate to specialist sub-agents up to three levels deep, and the obvious failure mode of letting an AI wire those connections is creating a loop — agent A delegates to B which delegates back to A. The AI Builder runs automatic circular-dependency checks when it assigns sub-agents, so a conversational request to "let this agent hand off to the shipping agent" can't quietly create an infinite delegation chain.

On model choice: switching models changes what each run costs, because Macha bills credits per AI action and the rate varies by model (0.5–9 credits depending on the model, with the default GPT-5.4 Mini at 1 credit). Telling the editor to move a high-volume auto-tagger to a cheaper model is a legitimate cost lever, and it's one sentence. See the pricing page for how credits map to plans.

The guardrails that make conversational editing safe

A conversational editor pointed at a production agent is only as good as the safety rails around it. Macha shipped the editor alongside a set of agent-configuration improvements that exist precisely so an edit can't silently go wrong:

• Save guard — the save button is grayed out when there are no changes, so you always know whether you have unsaved edits pending.
• Navigate-away protection — a confirmation modal appears if you try to leave a config page with unsaved changes, so an in-progress edit doesn't evaporate.
• camelCase handles — agent handles auto-generate from the agent's name as you type (for example @ticketTriageAgent), keeping references consistent when the editor renames or creates agents.
• Inline management — you can delete agents directly from the agents table without opening each one, which keeps cleanup fast after experimenting.

The combination — artifact cards for what changed, plus a save guard and navigate-away modal for when it commits — is what separates a conversational editor you'd trust on a live queue from a novelty. You see the change as a clickable object, and nothing persists until you deliberately save.

Where the AI Editor fits — and when to edit by hand

The AI Editor is the fastest path for most changes, but it isn't the only path, and pretending it is would be dishonest. Here's the honest split.

Reach for the AI Editor when:

• You're making a described change — "add this tool," "handle this new case," "route these tickets here." Natural language is genuinely faster than hunting through tabs.
• You're not sure exactly where a setting lives. The editor knows the config surface, so you don't have to.
• You want a record of the change. Artifact cards give you that for free.

Edit by hand when:

• You need surgical, character-level control over instruction wording and want to see the exact diff yourself. Typing the edit directly is more precise than describing it.
• You're doing fine-grained tool-permission or trigger-condition work where the exact field values matter and you'd rather set them explicitly than interpret a model's interpretation.
• You're reviewing or auditing — reading the config straight is clearer than re-deriving it from a chat transcript.

In practice the two aren't rivals. Most teams use the editor to get 90% of the way there in one sentence, then nudge a field by hand. Because both write to the same agent configuration, there's no "AI version" versus "manual version" to reconcile — it's one agent, edited two ways.

A couple of real watch-outs worth stating plainly: a conversational editor will always interpret intent, so a vague request ("make it better") gets a vague edit — be specific, and check the artifact card. And every edit that involves the AI doing work draws on your credit balance like any other AI action, so iterating ten times on phrasing isn't free. The save guard and cards exist to keep you in control, but they don't remove the need to read what changed.

How this compares to the broader "build agents in natural language" wave

Conversational agent building isn't unique to Macha — Microsoft's Copilot Studio authors topics and agents from natural-language descriptions, and Google's Gemini Enterprise Agent Designer offers a chat pane to refine an agent through prompts. Those are capable general-purpose platforms. The distinction that matters for support teams is what the agent is wired into. Macha's agents — and therefore the edits you make to them — operate as a layer on top of your existing helpdesk and the commerce, knowledge, and comms tools around it, so "add a refund tool" means a real Stripe action on the ticket in front of a customer, not a hypothetical capability in a sandbox. The conversational editing is the interface; the helpdesk-native execution is the point.

If you want the wider picture of how Macha sits on top of your stack, the features overview and the Macha on Zendesk page walk through it, and the docs cover agent configuration in depth.

FAQ

What is Macha's AI Editor? It's a conversational interface for editing an existing AI agent. Open it from any agent's configuration page and describe the change you want in plain language — Macha modifies the agent's instructions, tools, triggers, sub-agents, or model and shows the result as clickable artifact cards.

What can I change with the AI Editor? Any facet of the agent: its instructions, the tools it can call across your connected integrations, the triggers that run it, the sub-agents it delegates to, and the model it uses. It's not limited to rewriting the prompt.

Is conversational editing safe on a live agent? There are guardrails: every change appears as an artifact card you can inspect, the save button stays grayed out until there's an actual change, and a confirmation modal warns you before you navigate away with unsaved edits. Nothing commits until you save.

Can I still edit agents manually? Yes. The AI Editor and the manual configuration screen write to the same agent, so you can describe a change and then fine-tune a field by hand. Use the editor for speed, manual editing for surgical precision.

Does building agents with AI cost extra, or is it plan-gated? Building agents through conversation is available on all plans. Edits use AI actions, which draw on your credit balance like any other action; rates vary by model. See the pricing page for details.

Which helpdesks does this work with? Macha agents run on top of Zendesk, Freshdesk, Gorgias, and Front. The AI Editor changes how those agents behave on your existing queue — it doesn't replace your helpdesk.

Try it

If you've ever built an AI agent and then dreaded the idea of maintaining it, the AI Editor is the part to try. Start a 7-day free trial, no credit card required, connect your helpdesk, build an agent in a sentence — then change it in another. Or read the agent configuration docs for the full walkthrough.

Written by Abbas (Customer Support & AI, Macha) · Reviewed by Ankeet Guha (Co-founder & CTO) · Published 2026-06-24 · Last updated 2026-06-24.