Your AI Business Assistants

QuotyAI Assistants are purpose-built AI agents that work for your business around the clock. Unlike generic chatbots that guess answers, our assistants use your actual business rules to give 100% accurate responses, process orders, and manage appointments across all your customer channels.

The Story Behind QuotyAI Assistants

Our founder was traveling in Bali, trying to book a $20/night homestay. What should have been a 5-minute conversation took 3 days of back-and-forth messages, because the owner couldn’t reply quickly to pricing and availability questions. That’s why we built QuotyAI: to make sure no small business loses a customer because they can’t respond fast, or gives wrong pricing because their chatbot guesses.

Two Assistants, One Platform

QuotyAI gives you two specialized assistants that work together:

1. Sales Assistant: Your 24/7 customer-facing agent that talks to customers, gives quotes, books appointments, and processes orders.
2. Management Assistant: Your internal operations agent that tracks receipts, manages expenses, and alerts you when a customer needs a human touch.

Sales Assistant: Your 24/7 Customer Agent

Your Sales Assistant works across all your customer channels: Facebook Messenger, Telegram, WhatsApp, Instagram, your website, and even voice calls. It speaks 80+ languages, responds in 1-2 seconds, and sounds like a natural human.

What It Does For You

• Instant Answers: Replies to customer questions about your products, services, hours, and policies instantly.
• Accurate Quotes: Calculates pricing using your actual business rules, never guesses, never gives unauthorized discounts.
• Appointment Booking: Checks your calendar in real time, books appointments, and sends confirmations.
• Order Processing: Takes customer orders, validates all details, and confirms with the customer.
• Smart Handover: Knows when to pass a conversation to a human team member, and sends you a notification with full context so you can pick up right where the AI left off.

A Real Business Story

A small homestay owner in Bali uses QuotyAI to handle all booking inquiries. Now, when a traveler asks “How much for 3 nights next week?”, the assistant checks availability, gives the exact price (with discounts for longer stays, applied correctly every time), and lets them book immediately. No more 3-day delays, no more lost bookings.

Management Assistant: Your Internal Operations Agent

Your Management Assistant handles the behind-the-scenes work so you can focus on your business. It’s designed for business owners and managers, not customers.

What It Does For You

• Receipt Tracking: Snap a photo of a receipt, and the assistant processes it, categorizes expenses, and stores it for you.
• Financial Reports: Get daily or monthly income/expense summaries with a simple command:
  • /today: See today’s sales and expenses
  • /categories: Breakdown of expenses by category (supplies, rent, utilities)
  • /help: See all available commands
• Handover Alerts: Get notified immediately when your Sales Assistant passes a conversation to a human, with a summary of the customer’s issue so you can respond fast.
• Multi-Business Support: If you own multiple businesses, get consolidated reports across all of them.

A Real Business Story

A small cafe owner uses the Management Assistant to track all daily receipts. Instead of spending hours at the end of the week sorting through paper receipts, they snap a photo of each receipt when they get it, and the assistant automatically tracks their daily sales, supply costs, and profit. At the end of the month, they get a full breakdown of expenses by category to help with tax filing.

How It Works (High-Level)

We built QuotyAI Assistants to be reliable, transparent, and easy to update:

1. Your Business Rules, Captured: Tell us your pricing, availability, and policies in plain English. Our AI writes actual math formulas (not just text prompts) to make sure your assistant follows your rules exactly, every time.
2. Always Up-to-Date: Every time you update your business rules (e.g., change your pricing, add new services), we automatically create a new, immutable version of your assistant so it’s never using old information.
3. Safe & Secure: All the code our AI writes runs in a secure, sandboxed environment, so it can’t access your private data or make unauthorized changes.
4. Gets Better Over Time: Your assistant learns from every conversation. If it gets a question wrong, you can correct it, and it will improve for next time.

Why QuotyAI Assistants Are Different

Built For Your Industry

QuotyAI Assistants work for any small business, with pre-built workflows for:

• Restaurants & Cafes: AI maître d’ that handles reservations, menu questions, and daily specials in 80+ languages.
• Spas & Wellness: Books appointments, calculates service pricing with add-ons, and sends reminders.
• Real Estate: Schedules property viewings, gives accurate pricing and availability, answers neighborhood questions.
• Retail & E-Commerce: Tracks orders, checks inventory, handles returns and exchanges.
• Hospitality: Hotel booking, guest service questions, local recommendations.
• Professional Services: Schedules consultations, sends intake forms, confirms appointments.

