Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.sigmic.ai/llms.txt

Use this file to discover all available pages before exploring further.

The widget is not a chatbot. It is an agent with access to your systems — embedded where your users already work. It calls APIs, runs code, processes data, and takes action across multiple tools in a single conversation. These use cases all require capabilities that go beyond a single LLM call: multi-step tool execution, live access to external systems via MCP, sandbox compute, and scheduled automation.
Each use case below describes where the widget lives, who interacts with it, what the agent actually does (step by step), how hard it is to set up, and the ROI case for your team.

Order Management

Automate returns, refunds, and order changes across fulfillment, payment, and email systems — 5-6 tool calls per interaction, zero human agents.

Sales Call Prep

Synthesize briefings from CRM, email, support tickets, and analytics in 30 seconds — so reps show up prepared every time.

Scheduled Alerts

Non-technical users create recurring monitoring and alerts in plain English. No cron, no Zapier, no engineer required.

Churn Detection

Score accounts across usage, support, and billing data — then draft outreach and set up weekly automated re-checks.

Customer Operations: Order Management

Where it lives

Embedded on your e-commerce storefront, order status page, or customer account dashboard.

Who uses it

Your customers — the people who placed orders and need help with returns, refunds, shipping issues, or order changes.

What the agent does

A customer types “I want to return order #4521.” The agent doesn’t just respond with a policy link. It executes a multi-step workflow:
  1. Looks up the order via your order management API (MCP tool call)
  2. Checks return eligibility against your policy rules (date window, item condition, order status)
  3. Initiates the return in your fulfillment system (MCP tool call — pauses for approval if configured)
  4. Triggers the refund in your payment system (MCP tool call to Stripe, Adyen, etc.)
  5. Sends a confirmation email to the customer with return label and timeline (MCP tool call to your email service)
  6. Updates the order status in your database
That is 5–6 sequential tool calls across 3–4 different systems, where each step depends on the result of the previous one. A single LLM call cannot do this.

Setup effort

  1. Connect your APIs as MCP servers — order management, payment, email, and fulfillment. Each is a thin wrapper around your existing REST APIs. If your team can write a curl command, they can create an MCP server.
  2. Create a widget app in the Console with your storefront’s domain as the allowed origin.
  3. Add two script tags to your site — the standard widget embed.
  4. Pass customer-scoped credentials at token exchange time using secrets (e.g., the customer’s Stripe customer ID, your internal API tokens). These never touch the browser.
No AI expertise required. No model training. No prompt engineering beyond describing the return policy in your project’s system instructions.

ROI

Each human-handled support ticket costs $5–15 depending on your region and support tier. Order status, returns, and refund requests make up 60–70% of inbound support volume for most e-commerce businesses. The widget handles this slice autonomously — end to end, in under a minute, 24/7. A 50-person support team operates like 80, and the remaining human agents focus on the complex cases that actually need judgment.
Configure tool approval policies to require human confirmation for high-value actions like refunds above a threshold. The widget’s approval workflow pauses execution until a human approves or rejects the tool call.

Internal Productivity: Sales Call Prep

Where it lives

Embedded in the sidebar of your CRM dashboard

Who uses it

Your sales reps, account managers, and customer success managers — anyone who needs to prepare for a customer interaction.

What the agent does

Before a call, a rep types “Prep me for the Acme Corp meeting at 3pm.” The agent pulls data from multiple systems and synthesizes a briefing:
  1. Queries the CRM for Acme’s deal history, pipeline stage, contract value, and key contacts (MCP tool call)
  2. Pulls the last 5 email threads with Acme from the email integration (MCP tool call)
  3. Checks open support tickets from Acme in your ticketing system (MCP tool call)
  4. Pulls recent product usage metrics from your analytics platform (MCP tool call)
  5. Runs analysis in the sandbox — compares usage trends against the contract tier, flags churn risk signals, identifies upsell opportunities
  6. Produces a one-page briefing with talking points, risk flags, and recommended next steps
That is 4+ parallel API calls across different systems, followed by compute-heavy analysis in the sandbox. The agent adapts its output based on what it finds — if there are open P1 tickets, those get surfaced prominently. If usage is spiking past the current plan, the upsell angle gets highlighted.

Setup effort

  1. Connect CRM, email, ticketing, and analytics as MCP servers. These are standard REST API integrations — your team writes a thin adapter for each.
  2. Embed the widget in your CRM’s sidebar or internal tools portal using the standard embed.
  3. Pass rep-scoped credentials at token exchange time via secrets, so the agent only accesses data the rep is authorized to see.
If your systems already have REST APIs (and they almost certainly do), each MCP adapter takes a few hours to write — not weeks.

ROI

Sales reps currently spend 20–30 minutes before each call clicking through 4 different tools — CRM, email, support tickets, analytics — and mentally stitching the story together. Most skip it and wing the call instead. The agent does it in 30 seconds. Across a 50-person sales team taking 5 calls per day, that is 400+ hours per week recovered. But the bigger number is deal quality: reps who show up prepared close more, retain more, and expand more. The prep that used to be skipped now happens every time.

Automated Monitoring: Scheduled Alerts

Where it lives

The user configures the automation through the widget (on your internal dashboard or ops portal), and then it runs autonomously on a schedule.

Who uses it

Operations managers, finance leads, or any non-technical stakeholder who needs recurring reports from live systems — and currently relies on an engineer to build and maintain a custom script or Zapier chain.

What the agent does

