How to Connect Front to an AI Agent (Macha) and Route Conversations

This guide shows you how to connect Front to an AI agent in about ten minutes, so that first pass — read, classify, tag, assign — happens automatically. Macha sits on top of Front and takes that first pass for you. It's not a replacement for Front — your inbox, your channels, your team structure all stay exactly where they are. Macha is an AI agent layer that connects to Front (and to your commerce, knowledge, and comms tools), reads each incoming conversation, and takes real actions through Front's own API: tag it, assign it to a teammate, post an internal comment with an @mention, set a status, or draft and send a public reply.

The Front connector shipped on June 23, 2026, alongside Gorgias. This post is the practical walkthrough: generate an API token in Front, connect it to Macha, and build an agent that triages and routes new conversations the moment they land. It takes about ten minutes.

What you can do once Front is connected

Before the setup, it's worth being precise about what Macha can actually do inside Front, because that determines what kinds of agents are worth building. The connector exposes 15 tools — the verbs your agents call:

And four triggers decide when an agent runs:

• Conversation Created — a new conversation lands in Front.
• New Message Added — an inbound customer reply or message hits an existing conversation.
• Conversation Assigned — a conversation is assigned or reassigned.
• Custom Webhook — Macha generates a webhook URL you drop into any Front rule's "Send a webhook" action, so you control exactly which conversations fire an agent.

For routing specifically, the pattern is simple: Conversation Created fires → an agent reads the conversation, classifies it, checks teammate availability with List Teammates, then calls Update Tags and Assign Conversation. Optionally it leaves an Internal Comment explaining the call so the human picking it up has context.

Step 1 — Generate a Front API token

Macha authenticates to Front with an API token, which you create inside Front. You'll need to be a Front admin — only admins can create or manage API tokens (per Front's developer docs).

In Front:

1. Go to Settings → Developers.
2. Open the API Tokens tab.
3. Click Create API token.

When you create the token, Front lets you scope it across three dimensions, and it's worth setting these deliberately rather than granting everything:

