CX & Product Intelligence_ARCHITECTURE

Stop Tagging. Start Understanding.

Zendesk reporting is rigid, and manual ticket tagging is fundamentally broken. Arcli’s AI agents autonomously ingest your Zendesk data, flatten the notorious custom field arrays, and let you query your entire support operation in plain English.

Start Free Trial
14-DAY TRIAL
NO CREDIT CARD
Correlating Support with Churn Risk
By automatically joining Zendesk tickets with Stripe subscription data, Arcli identifies exactly how much MRR is at risk due to specific bug categories or missed SLA times.
Eradicating the Tagging Backlog
Human agents mistag or ignore ticket categorizations. Arcli's Semantic Engine reads the actual ticket payload, applying consistent, retroactive NLP categorization across thousands of historical conversations.
Automated SLA Watchdogs
Deploy anomaly detectors that monitor First Response Time (FRT) and automatically alert Slack when VIP Enterprise customers (identified via Salesforce/Stripe sync) are waiting longer than their contractual SLAs.
// STRATEGIC_DEPLOYMENT

Strategic Deployment

Real-world orchestration patterns deployed by our top enterprise partners.

Agent Performance & True SLA Adherence

The AI agent queries the normalized Zendesk audit logs to calculate exact timestamp deltas between ticket creation and the first public agent comment, automatically excluding weekends and out-of-office hours based on your semantic workspace definitions.

Product Friction via NLP Extraction

Instead of relying on dropdown tags, Arcli performs full-text vector analysis over the ticket descriptions. The anomaly detector flags statistical deviations in specific keyword groupings, alerting the Product team to undocumented bugs in real-time.

Support Cost vs. Customer LTV (Cross-Platform)

This is where Arcli outclasses traditional dashboards. The agent seamlessly joins Zendesk ticket handles with Stripe Customer IDs, calculating the aggregate 'cost to serve' based on total resolution hours divided by the cohort's MRR.

// STRATEGIC_SCENARIO

Deep Data Retrieval

How Arcli grounds AI in your exact schema to generate highly-optimized, dialect-specific execution logic.

The Engine Room: Joining Zendesk with Financial Data

To answer the Strategic Scenario ('Support Cost vs. LTV'), the Arcli query planner generates this complex PostgreSQL query. It dynamically unrolls Zendesk's nested JSON arrays, calculates business hours, and bridges the gap to Stripe billing data.

THE EXECUTIVE FILTER (ROI)

Allows COOs and VP of CS to instantly see if they are over-servicing low-value customers, leading to data-driven pricing, gating, and support-tiering decisions.

  • Fully optimized for sql constraints.
  • Bypasses semantic layer hallucinations via strict schema grounding.
sql_COMPILE

-- AI Agent Generated: Support Cost vs Customer Tier (Zendesk + Stripe)
-- Dialect: Standard PostgreSQL / Snowflake
-- Target: Calculate average ticket handling time and volume, grouped by Stripe MRR.

WITH parsed_tickets AS (
    SELECT 
        id AS ticket_id,
        created_at,
        -- Safely extract email from nested requester JSONB
        requester_info->>'email' AS customer_email,
        -- COMPLEXITY: Zendesk stores custom fields as an array of objects [{"id": 123, "value": "x"}]
        -- We must unnest the array to find the specific "Category" field (assuming ID 360012345678)
        (
            SELECT cf->>'value' 
            FROM jsonb_array_elements(custom_fields) cf 
            WHERE cf->>'id' = '360012345678'
        ) AS ticket_category,
        -- Calculate total time open in hours
        EXTRACT(EPOCH FROM (updated_at - created_at))/3600.0 AS resolution_hours
    FROM tenant_workspace.zendesk.tickets
    WHERE status IN ('solved', 'closed')
      AND created_at >= CURRENT_DATE - INTERVAL '90 days'
),
stripe_customers AS (
    SELECT 
        c.email,
        s.status AS sub_status,
        -- Calculate MRR in dollars
        SUM(s.plan_amount_cents) / 100.0 AS current_mrr,
        -- Dynamically bucket customers into revenue tiers
        CASE 
            WHEN SUM(s.plan_amount_cents) / 100.0 >= 1000 THEN 'Enterprise ($1k+)'
            WHEN SUM(s.plan_amount_cents) / 100.0 >= 100 THEN 'Pro ($100+)'
            ELSE 'Basic/Free'
        END AS customer_tier
    FROM tenant_workspace.stripe.customers c
    JOIN tenant_workspace.stripe.subscriptions s ON c.id = s.customer_id
    WHERE s.status = 'active'
    GROUP BY c.email, s.status
),
cross_platform_join AS (
    -- Bridge Zendesk and Stripe via normalized email
    SELECT 
        t.ticket_id,
        t.ticket_category,
        t.resolution_hours,
        COALESCE(s.customer_tier, 'Unknown/Non-Subscriber') AS customer_tier,
        COALESCE(s.current_mrr, 0) AS mrr
    FROM parsed_tickets t
    LEFT JOIN stripe_customers s ON LOWER(TRIM(t.customer_email)) = LOWER(TRIM(s.email))
)
-- Aggregate metrics for executive view
SELECT 
    customer_tier,
    COUNT(DISTINCT ticket_id) AS total_tickets,
    ROUND(AVG(resolution_hours)::numeric, 2) AS avg_resolution_hours,
    SUM(mrr) AS total_mrr_impacted,
    -- Calculate efficiency ratio (Tickets generated per $1k of MRR)
    CASE 
        WHEN SUM(mrr) = 0 THEN 0
        ELSE ROUND((COUNT(DISTINCT ticket_id) / (SUM(mrr) / 1000))::numeric, 2) 
    END AS tickets_per_1k_mrr
FROM cross_platform_join
GROUP BY 1
ORDER BY avg_resolution_hours DESC;
        
ZERO_DATA_MOVEMENT

Architecturally impossible to mutate your production data.

Arcli operates on a strict Read-Only security model. We generate the execution logic, but your warehouse executes the compute. Your data never leaves your VPC.

Automated Data Sanitizer

Arcli's `data_sanitizer` acts as a middleware layer during ingestion, utilizing regex and local NER models to mask credit cards, SSNs, and API keys before they ever hit the database.

Zero-Retention LLM Context

When using our text-to-SQL capabilities, we guarantee zero data retention. Your Zendesk ticket payloads are never used to train foundational AI models.

Row-Level Multi-Tenancy

In embedded SaaS scenarios, Arcli strictly enforces Tenant IDs. Agent A can never accidentally query or aggregate tickets belonging to Agent B.

// DOCUMENTATION

Expert Insights

Everything you need to know about implementing Arcli's engine into your stack.