A finance lead opens the widget on your internal tools portal and types: “Every morning at 8am, check Stripe for failed payments over $500 and post a summary to #finance on Slack.” The agent creates a scheduled task that executes daily:
  1. Queries the Stripe API for failed charges in the last 24 hours over the $500 threshold (MCP tool call)
  2. Filters and groups the results by failure reason (card declined, insufficient funds, expired card, etc.)
  3. Formats a summary with total count, total amount, and breakdown by reason
  4. Posts the summary to Slack in the #finance channel (MCP tool call)
  5. If critical failures exceed a threshold, tags the on-call finance lead in the Slack message
The next day, the user can modify it just as naturally: “Change the threshold to $1,000 and add the CFO to the Slack message.” No code, no config files, no redeployment.

Setup effort

  1. Connect Stripe and Slack as MCP servers. Both have well-documented REST APIs.
  2. Embed the widget on your internal tools portal.
  3. That’s it. The user defines the automation in plain English. No cron syntax, no workflow builder, no YAML.
The scheduled task runs via the platform’s built-in task scheduling — no external scheduler needed.

ROI

This replaces three things that are each expensive in different ways:
  • Custom scripts that an engineer has to write, deploy, monitor, and maintain — typically 1–2 weeks of eng time per automation, plus ongoing maintenance when APIs change.
  • Zapier/Make workflows that break silently, cost per execution, and can’t handle conditional logic well.
  • Manual processes where someone logs into Stripe every morning and copies numbers into Slack — boring, error-prone, and one vacation away from being skipped.
The widget lets a non-technical user create automations that would normally require engineering time to build. Each one you don’t have to custom-build saves 1–2 weeks of eng effort upfront and ongoing maintenance costs.

Customer Success: Churn Risk Detection & Intervention

Where it lives

Embedded in your customer success dashboard, account management portal, or CRM sidebar.

Who uses it

Customer success managers (CSMs) responsible for a portfolio of accounts — anyone whose job is to keep customers healthy and prevent churn.

What the agent does

A CSM opens the widget and types “Check health scores for my portfolio.” The agent doesn’t just return a static dashboard — it runs a live, multi-system investigation:
  1. Pulls product usage metrics for the CSM’s accounts from your analytics platform — login frequency, feature adoption, usage trends over the last 30/60/90 days (MCP tool call)
  2. Pulls open support tickets and CSAT scores from your ticketing system to gauge support sentiment (MCP tool call)
  3. Checks billing status — overdue invoices, recent plan downgrades, approaching renewal dates (MCP tool call)
  4. Runs a risk analysis in the sandbox — scoring each account on usage trend, support sentiment, billing health, and engagement recency. The agent writes and executes the scoring logic on the fly, adapting to the data it finds
  5. Produces a prioritized watchlist with specific churn indicators per account — not a generic “health score,” but concrete reasons like “usage dropped 40% after their admin left” or “3 unresolved P1 tickets in the last 2 weeks”
  6. For the top 3 at-risk accounts, drafts personalized outreach emails referencing the specific issues found (MCP tool call to email, with approval before sending)
  7. Optionally sets up a recurring weekly check (scheduled task) that re-runs the full analysis and posts changes to a Slack channel — so the CSM gets alerted when an account’s health shifts
This is 4+ API calls across different systems, followed by compute-heavy analysis in the sandbox, followed by action (email drafts, Slack alerts, scheduled automation). The agent adapts its output based on what it finds — if an account has billing issues, that gets surfaced differently than one with declining usage.

Setup effort

  1. Connect your analytics, ticketing, billing, and email platforms as MCP servers. Each is a thin wrapper around existing REST APIs.
  2. Embed the widget in your CS dashboard or internal tools portal using the standard embed.
  3. Pass CSM-scoped credentials at token exchange time via secrets, so the agent only accesses accounts in the CSM’s portfolio.
  4. No ML pipeline or data science team needed — the scoring model runs as code in the sandbox. The agent writes the analysis based on the data it finds.

ROI

CSMs currently rely on gut feel or stale health score dashboards that update monthly. By the time they notice churn signals, the customer is already halfway out the door. The agent surfaces problems while there is still time to act — before the renewal conversation, before the competitor evaluation, before the executive sponsor stops responding. Reducing churn by even 2–3% on a $10M ARR book pays for the entire platform many times over. The scheduled weekly check turns this from a one-time analysis into a continuous early warning system. CSMs stop firefighting and start preventing fires.
Use scheduled tasks to run the health check weekly and post a diff (“Acme Corp: usage down 15% vs. last week, new P1 ticket opened”) to your CS team’s Slack channel. No human action needed after initial setup.

What Makes These Work

Every use case above depends on the same set of platform capabilities that a standard chatbot or single LLM call cannot provide:
CapabilityWhat it enables
MCP tool integrationThe agent calls your APIs — not just talks about them. It reads, writes, and takes action across your systems.
Sandbox computeThe agent runs code (data analysis, health checks, report generation) in an isolated environment.
Multi-step executionEach task involves 5–15+ sequential tool calls where each step’s output determines the next step’s input.
Tool approval workflowDestructive actions (refunds, credential rotations, data writes) pause for human confirmation before executing.
Scheduled tasksAutomations run on a cron schedule with no human in the loop after setup.
Secrets injectionCustomer credentials and API tokens are passed server-side, encrypted at rest, and never exposed to the browser.
End-user scopingEach customer’s conversations and data are isolated — multi-tenant by default.

Next Steps

Widget Setup Guide

Embed the widget in your application with JWT authentication

MCP Server Configuration

Connect your APIs so the agent can take action in your systems

Console

Create widget apps, manage credentials, and configure tool policies

Task API Use Cases

See how the same agent capabilities work via the programmatic API