Desk FAQ

Desk is an AI-powered customer support agent that lives on WhatsApp (and other messaging channels). Think of it as a very knowledgeable front-desk receptionist who never sleeps — it reads your company's documents, understands your products and policies, and answers customer questions automatically, 24/7.

When a question is too complex or sensitive for the AI, it hands the conversation over to a human agent — with full context so the human doesn't have to start from scratch.

Crucially, Desk runs on your own infrastructure. Your customer conversations never touch third-party servers unless you explicitly choose to use a cloud AI model.

Three problems, in order of importance:

1. Data sovereignty. Customer support conversations contain names, phone numbers, order details, health information, financial data. Cloud-based tools (Intercom, Zendesk AI, Ada) send all of this to third-party servers — often in jurisdictions that conflict with data-residency laws like GDPR, HIPAA, or PDPA. Desk keeps everything on your own servers.
2. WhatsApp is underserved. WhatsApp is the dominant support channel in most of the world outside the US (2+ billion users). Yet most self-hosted support tools bolt WhatsApp on as an afterthought. Desk is designed WhatsApp-first.
3. Repetitive questions overwhelm teams. Most support teams spend 60-80% of their time answering the same questions. Desk automates this, freeing humans for complex, high-value conversations.

ChatGPT knows a lot about the general internet but knows nothing about your company. Ask it "What's your return policy?" and it will guess or refuse.

Desk is the opposite: it knows your documents inside out. It retrieves answers from your own knowledge base (product manuals, policy documents, FAQs) and can cite the exact source. It also speaks in your brand voice, follows your response policies, and keeps data on your servers.

Think of ChatGPT as a brilliant stranger, and Desk as a trained employee who has read your entire employee handbook.

"Self-hosted" means Desk runs on your own servers — either a machine in your office, a private cloud you control (AWS, Azure, GCP), or a server rented from a hosting provider. No one else has access to the hardware.

This matters because:

• Privacy: Customer conversation data never leaves your infrastructure (unless you choose to route some queries to cloud AI models).
• Compliance: You can satisfy data-residency requirements (GDPR, HIPAA, PDPA) because you control where data physically lives.
• No vendor lock-in: You own the deployment. If you stop paying for the software license, your data is still there, exportable, yours.

A conversation is a continuous thread of messages between a customer and Desk (or a human agent). It starts when a customer sends their first message and ends when the conversation is marked as resolved.

Each conversation has a state: it can be active (AI is handling it), escalated (a human agent has taken over), pending (waiting for customer reply), or resolved (closed). The state machine ensures nothing falls through the cracks.

"Model-agnostic" means Desk doesn't force you to use one specific AI brain. You can choose:

• Local models (e.g., Llama, Mistral) — run entirely on your own hardware. Maximum privacy, no per-message cost.
• Frontier models (e.g., GPT-4, Claude) — cloud-based, higher quality for complex questions, but data leaves your server.
• Hybrid routing — Desk automatically picks the right model per query. PII-heavy questions stay local; complex reasoning goes to frontier models.

You're not locked into any single AI provider. Switch models anytime without changing your setup.

ODW.ai is a suite of AI products for businesses. Desk is one module in that suite. The most important sibling is Vault — the suite's knowledge base and document intelligence platform.

Desk integrates deeply with Vault: when a customer asks a question, Desk queries Vault to find the relevant documents, then generates an answer grounded in those documents. If you already use Vault, Desk works in minutes — your knowledge base is already there.

Desk also shares authentication (single sign-on), user management, and billing with the rest of the suite.

Three primary audiences:

1. Regulated businesses (10–500 employees) — healthcare clinics, legal firms, fintech startups, government contractors, education institutions. These organizations need data sovereignty and can't send customer conversations to cloud SaaS.
2. Businesses in regions with strict data-localization laws — EU (GDPR), Brazil (LGPD), India, Southeast Asia (PDPA). Desk lets you keep data within your jurisdiction.
3. Developer-led companies and agencies — teams that want to white-label or deeply customize their support stack without vendor lock-in.

Desk is not designed for businesses that need 200+ integrations, visual flow builders, or full CRM functionality. It's focused on AI-first support with sovereignty.

No — and it's not designed to. Desk augments your human team, not replaces it.

Typical outcomes: Desk handles 60-80% of conversations end-to-end without human intervention (repetitive questions, FAQs, status checks). The remaining 20-40% — complex issues, emotional customers, edge cases — are escalated to human agents with full context.

The goal is to free your humans from repetitive work so they can focus on high-value conversations that actually need empathy and judgment.

Most open-source support tools (Chatwoot, Botpress) add WhatsApp as an afterthought — a connector bolted onto a web-chat-first architecture. This leads to awkward UX: message templates don't work properly, the 24-hour window isn't tracked, agent handoff is clunky.

Desk was designed from day one around WhatsApp's constraints and strengths:

• 24-hour session window — tracked natively. Desk knows when the window expires and switches to template messages automatically.
• Message templates — built-in management for approved templates (order confirmations, appointment reminders).
• Rich media — images, documents, location sharing all handled as first-class message types.
• Agent handoff — designed for the WhatsApp experience, not adapted from a web chat paradigm.

Desk offers two paths to connect WhatsApp — no other self-hosted solution offers both:

Choose Business API if you need Meta's official stamp of approval (healthcare, finance, government). Choose Baileys Bridge if you want to test Desk in 30 minutes without paperwork.

The Baileys Bridge is a quick-start WhatsApp connector that works by linking to WhatsApp Web — similar to how WhatsApp Web/Desktop works on your computer. You scan a QR code, and Desk can send and receive messages on that WhatsApp number.

Advantages:

• No Meta Business verification needed
• Setup in under 30 minutes
• Works with any WhatsApp account (personal or business)
• Free to use

