Eliminate $8k–$15k/month in support cost — without hiring more agents.
The Agent Control Plane (ACP) is a routing intelligence system for customer support. Your support stack isn't short on tools. Zendesk routes. A chatbot deflects. A BI dashboard reports. What's missing is the decision layer that ties them together — remembers every decision it made, and learns from every correction your team makes.
How $22 a ticket becomes $0.65 per resolution — without replacing your stack.
Watch the trailer →
ACP is the traffic controller between your customers and your support org. Every ticket is scored, every decision is traced, and every human correction is fed back into the model.
Every team feels them. Zendesk triggers, a chatbot, a few macros — they each solve a piece. The costs live in what falls between them — where tickets stall, misroute, and your team ends up doing the same work twice.
Humans reading and routing tickets that rules could handle. Every minute spent on triage is a minute not spent resolving. Triggers and macros are too shallow to do it well.
The same password resets, refund questions, and order-status checks consume your live agents — over and over. Standalone chatbots try to help, then hallucinate when the question gets specific.
When a ticket misroutes or a bot misfires, nobody can explain why. No memory, no traceability, no learning. The next ticket repeats the mistake.
High-confidence tickets resolve themselves. The rest arrive at an agent's desk pre-classified, pre-prioritized, and pre-summarized — so triage time disappears.
A customer submits a ticket. ACP sees it before any agent does — scoring priority, customer tier, and intent in under two seconds. No manual triage required.
Password resets, order status, common billing questions — ACP answers them correctly and closes the ticket. Your agents never see it. Customer gets a response.
Tickets that need a human land with priority assigned, team selected, and a routing summary already written as an internal note. Agents open a ticket and skip triage entirely.
For your engineering or ops team evaluating the integration.
Zendesk fires a per-tenant webhook into n8n. Payload is canonicalized — tenant id, ticket id, subject, body, tags, requester — and dispatched to the Decision Engine. Every hop is logged.
The FastAPI Decision Engine runs three deterministic gates: VIP gate → Tier 0 deflection → Tier 1 classify-and-route. Cheap decisions first, expensive ones only when warranted.
n8n applies the action — public reply, routing, tag change, or HITL note. Every hop writes to acp_events and acp_decisions. Visible in the console instantly.
Matches Zendesk tags (vip, enterprise, platinum). Skips Tier 0 and Tier 1, forces urgent priority, routes straight to a senior agent. Bots never reply to your top-10 accounts.
RAG over your knowledge base via pgvector. Cosine similarity below threshold = clean escalation, not a guess. Stateful multi-turn conversations. No hallucinated answers to novel tickets.
Deterministic keywords (fast, cheap) reconciled with LLM signal. A policy engine decides whether to act automatically or require human approval. Routing rationale lands as an internal note in Zendesk.
Per-ticket pricing on resolution and routing. A single flat fee for the Operator Console. No per-seat charges, no annual lock-in to start.
ACP automatically answers repeatable tickets using your knowledge base. When confidence is high, the customer gets a correct response instantly — and the ticket is resolved before an agent ever sees it.
When a ticket needs a human, ACP classifies it, assigns a priority, and sends it to the right team — with a routing summary already written as an internal note. Agents skip triage entirely.
The control surface for your team. Live decision feed, HITL review queue, routing analytics, knowledge base management, and per-tenant access controls. Required for every workspace.
Three properties no other tool combines: deterministic VIP protection, threshold-gated deflection, and a learning loop that compounds on your data.
Bots never accidentally reply to your top-10 accounts. A tag-based gate (vip, enterprise, platinum) short-circuits all automation, forces urgent priority, and audit-logs the decision. Your highest-revenue customers always get a human.
Tier 0 only answers when cosine similarity against your knowledge base clears a threshold. Below it, the ticket escalates cleanly to a human. No hallucinated answers to novel tickets, ever.
Every operator correction becomes runtime weight immediately and a permanent classification keyword overnight. The system you buy in Q1 isn't the system you operate in Q3 — it's sharper.
Every pipeline hop writes to acp_events. Every final decision writes to acp_decisions. Every error writes to acp_errors. When something misroutes, you can always explain why.
Industry benchmark: $22 manual cost per support ticket (Zendesk / Gartner / HDI). On 1,000 tickets/mo with 40% Tier 0 deflection, ACP saves $10,075 against $915 of cost — and the math compounds with volume.
ACP is multi-tenant by design — every row is tenant-scoped, every webhook is per-tenant, the console enforces tenant-scoped login. One instance can serve one team or a thousand.
One Zendesk, one knowledge base, one team. Run ACP as the decision layer above your existing stack. Connects via API in days. Your agents keep working in the tool they already know — ACP just handles triage and deflection before tickets reach them.
Also built for
Running support for multiple clients. Per-tenant data isolation means you operate one ACP instance for all of them. Per-tenant webhooks, per-tenant knowledge bases, per-tenant decision histories. Data never crosses.
White-label the decision layer to your customers. Tenant-scoped console login, per-tenant policy engines, regional data residency on request. One vendor, every customer's compliance posture respected.
Triggers are rules. ACP is a decision system with memory, policy, and learning. Triggers can't deflect with RAG, can't reconcile keyword + LLM signals, and leave no trace when they misfire. ACP ties intake, classification, deflection, routing, and learning into one traceable pipeline — and remembers every decision.
That's why VIP accounts short-circuit automation entirely, Tier 0 only fires above a cosine-similarity threshold, and every tenant can require HITL-before-send. ACP is built to answer correctly or not at all. Below the threshold, the ticket escalates cleanly — never a guess.
Chatbots are blind to priority, routing, SLA, and policy. ACP is the decision layer around the chatbot — the chatbot is just Tier 0. The full system also handles deterministic VIP escalation, classify-and-route for everything Tier 0 can't answer, audit logging, and a learning loop that compounds on your data.
Every row in ACP's Postgres is tenant-scoped. Webhooks fire per-tenant. The Operator Console enforces tenant-scoped login. One ACP instance can serve many customers — but data never crosses. Regional data residency available on request.
Days, not quarters. We connect via API and ingest your knowledge base into pgvector. Tickets matching a KB article are auto-resolved by ACP; tickets without a match are classified and routed to the appropriate team in Zendesk. Low-confidence classifications queue for human review. No platform migration. No agent retraining.
Most teams see measurable deflection in the first week. Every ACP decision is logged in the Operator Console with the routing category, confidence score, and outcome. By the end of week one, you'll know exactly what your auto-resolution rate, routing accuracy, and blended cost per ticket look like.
The moat isn't the model — it's the labeled corrections dataset each tenant accumulates in their own Postgres. The longer you run ACP, the more your Tier 1 classifier outperforms a generic one, and the higher your switching cost. You're not buying a one-time tool; you're buying a decision system that compounds on your data.
Every pipeline hop writes to acp_events. Every final decision writes to acp_decisions. Every error writes to acp_errors and pages your team via Slack. Your operator opens the trace view in the console, sees exactly what happened, corrects it — and the correction immediately becomes a runtime override and an overnight classifier update.
ACP is not a wrapper around an LLM call — it's a multi-tenant decision system with a defined architecture, a real data model, and a learning loop that runs every night.
Two mechanisms convert corrections into improvement: one runtime, one nightly. Runtime confidence boost — when a new ticket is cosine-similar to a previously corrected label, Tier 1 applies an override weight immediately, no retrain required. Nightly recursive promoter — a scheduled job mines corrections into keyword_candidates; an operator reviews, approves, and the entry merges into acp_dynamic_keywords for live Tier 1 use.
acp_labels
→
Runtime override + nightly mine
→
keyword_candidates
→
Operator approve
→
acp_dynamic_keywords
→
Live in Tier 1
The moat isn't the model — it's the labeled corrections dataset each tenant accumulates in their own Postgres. The longer you run ACP, the more your Tier 1 outperforms a generic classifier. You're buying a decision system that compounds.
Every month without ACP leaves thousands in avoidable support cost on the table.
We'll map your ticket flow, calculate your exact ROI live, and show ACP running on a sample of your real data. No commitment required.