Get Started Today

Setting up your QuotyAI Assistants takes minutes:

1. Tell us about your business (pricing, services, hours) in plain English.
2. Connect your customer channels (Facebook, Telegram, etc.).
3. Your assistant is live and ready to talk to customers immediately.

No developers, no long setup, no hidden fees. Just an AI assistant that works for your business.

Technical Implementation Details

Architecture Overview

┌─────────────────────────────────────────────────────────────┐
│                    Assistant Builder                        │
│  (sales-assistant.builder.ts / management-assistant.builder.ts) │
├─────────────────────────────────────────────────────────────┤
│  1. Extract Business Facts (PRICE, ORDER, AVAILABILITY)    │
│  2. Generate JSON Schemas (Offerings, Order)               │
│  3. Validate Schemas (retry logic with feedback)            │
│  4. Generate Executable Code (Pricing, Scheduling, Validation) │
│  5. Create Snapshots (Instructions, Config, Business Data)  │
│  6. Persist Immutable Version to MongoDB                    │
└─────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────┐
│                   Runtime Execution                         │
│  (unified-sales-assistant-chatbot.service.ts)              │
├─────────────────────────────────────────────────────────────┤
│  • Channel Adapters (Chatwoot, Facebook, Telegram, API)    │
│  • Skills System (8 modular skills with LangChain tools)     │
│  • Dynamic Runner (Sandboxed TypeScript execution)          │
│  • Observability (Full audit trails & backtraces)          │
└─────────────────────────────────────────────────────────────┘

Core Concepts

Immutable Versioning

Each assistant build creates a new MongoDB document — existing assistants are never modified. New versions are created when:

The builder implements smart schema reuse: schemas and generated code are reused from the previous version if business facts have not changed, unless forced regeneration is requested.

const shouldReuseSchemas = !forceSchemaRegeneration && !factsAreNewer && !!previousAssistant?.aiExecutableSource;

Assistant Snapshots

Each assistant version packages frozen snapshots to ensure deterministic, reproducible behavior:

Deterministic Code Execution

AI-generated code in aiExecutableSource runs in a sandboxed environment via DynamicRunnerService:

Sandbox Security:

• Uses Bun’s native Function constructor to execute TypeScript directly
• Exposes only safe globals (no file system, network, or real environment variables)
• Overrides console methods to use the application logger
• No access to fs, fetch, or network modules

Three Core Functions:

1. quoteOrder(order) — Calculates pricing with full audit backtraces
2. transformToCheckAvailability(order) — Processes scheduling/availability logic
3. validateOrder(order, pricingParams, schedulingParams) — Validates order parameters against business rules

Sales Assistant (Technical Details)

The Sales Assistant is the primary customer-facing agent, handling end-to-end sales conversations with:

• 80+ languages with native quality
• 24ms low-latency voice conversations via LiveKit
• Natural human-like fluency with emotion detection

Build Pipeline

The SalesAssistantBuilderService automates assistant creation:

Business Entity Fetch
       ↓
Schema Reuse Check ─── Yes ──→ Reuse Previous Schemas
       ↓ No
Generate New Schemas:
  • Offerings JSON Schema (with validation retry)
  • Order JSON Schema (with validation retry)
  • Compile to TypeScript interfaces (json-schema-to-typescript)
       ↓
Generate Executable Code:
  • Pricing Formula (AiPricingFormulaGenerationAgent)
  • Scheduling Function (AiSchedulingTransformationFunctionGenerationAgent)
  • Order Validation (AiOrderParameterValidationGenerationAgent)
       ↓
Build Snapshots (Instructions, Business, Config, LLM)
       ↓
Persist Immutable Version → MongoDB

Schema Validation Loop:

• Generate schema via AI coding agent
• Validate using dedicated validation agents
• If invalid, provide feedback and retry (up to 2 attempts)
• Return valid schema or throw error after all attempts fail

Runtime Execution

Incoming messages are processed by UnifiedSalesAssistantChatbotService:

1. Validate assistant and resolve LLM configuration (with fallback model support)
2. Route messages to the appropriate channel adapter
3. Build SkilledAgentRunContext with conversation history, snapshots, and executable code
4. Invoke LangchainChatSkilledSalesAgentService to generate responses

Channel Adapters

LangChain Agent

The LangchainChatSkilledSalesAgentService:

• Loads active skills via SkillsDirectoryService
• Builds system/human prompts via SalesAgentPromptBuilder
• Creates a LangChain agent with registered tools from active skills
• Supports model fallback middleware for high availability
• Integrates with LangChainObservabilityTracer for full decision traceability

Skills System

The Sales Assistant uses a modular, pluggable skills architecture. All skills implement the BaseSkill interface and are registered in SkillsDirectoryService.

Skill Activation Flow

Incoming Message
      ↓
SkillsDirectoryService.getLangchainTools(context)
      ↓
For each registered skill:
  • Check isActive(context) ── No ──→ Skip
                              ── Yes ──→ Get tools & instructions
      ↓
Aggregate all active skill tools
      ↓
Register with LangChain Agent
      ↓
LLM can invoke any active tool during conversation

Handover & Conversation Management

Handover Sensitivity

Configurable via userConfig.handoverSensitivity:

Conversation State

SalesAssistantConversationStateService tracks per-conversation state:

• Latest quote results and order parameters
• Sent attachment IDs (prevents duplicate sends)
• Handover state and customer name
• Active business entity and assistant assignment

Human Handoff

When the LLM invokes handoverRequest, the HandoverSkill:

1. Saves handover details as a private note in Chatwoot
2. Opens the conversation for human agent takeover
3. Sends notifications to Management Assistant’s configured receivers
4. Checks notifyCustomerBeforeHandover setting before notifying customer

Management Assistant (Technical Details)

The Management Assistant is an internal-facing agent for business owners and managers, focusing on operational efficiency rather than customer conversations.

Core Functions

Receipt Processing

• OCR-based text and image receipt processing
• Item categorization and storage
• AI-powered incomplete receipt correction (/fix command)

Financial Commands

Analytics & Reporting

• Daily/monthly financial summaries via BusinessEntityReceiptsService
• Category-based expense/income breakdowns
• Cross-entity summary reporting
• Multi-currency support

Handover Notifications

• Receives handover events from Sales Assistants
• Routes notifications to configured team members
• Configurable via managementConfigSnapshot.handoverEventReceivers

Implementation

Built using simpler command-based architecture (stateless, no conversation state):

Technical Differentiators

1. Zero Hallucination Pricing

Unlike generic LLMs that guess pricing, QuotyAI generates deterministic TypeScript functions that:

• Calculate prices with 100% consistency
• Provide full audit trails and calculation backtraces
• Are type-safe with compiled JSON schemas
• Execute in a sandboxed environment for security

2. End-to-End Platform

QuotyAI unifies three components that competitors only offer separately:

• AI Agents with industry-specific skills and deterministic code
• Omnichannel Inbox with native integrations and human handoff
• Knowledge Base with fact tagging and structured data extraction

3. Self-Improving AI

The EvolutionSkill automatically:

• Analyzes conversations to identify knowledge gaps
• Generates improvement suggestions for facts, instructions, or skills
• Learns from human guidance and corrections
• Triggers retraining when business facts change

4. BYOK + Fallback Support

• Bring Your Own Keys for Gemini, OpenAI, Anthropic models
• Primary/Fallback model configuration per assistant
• Per-tenant LLM settings with llmByokSnapshot
• Model fallback middleware in LangChain for high availability

5. No Middlemen

Business rules go from natural language to production-ready code in seconds:

Owner describes pricing rule in plain English
         ↓
AI Coding Agent generates TypeScript function
         ↓
Schema validation ensures correctness (with retry)
         ↓
Executable code stored in immutable assistant version
         ↓
Live in production — no developer needed

Traditional workflow: Owner → Analyst → Developer → QA → Production (days/weeks) QuotyAI workflow: Owner → AI → Production (seconds)

6. Full Observability

• LangChainObservabilityTracer captures every LLM call, tool invocation, and decision
• Calculation backtraces show exactly how prices were computed
• Conversation state and handover events are fully logged
• OpenTelemetry integration for distributed tracing

Feature Comparison