Tentacle

TENTACLE is an autonomous AI support copilot that reasons across policies, simulates risk, and safely executes audited actions like refunds and cancellations via strict guardrails.

Comment

Inspiration

Most e-commerce support bots are frustrating dead ends: they regurgitate FAQ links, fail to understand context, and can’t actually resolve disputes. When human agents take over, they spend 2 to 3 days manually juggling policy documents, order histories, and payment dashboards just to process a basic refund or address change.

We asked ourselves: Why can't an AI support copilot safely execute the entire workflow from dispute to resolution? We built Tentacle to bridge the gap between conversational AI and transactional enterprise backends—moving from "chatbots that deflect" to "autonomous engines that resolve."

What it does

Tentacle is an autonomous AI operations copilot that ingests customer support disputes, evaluates business rules, simulates financial trade-offs, and safely executes end-to-end backend actions.

  • Autonomous Pipeline (Ingest $\rightarrow$ Classify $\rightarrow$ Retrieve $\rightarrow$ Plan $\rightarrow$ Act $\rightarrow$ Audit): Resolves routine disputes (refunds, cancellations, replacements, address changes) in ~4.2 minutes instead of days, hitting an 80%+ autonomous resolution rate.
  • Pre-Execution Business Simulation: Before committing financial actions, Tentacle models downstream impact on customer lifetime value (LTV), refund costs, retention probability, and SLA targets against alternative remedies.
  • Explainable Decision Ledger: Provides human reviewers with a transparent "Why This Action?" audit log detailing model confidence, exact policy citations, and triggered safety constraints.
  • Continuous Organizational Learning: Captures every human override, edited action draft, and escalation as training signal to adapt confidence scoring over time.
  • Smart Escalation: Automatically routes anomalous, high-value, or emotionally volatile tickets to human operators with pre-compiled context and one-click execution recommendations.

How we built it

  • Frontend & Architecture: Next.js 16 (App Router), React 19, and TypeScript with Tailwind CSS for an operator dashboard.
  • Data Layer & ORM: PostgreSQL managed with Prisma ORM, storing immutable audit logs, case states, and customer event histories.
  • Multi-Source RAG Pipeline: Retrieves context concurrently from vector embeddings of internal company policies, transactional order databases, and historical resolution logs.
  • Safety & Actuation Layer:
  • Deterministic SHA-256 idempotency hashing (caseId:stepId:action) to guarantee zero duplicate refunds or duplicate inventory dispatches on retries.
  • In-flight PII redaction pipeline sanitizing credit cards, phone numbers, and SSNs before any prompt hits LLM endpoints.
  • A 3-tier circuit breaker pattern with heuristic regex fallbacks to keep critical flows online if an upstream AI endpoint degrades.

Challenges we ran into

  • Deterministic Financial Safety vs. Probabilistic LLMs: LLMs are inherently non-deterministic, making them dangerous around financial transactions. We solved this by decoupling reasoning from execution: the model outputs an action plan, but a strict deterministic validation layer inspects policy boundaries and enforces SHA-256 idempotency locks before invoking payment APIs.
  • Retrieval Discrepancies: Support decisions require real-time SQL data (order status, shipment location) combined with semantic policy knowledge (return windows, condition tiers). We had to design a hybrid retrieval orchestrator that unifies structured relational queries with unstructured vector search seamlessly.
  • Preventing Cascading Failures: When external LLM APIs experience rate limits or latency spikes, a customer support queue can collapse. Building our 3-tier circuit breaker with automatic regex/heuristic fallback rules was critical to ensuring high availability.

Accomplishments that we're proud of

  • Sub-5-Minute Full Resolution: Achieving a complete, verified autonomous loop—from raw customer complaint parsing to database mutation and customer notification—in an average of 4.2 minutes.
  • Zero-Hallucination Guardrails: Building an actuation pipeline where the AI cannot execute any action that violates programmatic bounds (e.g., refund amounts exceeding the order value or returns outside policy limits).
  • The "Why This Action?" Engine: Creating an audit ledger that translates complex vector retrieval scores and multi-variable simulation weights into plain-English justifications for operators.

What we learned

  • Autonomous agents in enterprise environments must follow a Zero-Trust architecture: treat all LLM outputs as untrusted user inputs until validated against deterministic schema constraints.
  • Feedback loops are everything. Human-in-the-loop isn't just an escalation safety net—it's the primary engine for organizational learning and model alignment.
  • Real-world support automation isn't about natural conversation; it's about reliable, audited state changes.

What's next for Tentacle

  • Multi-Platform Omnichannel Connectors: Native webhooks for Zendesk, Gorgias, Freshdesk, Shopify, and Salesforce Service Cloud.
  • Multimodal Evidence Verification: Ingesting and verifying image and video attachments (e.g., verifying broken item photos using vision models before approving damage claims).
  • Cross-Merchant Fraud Ring Detection: Graph-based anomaly detection to spot coordinated return abuse and synthetic identity fraud across multiple accounts.
Share this project:

Updates