Limitations:

• Unofficial — not endorsed by Meta
• Session can expire (typically 30 days, auto-reconnectable)
• Not suitable for very high-volume deployments

The WhatsApp Business API is Meta's official channel for businesses to message customers at scale. It's the same API that large companies use for order notifications, appointment reminders, and customer support.

To get access:

1. Create a Meta Business Manager account (if you don't have one)
2. Verify your business with Meta (requires business documents — registration certificate, utility bill)
3. Request WhatsApp Business API access through Meta or a Business Solution Provider (BSP)
4. Wait for approval (typically 1-5 business days)

Once approved, Desk connects directly to the API. You get official green-tick verification (optional), message templates, and full Meta support.

WhatsApp's Business API has a rule: once a customer sends you a message, you have 24 hours to reply with free-form messages. After 24 hours, the "session window" closes and you can only send pre-approved template messages (e.g., "Your order has shipped") until the customer messages you again.

Desk tracks this window automatically. If a conversation is approaching the 24-hour limit, Desk will:

• Switch to template messages for proactive outreach
• Alert your agent inbox that the session is expiring
• Log the window state for compliance auditing

You don't need to manage this manually — Desk handles it.

Desk supports multiple channels via a pluggable adapter system. Current and planned channels:

WhatsApp is the primary focus. Other channels are optional modules you can enable as needed.

Yes. Desk supports multiple channel adapter instances. You can connect multiple WhatsApp numbers (e.g., one for sales, one for support, one for each region) and manage them all from a single Desk deployment.

Each adapter instance has its own configuration, credentials, and message routing rules. Conversations from different numbers are kept separate but visible in the same agent inbox.

Yes. For WhatsApp Business API connections, Desk includes template management:

• Create, edit, and submit templates to Meta for approval
• Track template approval status
• Use templates for proactive messages outside the 24-hour window
• Template variables (e.g., {{customer_name}}, {{order_id}}) are populated automatically from conversation context

For Baileys Bridge connections, template messages are not available (the bridge uses free-form messages only).

Yes. Desk handles rich media messages:

• Images: Customers can send photos (e.g., of a damaged product). Desk can analyze them or route to a human agent.
• Documents: PDFs, Word files, spreadsheets — Desk can extract text and use it in the conversation.
• Voice messages: WhatsApp voice notes are transcribed (using Whisper or similar) and processed as text.
• Location: If a customer shares their location, Desk can use it for context (e.g., "Find the nearest branch").

All media is stored securely in your infrastructure (S3-compatible storage or local filesystem).

Chatwoot and Botpress are excellent open-source tools, but they have different design priorities:

Choose Chatwoot/Botpress if you need a general-purpose, web-chat-first tool with lots of integrations. Choose Desk if WhatsApp is your primary channel and you need data sovereignty + AI intelligence.

When a customer sends a message, here's what happens behind the scenes:

1. Channel Gateway — receives the message from WhatsApp (or other channel) and normalizes it into a standard format.
2. Message Router — identifies the customer, loads their conversation history, and decides: should AI handle this, or a human?
3. Conversation Manager — saves the message, updates the conversation state, and starts SLA timers (how long has the customer been waiting?).
4. PII Shield — scans the message for personally identifiable information (names, phone numbers, credit cards). If PII is detected, it's redacted before sending to cloud AI models, or the query is routed to a local model only.
5. Policy Engine — checks if the message triggers any response policies (e.g., competitor mentions, legal disclaimers). If a hard rule matches, a template response is sent immediately.
6. Model Router — decides which AI model to use (local or frontier) based on PII detection, complexity, and your routing policy.
7. Persona Service — composes the system prompt with your brand voice (tone, vocabulary, do's/don'ts).
8. Vault Client — queries your knowledge base (Vault) for relevant documents. Retrieves the top 5-10 most relevant chunks.
9. AI Engine — sends the customer's question + retrieved documents + brand persona to the AI model. Gets a response back.
10. Confidence Scorer — calculates how confident the AI is in its answer. If confidence is below your threshold, the conversation is escalated to a human.
11. Policy Engine (post-check) — validates the AI's response against your policies. If it violates a rule (e.g., mentions a competitor), it's rewritten or blocked.
12. Outbound Dispatcher — formats the response for WhatsApp and sends it back to the customer.

Total latency: <5 seconds for local models, <8 seconds for frontier models.

PII stands for Personally Identifiable Information — names, phone numbers, email addresses, credit card numbers, health records, etc.

The PII Shield is a component that scans every message (inbound and outbound) for PII. When it detects PII:

• Redaction: PII is replaced with placeholders (e.g., "John Smith" → [NAME]) before the message is sent to a cloud AI model.
• Routing: If PII is detected, the query is automatically routed to a local model only — it never touches a cloud API. This ensures sensitive data stays on your servers.
• Override: Admins can configure PII patterns (e.g., add industry-specific identifiers) and override routing rules if needed.

After the AI generates a response, Desk calculates a confidence score (0-100%) indicating how sure the AI is that its answer is correct and relevant.

You set a confidence threshold (e.g., 70%). If the AI's confidence is:

• Above threshold: Response is sent to the customer automatically.
• Below threshold: Conversation is escalated to a human agent. The AI's draft response is shown to the agent as a suggestion, but the human reviews and sends it.

This ensures the AI only handles questions it's confident about. Complex, ambiguous, or edge-case questions are handed off to humans — no guessing, no hallucination.

Three things can happen, depending on your configuration:

1. Escalation to human: If confidence is below your threshold, the conversation is escalated. A human agent sees the question + the AI's draft response (if any) and can take over.
2. Graceful fallback: The AI can be configured to say "I'm not sure about that. Let me connect you with a human who can help" — and then escalate.
3. Restricted topics mode: You can configure Desk to never answer questions outside your knowledge base. If a question can't be answered from your documents, it's escalated immediately — no guessing.

Desk never makes up answers. If it doesn't know, it says so and hands off.

When a conversation is escalated (low confidence, PII detected, or customer requests a human):

1. Agent Inbox notification: The conversation appears in the agent inbox with a flag: "Escalated by AI — low confidence" or "PII detected — routed to local model."
2. Context transfer: The human agent sees the full conversation history, the customer's profile, and the AI's draft response (if any).
3. Takeover: The agent clicks "Take Over." From that point, the AI stops auto-responding. The human handles the conversation.
4. Resolution: When the agent resolves the conversation, they mark it as "Resolved." Future messages from that customer go back to the AI (unless you configure it differently).

Agents can also proactively take over any conversation — they don't have to wait for escalation.

The agent inbox is a web-based interface where human agents can:

• View all conversations (AI-handled, escalated, pending, resolved)
• Take over conversations from the AI
• Respond to customers directly
• See real-time updates via WebSocket (no page refresh needed)
• Filter conversations by status, channel, customer, or tag
• View SLA timers (how long has this customer been waiting?)

The inbox is designed for speed — agents can handle multiple conversations in parallel, switch between them instantly, and see AI-suggested responses as drafts.

Desk tracks two key SLA metrics:

• First-response time: How long does it take for the customer to get a reply after sending their first message? (Target: <5 seconds for AI, <5 minutes for human handoff.)
• Resolution time: How long does it take to fully resolve the conversation? (Target varies by business.)

SLA timers are enforced automatically. If a conversation exceeds your SLA threshold, Desk can:

• Alert the agent inbox
• Escalate to a supervisor
• Log the SLA breach for reporting

You configure SLA thresholds in the admin dashboard.

Desk uses multiple layers to prevent hallucination:

1. Retrieval-Augmented Generation (RAG): The AI doesn't answer from memory. It retrieves relevant documents from your knowledge base (Vault) and generates answers grounded in those documents. If the documents don't contain the answer, the AI says so.
2. Confidence scoring: Every response gets a confidence score. Low-confidence responses are escalated to humans — they're never sent to customers automatically.
3. Policy guardrails: You can configure Desk to never answer questions outside your knowledge base (restricted topics mode). No guessing allowed.
4. Source citations: Every AI response includes citations to the source documents. Agents (and customers, if you enable it) can verify the answer by reading the original document.
5. Post-generation validation: The Policy Engine checks every response against your rules. If it violates a policy (e.g., mentions a competitor), it's rewritten or blocked.

Three safeguards:

1. Prevention: Confidence scoring + policy guardrails catch most errors before the response is sent.
2. Detection: If a customer says "That's wrong" or "I disagree," the conversation is flagged for human review.
3. Correction: Human agents can take over, correct the answer, and mark the conversation as resolved. The correction is logged for future analysis.

You can also review AI-handled conversations in the agent inbox to spot patterns and improve the knowledge base.

Yes. Every AI response includes source citations — links to the exact documents and page numbers the AI used. These citations are:

• Visible to human agents in the agent inbox
• Optionally visible to customers (you can enable/disable this in settings)
• Logged in the audit trail for compliance

This transparency lets you verify the AI's answers and build trust with customers.

Accuracy depends on three factors:

1. Quality of your knowledge base: If your documents are clear, complete, and up-to-date, the AI will be accurate. Garbage in, garbage out.
2. Model choice: Frontier models (GPT-4, Claude) are more accurate than local models (Llama, Mistral), but less private.
3. Configuration: Confidence thresholds, policy guardrails, and restricted topics mode all affect accuracy.

Typical outcomes: 60-80% of conversations are resolved by AI without human intervention. The remaining 20-40% are escalated to humans (either because the AI wasn't confident, or the customer requested a human).

Yes. Desk includes a Persona Preview/Test Tool that lets you:

• Simulate customer conversations in a sandbox environment
• Test how the AI responds to specific questions
• Preview the AI's tone and brand voice
• Verify that policy guardrails are working

You can also run Desk in "shadow mode" — the AI processes real customer messages and generates draft responses, but doesn't send them. Instead, drafts are logged for human review. This lets you evaluate AI performance before enabling auto-response.

Desk maintains conversation context across multiple messages. When a customer sends a follow-up question, the AI has access to:

• The full conversation history (previous messages)
• The customer's profile (name, past conversations, preferences)
• The retrieved documents from previous turns

This allows the AI to handle complex, multi-step conversations naturally. For example:

• Customer: "What's your return policy?"
• AI: "Our return policy is 30 days..."
• Customer: "What about electronics?"
• AI: "For electronics, the return window is 14 days..." (understands "electronics" refers to the return policy context)

Desk supports English and Chinese (Simplified and Traditional) out of the box. The AI can detect the customer's language and respond in the same language.

Additional languages can be added by:

• Configuring the AI model to support them (most frontier models support 50+ languages)
• Adding knowledge base documents in those languages
• Configuring the brand persona for language-specific tone and vocabulary

Not in v1.0. Desk is designed to answer questions, not execute transactions. This is a deliberate design choice — executing actions (creating refunds, booking appointments, modifying orders) introduces significant complexity and risk.

For v1.0, if a customer needs an action taken, the AI escalates to a human agent who can perform the action in your backend systems.

Generative actions are planned for a future release (v1.2+), but will require explicit configuration and approval workflows to ensure safety.

All data is stored on your own infrastructure:

• Conversation data: PostgreSQL database (on your server)
• Media files: S3-compatible storage (your bucket) or local filesystem
• Knowledge base: Vault (your deployment)
• Configuration: PostgreSQL database
• Audit logs: PostgreSQL database

No data is sent to ODW.ai servers. No data is sent to cloud AI providers unless you explicitly configure frontier model routing (and even then, PII is redacted).

Desk is compatible with GDPR, HIPAA, PDPA, and other data-protection regulations — but compliance depends on how you deploy it.

Desk provides the tools you need for compliance:

• Data sovereignty: All data stays on your servers. You control where it physically lives (important for data-residency requirements).
• Data export: Export all customer data in standard formats (JSON, CSV) for subject access requests.
• Data deletion: Delete customer data on request (GDPR "right to erasure"). Deletion is logged in the audit trail.
• Retention policies: Configure how long data is kept (e.g., "delete conversations after 2 years").
• Audit logs: Every AI decision, data access, and configuration change is logged.
• PII Shield: Automatically redacts PII before sending to cloud AI models.

Desk uses industry-standard encryption:

• In transit: TLS 1.3 for all network communication (HTTPS, WebSocket, database connections).
• At rest: AES-256 encryption for sensitive data in the database (e.g., customer PII, API keys). PostgreSQL Transparent Data Encryption (TDE) or filesystem encryption for the entire database.
• WhatsApp Baileys sessions: Encrypted auth credentials stored in the database.

You can also enable end-to-end encryption for specific use cases (e.g., healthcare) by configuring additional encryption layers.

Partially. Desk can run with local models only (no internet for AI inference), but it still needs internet for:

• WhatsApp Business API: Requires internet to connect to Meta's servers.
• WhatsApp Baileys Bridge: Requires internet to connect to WhatsApp Web.
• License validation: Periodic license checks (can be configured for offline validation with a license file).

If you need fully offline operation (e.g., air-gapped network), you can:

• Use local models only (Ollama, vLLM)
• Use a private WhatsApp bridge (e.g., on-premise WhatsApp Business API gateway)
• Use offline license validation

Fully offline operation is possible but requires custom configuration. Contact us for details.

The PII Shield scans every message for personally identifiable information:

• Detection: Uses NER (Named Entity Recognition) models and regex patterns to detect names, phone numbers, email addresses, credit card numbers, health records, etc.
• Redaction: PII is replaced with placeholders (e.g., "John Smith" → [NAME]) before sending to cloud AI models.
• Routing: If PII is detected, the query is automatically routed to a local model only — it never touches a cloud API.
• Configuration: Admins can add custom PII patterns (e.g., industry-specific identifiers like patient IDs, policy numbers).

PII detection runs on every message, inbound and outbound. You can configure the sensitivity level (strict, moderate, lenient) in the admin dashboard.

Desk maintains a tamper-evident audit log of every significant event:

• Every AI decision (model used, confidence score, retrieved documents, response generated)
• Every policy decision (guardrail triggered, response rewritten/blocked)
• Every data access (who accessed which conversation, when)
• Every configuration change (who changed what, when)
• Every data export/deletion request

Audit logs are stored in the PostgreSQL database and can be exported to SIEM systems (Splunk, ELK) for analysis. Logs are immutable — once written, they cannot be modified or deleted (only archived).

Yes. Desk provides compliance tooling for data export and deletion:

• Data export: Export all data for a specific customer (conversations, profile, media) in JSON or CSV format. Useful for GDPR "subject access requests."
• Data deletion: Delete all data for a specific customer. Deletion is permanent and logged in the audit trail. Useful for GDPR "right to erasure."
• Bulk operations: Export or delete data for multiple customers at once.
• Retention policies: Configure automatic data deletion after a specified period (e.g., "delete conversations after 2 years").

All export/deletion operations are performed by admins through the admin dashboard or via API.

No. Desk is self-hosted. ODW.ai has zero access to your data — conversations, knowledge base, configuration, audit logs, everything stays on your servers.

The only communication between your Desk deployment and ODW.ai is:

• License validation: Periodic checks to verify your license is valid (can be disabled for offline deployments).
• Support: If you contact support, you may share logs or configuration — but this is voluntary and controlled by you.

ODW.ai cannot access your data remotely. There is no "backdoor" or remote administration capability.

If your server is compromised, the attacker could potentially access:

• Conversation data (customer messages, AI responses)
• Knowledge base documents
• Configuration (including API keys for WhatsApp, AI models, etc.)
• Audit logs

Mitigation:

• Encryption at rest: Even if the database files are stolen, they're encrypted.
• Network security: Use firewalls, VPNs, and access controls to restrict who can access the server.
• Regular backups: Back up your data to a secure, separate location.
• Monitoring: Use the audit logs to detect suspicious activity.
• Incident response: If compromised, rotate all API keys, change passwords, and review audit logs to assess the breach.

Desk provides the tools for security, but you are responsible for securing your infrastructure. If you're not comfortable managing server security, consider using a managed hosting provider.

Desk integrates with Vault — the ODW.ai suite's knowledge base and document intelligence platform. When a customer asks a question:

1. Desk sends the question to Vault's retrieval API.
2. Vault searches its document corpus and returns the top 5-10 most relevant chunks (paragraphs).
3. Desk includes these chunks in the AI's prompt, so the AI generates an answer grounded in your documents.

If you already use Vault, Desk works in minutes — your knowledge base is already there. If you don't use Vault yet, you'll need to set it up first (separate product).

Vault supports 15+ file formats:

• Documents: PDF, Word (DOCX), PowerPoint (PPTX), Excel (XLSX), plain text (TXT, MD)
• Web content: HTML, Markdown
• Archives: ZIP (extracts and processes contents)
• Media: Images (OCR), audio/video (transcription)
• Code: Source code files (for technical documentation)
• Other: CSV, JSON, XML

Vault uses industry-standard PRONOM format signatures to identify file types (not just file extensions), so it handles misnamed files correctly.

Vault supports incremental updates:

• Add new documents — only new files are processed.
• Update existing documents — only changed files are re-processed (detected via SHA-256 hash).
• Delete documents — removed from the knowledge base immediately.

You don't need to re-process the entire knowledge base every time you make a change. Updates are fast and efficient.

You can also schedule automatic sync from folders (e.g., SharePoint, Google Drive, local filesystem) so the knowledge base stays up-to-date automatically.

Yes. Vault provides multiple ways to exclude documents:

• Folder-level exclusion: Exclude entire folders (e.g., "HR/Confidential").
• File-level exclusion: Exclude specific files (e.g., "salary_data.xlsx").
• Pattern-based exclusion: Exclude files matching a pattern (e.g., "*.private").
• Pre-processing review: Before processing, Vault generates a report of all discovered files. You can review and exclude sensitive files before they're indexed.

Excluded files are never processed or indexed. They remain in your filesystem but are invisible to the AI.

Vault uses SHA-256 hash-based deduplication:

• Every file is fingerprinted with a SHA-256 hash (a unique digital signature).
• If two files have the same hash, they're identical — Vault processes only one copy.
• This works even if the files have different names or are in different folders.

Deduplication saves processing time and storage space. It also ensures the AI doesn't retrieve the same document multiple times under different names.

When Vault processes documents, it chops them into small pieces (chunks) — usually a paragraph or two. But when a chunk is isolated, it loses context. A chunk that says "the maximum was 8 degrees" has no idea whether it's talking about a slope, a temperature, or a rotation angle.

Contextual retrieval fixes this: before storing each chunk, Vault asks a small AI model to write a one-sentence context tag like "This chunk describes the slope tolerance for the delivery robot in Section 4 of the deployment manual." That tag rides along with the chunk into the vector database.

Anthropic reported a 20-30% reduction in retrieval failures using this technique. Vault implements it by default. It's one of the biggest reasons Desk's answers stay accurate on messy, real-world document collections.

Yes. Vault supports multiple collections. You can create separate collections for:

• Departments (Sales, Support, HR, Legal)
• Products (Product A, Product B, Product C)
• Regions (North America, Europe, Asia-Pacific)
• Languages (English, Chinese, Spanish)

Desk can be configured to query specific collections based on the conversation context. For example, if a customer asks about Product A, Desk queries the Product A collection. If they ask about shipping, Desk queries the Support collection.

This ensures the AI retrieves the most relevant documents and doesn't mix information from different contexts.

Vault can handle very large knowledge bases:

• Documents: Thousands to tens of thousands of documents.
• Chunks: Hundreds of thousands to millions of chunks.
• Storage: Limited only by your server's disk space and PostgreSQL/ChromaDB capacity.

Performance depends on your infrastructure. For very large knowledge bases (100k+ documents), you may need to:

• Use a powerful server (16+ GB RAM, SSD storage)
• Optimize PostgreSQL and ChromaDB performance
• Use Redis caching to speed up retrieval

For most businesses (1k-10k documents), a standard server is sufficient.

Desk is deployed via Docker Compose (single-node) or Kubernetes Helm chart (clustered). The simplest path:

1. Install Docker and Docker Compose on your server.
2. Download the Desk Docker Compose file (docker-compose.yml).
3. Configure environment variables (database credentials, WhatsApp API keys, etc.).
4. Run docker-compose up.
5. Access the admin dashboard at http://your-server:8000.
6. Complete the setup wizard (connects WhatsApp, Vault, configures AI models).

Total setup time: <30 minutes for Baileys Bridge, <2 hours for Business API (including Meta verification).

Hardware requirements depend on your deployment:

Notes:

• If you use local AI models (Ollama, vLLM), you need a GPU (NVIDIA RTX 3060+ or better) or a very powerful CPU.
• If you use frontier models only (OpenAI, Anthropic), you can run Desk on a modest server (4 cores, 8 GB RAM).
• For high-volume deployments (1,000+ conversations/day), use Kubernetes with horizontal scaling.

Yes. Desk can run on any cloud provider:

• AWS: EC2, ECS, EKS (Kubernetes)
• Azure: VMs, Container Instances, AKS (Kubernetes)
• GCP: Compute Engine, Cloud Run, GKE (Kubernetes)
• Other: DigitalOcean, Linode, Hetzner, etc.

Running on a cloud server gives you:

• Scalability (add more resources as needed)
• High availability (multi-region deployment)
• Managed backups and snapshots

But remember: even on a cloud server, you control the data. It's still self-hosted — ODW.ai has no access.

Yes. Desk can run on an on-premise server in your office. This is ideal for:

• Businesses with strict data-residency requirements (data must stay on-premise)
• Businesses with existing server infrastructure
• Businesses that want full control over hardware and network

Requirements:

• A dedicated server (or VM) with Docker installed
• Static IP address or domain name (for WhatsApp webhooks)
• Internet connection (for WhatsApp API, license validation)
• IT staff to manage the server (updates, backups, security)

On-premise deployment gives you maximum control but requires more IT overhead than cloud deployment.

Yes, initially. Desk is designed for technical operators (DevOps-literate). You need someone who can:

• Deploy and configure Docker containers
• Manage a PostgreSQL database
• Configure WhatsApp API credentials
• Monitor server health and performance
• Perform updates and backups

Day-to-day operation is non-technical: admins configure the system via the web dashboard, agents use the agent inbox, and the AI handles conversations automatically.

If you don't have technical staff, you can:

• Hire a DevOps consultant for initial setup (1-2 days)
• Use a managed hosting provider (we can recommend partners)
• Wait for a managed SaaS offering (planned for v2, not yet available)

Updates are performed via Docker:

1. Pull the new Docker image: docker pull odwai/desk:latest
2. Restart the containers: docker-compose down && docker-compose up -d
3. Database migrations run automatically on startup.

Total update time: <5 minutes (plus downtime during restart).

For zero-downtime updates, use Kubernetes with rolling deployments.

Yes. Desk supports white-labeling:

• Custom branding: Replace the ODW.ai logo with your logo. Customize colors, fonts, and UI elements.
• Custom domain: Run Desk on your own domain (e.g., support.yourcompany.com).
• Custom email: Use your own email address for notifications and alerts.

White-labeling is ideal for:

• Agencies that want to resell Desk to their clients
• Large enterprises that want a unified brand experience
• SaaS companies that want to embed AI support in their product

White-labeling is available in the paid tier.

Not in v1.0. Desk is designed as a standalone support tool with deep Vault integration. CRM integrations (Salesforce, HubSpot), helpdesk integrations (Zendesk, Freshdesk), and other third-party connectors are out of scope for v1.0.

However, Desk provides a REST API that you can use to build custom integrations:

• Export conversation data to your CRM
• Import customer profiles from your database
• Trigger workflows in other systems (e.g., create a ticket when a conversation is escalated)

Pre-built integrations are planned for v1.2+ based on customer demand.

The setup wizard is a step-by-step guide that walks you through the initial configuration:

1. Welcome: Introduction to Desk and overview of the setup process.
2. WhatsApp connection: Connect WhatsApp Business API or Baileys Bridge. Test sending/receiving messages.
3. Vault connection: Connect to your Vault deployment. Test knowledge retrieval.
4. AI model configuration: Choose local models, frontier models, or hybrid routing. Test AI inference.
5. Brand persona: Configure your brand voice (tone, vocabulary, do's/don'ts). Preview how the AI sounds.
6. Response policies: Configure guardrails (competitor mentions, legal disclaimers, etc.).
7. Go live: Enable auto-response and start handling conversations.

The wizard validates each step before proceeding, so you know everything is working before going live.

Desk has a freemium model:

Additional costs:

• Server hosting: $20-$200/month depending on your infrastructure (cloud or on-premise).
• WhatsApp Business API: Meta charges per conversation (~$0.03-$0.08 per conversation, varies by country).
• Frontier AI models: If you use OpenAI/Anthropic, you pay per token (~$0.01-$0.03 per conversation).
• Local AI models: Free (but requires GPU hardware).

The free tier includes:

• Channels: Web chat widget + email (IMAP/SMTP). WhatsApp Baileys Bridge is also free.
• AI: Single AI persona, basic Vault integration, local model support.
• Agents: Single agent mode (one AI persona, no multi-agent routing).
• Features: Basic conversation management, agent inbox, admin dashboard.

The free tier is fully functional — it's not a trial or a limited demo. You can run a production support operation on the free tier.

What's not included: WhatsApp Business API (paid), multi-agent routing (paid), advanced compliance features (paid), SLA-backed support (paid).

The paid tier adds:

• WhatsApp Business API: Official Meta integration (requires Meta verification).
• Multi-agent routing: Different AI personas for different topics (e.g., Sales bot, Support bot).
• Advanced compliance: Audit exports, data-retention policies, GDPR/HIPAA tooling.
• SLA-backed support: Priority bug fixes, guaranteed response times, dedicated support channel.
• White-labeling: Custom branding, custom domain.

The paid tier is ideal for businesses that need enterprise features, official WhatsApp integration, or professional support.

Recommendation: Start with hybrid routing. Use local models for simple questions (FAQs, status checks) and frontier models for complex questions (troubleshooting, edge cases). This balances cost, privacy, and quality.

No hidden costs. The total cost of ownership includes:

• Desk license: Free or paid tier (see above).
• Server hosting: Your infrastructure cost (cloud or on-premise).
• WhatsApp API: Meta's per-conversation charges (if using Business API).
• Frontier AI models: Per-token charges from OpenAI/Anthropic (if using frontier models).

That's it. No setup fees, no per-user fees, no surprise charges.

The free tier is effectively a permanent free trial — no time limit, no credit card required. You can run the free tier indefinitely.

If you want to test the paid tier features (WhatsApp Business API, multi-agent routing, etc.), we offer a 14-day free trial of the paid tier. No credit card required. At the end of the trial, you can downgrade to the free tier or subscribe.

Contact us to start your free trial.

We accept:

• Credit/debit cards: Visa, Mastercard, American Express (via Stripe).
• Bank transfer: For annual subscriptions or large deployments.
• Cryptocurrency: Bitcoin, Ethereum, USDC (for privacy-conscious customers).

Invoicing is available for annual subscriptions. Contact us for details.

Yes. We offer a 30-day money-back guarantee for paid subscriptions. If you're not satisfied within the first 30 days, contact us for a full refund — no questions asked.

After 30 days, you can cancel anytime. You'll continue to have access until the end of your billing period, but no refund is provided for partial months.

Desk is designed to scale:

• Single-node (Docker Compose): ~1,000 concurrent conversations, ~10,000 messages/hour.
• Clustered (Kubernetes): 10,000+ concurrent conversations, ~100,000 messages/hour (horizontal scaling).

Performance depends on your infrastructure (CPU, RAM, database tuning) and AI model latency. For very high-volume deployments (100k+ conversations/day), we recommend Kubernetes with auto-scaling.

Yes. Desk can handle conversations in multiple languages simultaneously. The AI detects the customer's language and responds in the same language.

For best results:

• Add knowledge base documents in all supported languages.
• Configure the brand persona for each language (tone and vocabulary may differ).
• Use frontier models (GPT-4, Claude) for best multi-language quality.

Out of the box, Desk supports English and Chinese (Simplified + Traditional). Additional languages can be added by configuring the AI model and knowledge base.

Yes, in the paid tier. Multi-agent routing lets you configure different AI personas for different topics or channels:

• Sales bot: Optimistic, persuasive, focused on product benefits.
• Support bot: Empathetic, technical, focused on problem-solving.
• Billing bot: Formal, precise, focused on accuracy.

Each persona has its own brand voice, knowledge base collection, and response policies. Conversations are routed to the appropriate persona based on intent detection or channel.

The free tier supports a single AI persona only.

Desk provides built-in monitoring:

• Admin dashboard: Real-time metrics (conversations handled, AI resolution rate, average response time, escalation rate).
• Health checks: API endpoint (/health) for monitoring tools (Prometheus, Datadog, etc.).
• Logs: Structured logs (JSON format) for every significant event. Can be exported to SIEM systems.
• Metrics: Prometheus-compatible metrics endpoint (/metrics) for Grafana dashboards.

For Kubernetes deployments, we provide Grafana dashboards out of the box — pre-configured visualizations for all key metrics.

Desk stores all data in PostgreSQL and S3-compatible storage. Back up both:

• PostgreSQL: Use pg_dump for logical backups or filesystem snapshots for physical backups. Schedule daily backups to a separate location (e.g., S3, another server).
• S3 storage: Enable versioning and cross-region replication. Or use S3-compatible backup tools (rclone, restic).

Desk also provides backup and restore tooling:

• desk backup — creates a full backup (database + media files) as a single archive.
• desk restore — restores from a backup archive.

If Desk goes down:

• WhatsApp messages: Queued by WhatsApp and delivered when Desk comes back online (within the 24-hour window).
• Web chat messages: Lost (web chat doesn't queue messages). Consider displaying a "We're offline" message on your website.
• Email messages: Queued by the sender's email server and delivered when Desk comes back online.

High availability: For mission-critical deployments, use Kubernetes with multiple replicas. If one replica fails, traffic is automatically routed to healthy replicas.

Monitoring: Set up alerts (email, Slack, PagerDuty) to notify you immediately if Desk goes down.

Desk is designed to be intuitive, but we provide training resources:

• Documentation: Comprehensive user guides for admins and agents.
• Video tutorials: Step-by-step walkthroughs of key features.
• Onboarding session: For paid customers, we offer a 1-hour onboarding session (remote) to walk your team through the system.
• Support: Paid customers get priority support via email/chat.

Most teams are productive within 1-2 hours of training. The agent inbox is particularly intuitive — agents can start handling conversations immediately.

Yes. Desk is highly configurable:

• Brand persona: Configure tone, vocabulary, formality, do's/don'ts. Make Desk sound like your brand.
• Response policies: Configure guardrails (competitor mentions, legal disclaimers, restricted topics).
• Routing rules: Configure which conversations go to AI vs. human agents. Set confidence thresholds.
• SLA timers: Configure first-response and resolution time targets.
• PII detection: Add custom PII patterns (e.g., industry-specific identifiers).
• Knowledge base: Curate which documents the AI can access. Exclude sensitive files.

All configuration is done via the admin dashboard — no code changes required.

Yes. Desk includes a Brand Persona system that lets you configure:

• Tone: Friendly, professional, formal, casual, empathetic, etc.
• Vocabulary: Industry-specific terms, jargon, acronyms your team uses.
• Formality: How formal or casual the AI should be.
• Do's and don'ts: Specific phrases to use or avoid. (e.g., "Always say 'we' instead of 'I'", "Never use the word 'cheap' — say 'affordable' instead.")
• Few-shot examples: Provide example conversations that demonstrate your brand voice.

The brand persona is injected into every AI response, so Desk consistently represents your brand — whether it's a restaurant taking bookings or a law firm providing legal information.

Response policies are rules that control what the AI can and cannot say. Examples:

• Competitor mentions: If a customer asks about a competitor, the AI redirects: "I'm not the best person to compare us to [competitor], but I can tell you about our strengths..."
• Pricing questions: If a customer asks about pricing, the AI redirects to a human: "Pricing depends on your specific needs. Let me connect you with our sales team."
• Legal/medical disclaimers: If a customer asks for legal or medical advice, the AI adds a disclaimer: "I'm an AI assistant, not a lawyer/doctor. This information is for general guidance only. Please consult a professional for advice specific to your situation."
• Restricted topics: Certain topics are off-limits (e.g., politics, religion). If a customer brings up a restricted topic, the AI redirects or escalates.

Policies are enforced by the Policy Engine, which runs before and after AI generation. Every policy decision is logged in the audit trail.

Yes. Desk includes a Persona Preview/Test Tool that lets you:

• Simulate customer conversations in a sandbox environment.
• Test how the AI responds to specific questions.
• Preview the AI's tone and brand voice.
• Verify that response policies are working correctly.

You can iterate on the brand persona until it sounds right. Once you're satisfied, you can deploy it to production.

Yes, in v1.1 (paid tier). Desk supports loading LoRA/QLoRA adapters — fine-tuned model extensions that encode your brand voice at the model level (not just the prompt level).

How it works:

1. You train a LoRA adapter externally (using your own conversation data, brand guidelines, etc.).
2. You upload the adapter to Desk.
3. Desk loads the adapter and uses it for inference.

Fine-tuned models provide more consistent brand voice than prompt-based personas, especially for complex or nuanced brands.

The Policy Engine runs two checks:

1. Pre-generation hook: Before the AI generates a response, the Policy Engine checks if the customer's message triggers any policies (e.g., competitor mention). If a hard rule matches, a template response is sent immediately — the AI is skipped.
2. Post-generation hook: After the AI generates a response, the Policy Engine validates it against active policies. If it violates a rule (e.g., mentions a competitor), the response is:
   • Rewritten: The AI is asked to regenerate the response without the violation.
   • Blocked: A template response is sent instead.
   • Escalated: The conversation is escalated to a human agent.

Every policy decision is logged in the audit trail, so you can review what happened and why.

Not in v1.0. In v1.0, you configure a single brand persona per Desk deployment. All channels (WhatsApp, web chat, email) use the same persona.

Multi-persona support (different personas for different channels or topics) is planned for v1.1 (paid tier). This will allow you to:

• Use a casual persona on WhatsApp and a formal persona on email.
• Use a sales-focused persona for product inquiries and a support-focused persona for troubleshooting.
• Use different personas for different regions or languages.

Yes, in v1.1. Brand persona versioning lets you:

• Save multiple versions of your brand persona.
• Compare versions side-by-side.
• Rollback to a previous version if a change doesn't work out.

This is useful for:

• Testing new personas without risking your production setup.
• Reverting to a previous persona if a change causes issues.
• Auditing who changed what and when.

In v1.0, you can manually export/import persona configurations, but there's no built-in versioning.

Desk is powerful, but it has limitations in v1.0:

• No generative actions: Desk answers questions but doesn't execute transactions (create refunds, book appointments, modify orders). Planned for v1.2+.
• No visual flow builder: You can't drag-and-drop to design conversation flows. Desk is AI-first, not rules-first.
• Limited integrations: No pre-built CRM, helpdesk, or analytics integrations in v1.0. REST API is available for custom integrations.
• Single persona (free tier): Free tier supports one AI persona only. Multi-persona is in the paid tier.
• Limited channels: WhatsApp, web chat, and email only. Telegram, Discord, Slack, Signal, iMessage are planned for v1.1.
• No mobile admin app: Admin dashboard is web-only. No native mobile app.
• No multi-tenant SaaS: Desk is self-hosted only. We don't offer a managed cloud version (yet).

Telegram, Discord, Slack, Signal, and iMessage adapters are planned for v1.1 (Q4 2026). They will be optional modules you can enable as needed.

The channel adapter plugin system is already in place — adding new channels is a matter of implementing the adapter interface, not architectural changes.

If you need a specific channel urgently, contact us. We may be able to prioritize it based on customer demand.

Planned for v1.2+. Generative actions (executing transactions like creating refunds, booking appointments, modifying orders) are a major feature, but they require significant safety and approval workflows.

When implemented, generative actions will:

• Require explicit configuration and approval workflows.
• Log every action in the audit trail.
• Support rollback (undo) for critical actions.
• Be optional — you can disable generative actions entirely if you only want Q&A.

No specific release date yet. We're prioritizing stability and security for v1.0/v1.1 first.

Not in v1.0 or v1.1. Desk is self-hosted only. We believe self-hosting is the right choice for our target market (regulated businesses, data-residency-sensitive contexts).

A managed SaaS offering is being considered for v2+, but it's not committed. If there's enough demand, we may offer a hybrid model: self-hosted for sensitive data, managed for non-sensitive workloads.

If you need a managed solution today, we can recommend partner hosting providers who can manage Desk for you.

No. Desk is designed to avoid vendor lock-in:

• Data portability: Export all data (conversations, knowledge base, configuration) in standard formats (JSON, CSV). No proprietary formats.
• Model flexibility: Switch AI models anytime (local ↔ frontier, OpenAI ↔ Anthropic ↔ local). No lock-in to any AI provider.
• Self-hosted: You own the deployment. If you stop paying for the license, your data is still there, exportable, yours.
• Open standards: Desk uses open standards where possible (PostgreSQL, Redis, Docker, Kubernetes). No proprietary infrastructure.

You can leave Desk anytime. We'd rather earn your business than trap you.

Key milestones:

• v1.0 (Q3 2026): MVP launch. WhatsApp-first, Vault integration, model-agnostic AI, brand persona, response policies.
• v1.1 (Q4 2026): Multi-channel expansion (Telegram, Discord, Slack, Signal, iMessage), multi-persona support, LoRA adapter support, persona versioning.
• v1.2 (Q1 2027): Generative actions (execute transactions), pre-built integrations (CRM, helpdesk), advanced analytics.
• v2.0 (Q2 2027): Managed SaaS offering (maybe), visual flow builder (maybe), mobile admin app (maybe).

Roadmap is subject to change based on customer feedback and market demand. Contact us for the latest roadmap or to request features.

Desk is not the right fit if:

• You need 200+ integrations: Desk is focused on AI-first support with sovereignty, not a broad integration platform. If you need Salesforce, HubSpot, Zendesk, Slack, and 50 other tools connected out of the box, Desk is not for you (yet).
• You need a visual flow builder: Desk is AI-first, not rules-first. If you want to drag-and-drop to design conversation flows, use a tool like Landbot or Botpress.
• You need a general-purpose chatbot framework: Desk is for customer support, not marketing bots, lead-gen funnels, or internal tooling.
• You don't have technical staff: Desk requires DevOps-literate operators for deployment and maintenance. If you don't have technical staff, wait for a managed SaaS offering or use a partner hosting provider.
• You need SMS, Instagram, LINE, WeChat: These channels are out of scope for v1.0 and v1.1. They may be considered for v2 based on market demand.

Three paths:

1. Self-service (free tier): Download Desk, deploy it on your server, and start using it. No credit card required. Full documentation is available at docs.odw.ai/desk.
2. Guided setup (paid tier): Contact us for a 1-hour onboarding session. We'll walk you through deployment, configuration, and best practices.
3. Managed hosting (partner): If you don't have technical staff, we can recommend partner hosting providers who can deploy and manage Desk for you.

For all paths, we recommend starting with the WhatsApp Baileys Bridge (free, <30 minutes setup) to test Desk before committing to the official Business API.