• Features — what the token can do. For Macha you want Access resources (manage conversations, contacts, inboxes, tags). You do not need Auto-provisioning or the MCP server option.
• Namespaces — where it applies: Global (company-wide resources like teams and tags), Shared (specific workspaces and their shared inboxes), and Private (individual teammates' personal inboxes). Most routing agents work over Shared resources — your team inboxes — plus Global for tags and teammates.
• Granular permissions — Read, Write, Delete, and Send per resource type. A triage-and-route agent needs Read + Write (to tag and assign); add Send only if the agent will post public replies.

Figure: Creating a scoped API token in Front (Settings → Developers → API Tokens). Set Features to "Access resources," select the Shared and Global namespaces your inboxes and tags live in, and grant Read + Write — adding Send only when an agent will reply to customers.

Copy the token when it's shown — Front displays it once. One thing worth knowing before you scale up: Front's API rate limit is enforced per company, not per user or per token. The default ceiling depends on your plan — 50 requests per minute on Starter, 100 on Professional, and 200 on Enterprise — so raising it means moving up a plan, not adding tokens. A real-time routing agent sits comfortably under any of those, but if you intend to backfill a large archive in one burst, pace the run against your plan's per-company limit (Front also applies a short burst allowance of roughly half the limit before throttling).

A note on least privilege: scope the token to the inboxes and actions the agent actually needs. If your first agent only tags and assigns, don't grant Send. You can always issue a second, broader token later when you add a reply agent — and you can revoke any token from the same screen if something looks off.

Step 2 — Add the Front connector in Macha

In your Macha dashboard, open Connectors. The Front connector lives under the Support category, next to Zendesk, Freshdesk, and Gorgias.

Click Front, paste the API token from Step 1, and connect. Macha validates the token and pulls in your workspace context — inboxes, tags, teammates, and custom fields — so your agents can reference real values instead of guessing.

That's the entire connection. No app to install in Front's App Store, no OAuth dance — a scoped token in, and Macha can read conversations and take actions on your behalf.

Step 3 — Build a routing agent

A connector by itself does nothing; the work happens in an agent — a set of instructions, a trigger, and the tools it's allowed to use. Macha ships built-in agent templates for the Front connector, so you don't start from a blank page.

Here's how I'd configure a triage-and-route agent for a shared inbox:

Trigger: Conversation Created. The agent runs once, the moment a new conversation appears, before anyone touches it.

Tools: Get Conversation, List Tags, List Teammates, Update Tags, Assign Conversation, and Add Internal Comment. Read what came in, see the available tags and people, then act.

Instructions (the operative part — this is roughly what I'd write):

Read the new conversation. Classify it into exactly one of: Billing, Shipping, Returns, Technical, Sales. Apply the matching tag using the existing tag list — never invent a new tag. Then assign the conversation to an available teammate on the team that owns that topic (use List Teammates to check availability; if no one on that team is available, assign to the team lead). Post a one-line internal comment stating the category and why you chose it. Do not send a public reply.

Proof it works: a real test run

Instructions on a page are easy; what matters is whether the agent actually takes the right actions on a live conversation. So before trusting it, run it once. Macha's builder has a Test run that executes the agent against a real (or sample) Front conversation and shows you each tool call it made — the classification it landed on, the Update Tags call, and the Assign Conversation call — so you can confirm the routing decision before it ever runs unattended.

Figure: A test run in the Macha builder. The agent reads the conversation, classifies it, then fires its tool calls — for a routing agent, that's Update Tags to apply the matching tag and Assign Conversation to route it to an available teammate, with an internal comment explaining the call. Every action in the trace is a real Front API call you can verify on the conversation itself.

When you open that conversation back in Front, the tag and the assignee are there, with the agent's internal comment explaining why — exactly the audit trail you want before flipping an agent on for a live queue.

Two things make this reliable. First, the agent works from your real Front data — the actual tag names and teammate list — so it tags with values that exist rather than hallucinating new ones (Update Tags diffs against the current set, so it won't pile on duplicates). Second, because routing is high-stakes, you can keep the agent internal-only: no Send permission, no public replies, just tag + assign + comment. The human still owns the first customer-facing word.

If you want the agent to handle simple, unambiguous conversations end-to-end — "where's my order," a password reset, a known FAQ — give it Add Public Reply and connect a knowledge source (Notion, Confluence, a help center) plus a commerce tool like Shopify or Stripe so it can look up the real order or charge before replying. That's the difference between deflection (sending a canned answer) and resolution (taking the action the customer actually needed) — and it's where the layer-on-top model pays off: the agent reasons across Front and your other systems in one run.

Picking the right model

Each AI action consumes credits, priced by model — from 0.5 to 9 credits per response, with the default GPT-5.4 Mini at 1 credit. For a high-volume triage agent that just classifies and routes, GPT-5.4 Mini is usually the right call: it's cheap enough to run on every conversation and more than capable of a five-way classification. Reserve the heavier models for agents that draft nuanced customer replies or follow strict multi-step rules. (See the pricing page for the full plan and credit breakdown.)

Using the Custom Webhook trigger for surgical control

The three native triggers cover most cases, but if you already run a tight set of Front rules, the Custom Webhook trigger is the precise option. Macha generates a webhook URL; you add a "Send a webhook" action to any Front rule and point it at that URL. Now Front's rule logic decides which conversations reach the agent — VIP senders only, a specific inbox, conversations matching a keyword — and the agent runs only on those.

This is the clean way to scope an expensive or sensitive agent. Let Front's rules do the cheap filtering they're already good at, and spend AI actions only on the conversations that warrant them.

When not to reach for an AI agent here

Honesty section, because routing is exactly the place where over-automation bites:

• Don't auto-send replies on ambiguous queues from day one. Start internal-only — tag, assign, comment — and watch the agent's calls for a week before you give it Send. The internal-comment trail makes that review easy.
• Simple, deterministic routing doesn't need AI. If "anything to billing@ goes to the Finance inbox" is a fixed rule, build it as a native Front rule — it's free, instant, and never wrong. Use a Macha agent when the decision needs reading and judgment (what is this conversation actually about?), not when it's a lookup.
• Mind the per-company rate limit. Front's API limit is shared across your whole company, not allotted per user — defaulting to 50 rpm on Starter, 100 on Professional, and 200 on Enterprise. A real-time routing agent runs well under that, but if you plan to run a Study or backfill across thousands of historical conversations, pace it against your plan's ceiling so Macha's calls don't compete with your team's other integrations for the same shared budget.
• Scope the token tightly. A token with company-wide Delete permission is a liability. Grant the narrowest set that lets the agent do its job, and revoke tokens you're not using.

Macha won't replace Front's own automation — Front rules, SLAs, and assignment logic stay in charge. Macha adds the judgment layer on top: the reading, classifying, and cross-system lookups that rules can't do.

How this compares to the alternatives

The market for "AI in Front" splits into a few buckets. Front's own Autopilot and Topics give you native, in-product AI categorization and auto-reply. Third-party tools like eesel AI install from the Front App Store and resolve tier-1 conversations against your knowledge base. Both are solid for a Front-only world.

Macha's angle is different in one specific way: it's an agent layer that reasons across Front and your other systems in a single run. A native or App Store tool answers from your help center; a Macha agent can read the Front conversation, look up the actual order in Shopify, check the payment in Stripe, search your Notion runbook, then tag, assign, and reply — and do the same on Zendesk or Freshdesk if you run more than one helpdesk. If your routing decisions depend on data that lives outside Front, that's the gap Macha fills.

FAQ

Does Macha replace Front? No. Front stays your shared inbox and source of truth. Macha is an AI agent layer that connects to Front via API token and takes actions inside it — tagging, assigning, commenting, replying. Your channels, teams, and rules don't move.

How does Macha authenticate to Front? With an API token you generate at Settings → Developers → API Tokens in Front (admin-only). You scope it by features, namespaces, and read/write/delete/send permissions — grant only what the agent needs.

Can the agent send replies to customers, or only route internally? Both, and it's your choice. Give the token and agent the Send permission plus a knowledge/commerce source to draft and send public replies; withhold it to keep the agent internal-only (tag, assign, comment) while humans own the customer-facing reply.

What triggers an agent in Front? Four options: Conversation Created, New Message Added, Conversation Assigned, and a Custom Webhook you wire into any Front rule for surgical control over which conversations fire.

How much does it cost to run? Macha is credit-based — credits are spent per AI action, priced by model (0.5–9 credits; default GPT-5.4 Mini = 1). A lightweight triage agent on GPT-5.4 Mini costs about 1 credit per conversation it processes. See pricing for plans.

Will it create duplicate or wrong tags? The Update Tags tool diffs against the conversation's current tags and only adds/removes what's needed, and a well-instructed agent picks from your existing tag list rather than inventing new ones.

Get started

If you run Front and your routing still leans on a human reading every new conversation, this is a ten-minute setup that takes the first pass off their plate. Generate the API token, add the Front connector, start from a built-in agent template, and keep the first agent internal-only until you trust its calls. Start a 7-day free trial, no credit card required, or read the Connectors docs for the full reference. For the routing pattern itself, the triage-and-route use case walks through the same logic on a helpdesk queue.

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