What can you build with Botlit?
Real workflows grounded in the product — from the first bot app through versioned agents, knowledge bases, your own model providers, channel deployment, and the governance that makes it enterprise-ready.
Showing 25 use cases
Getting Started
From signup to your first bot app in minutes
Sign up, land in a workspace, and create your first bot app — the root object every other Botlit flow hangs off. Agents, knowledge bases, and channels all attach to it, inside a workspace that already has RBAC, audit, and billing in place.
Getting Started
Install a proven agent package from the store
Skip the blank page: install app and agent packages from the Botlit store across ten package kinds, either linked (tracking upstream updates) or forked (a copy you fully own) — and fork later if a linked install needs client-specific changes.
Getting Started
Build once, deliver many: a productized client-bot practice
Run "AI support bot in two weeks" as a repeatable service line: build one hardened Client Support Bot package, install it into a workspace per client, fork where a client needs bespoke behaviour, and watch per-client execution economics from one seat.
Build Agents
Agent versioning with publish, changelog, and rollback
Agents carry full version control: iterate in draft, publish a version with a changelog, and roll back when a "small prompt tweak" turns out to regress behaviour. App→agent routing links connect the front door to the specialists behind it.
Build Agents
Test agents in chat with a full execution record behind every reply
Chat with any agent directly in the platform. Each message resolves the agent’s model and provider credentials, calls the LLM, records an execution with token and cost metrics, and stores both sides of the exchange — so testing and auditing are the same act.
Build Agents
A governed registry for MCP servers and tools
Register Model Context Protocol servers in a workspace registry: track connection status, test connections, and discover and refresh the tools and resources each server exposes — so the tool surface is governed before agents start acting on it.
Build Agents
An A2A registry for multi-agent collaboration
Design multi-agent systems on the open Agent-to-Agent protocol: a registry of known agents with trust levels, explicit connections between them, and structured messages with priorities, acknowledgements, and delivery status.
Build Agents
API-first: embed Botlit agents inside your own product
Build your in-product AI assistant on Botlit’s control plane instead of a hand-rolled agent stack: machine credentials, the same API the UI uses, your own model providers, and per-execution cost records for runway math.
Build Agents
Orchestrate steps and agents with embedded visual workflows
Compose multi-step automations with the FluidGrids visual workflow builder embedded directly in Botlit — the same engine used across the Burdenoff platform — then run them and inspect each step, with credential adapters that can hand your LLM keys to agent steps.
Knowledge & RAG
Knowledge bases with per-KB vector collections and semantic search
Build managed RAG corpora: documents are chunked with the strategy you choose, embedded into a per-knowledge-base vector collection, and validated with semantic search — with reusable retrieval profiles capturing the recipe that works.
Models & Providers
Bring your own model: 11 provider types with vaulted keys
Register the LLM providers your organisation has sanctioned — OpenAI, Anthropic, Google, Cohere, Mistral, Groq, Together, HuggingFace, Azure OpenAI, AWS Bedrock, and custom OpenAI-compatible endpoints — with vaulted credentials, connection tests, and per-model parameters.
Channels
Deploy to Slack, Teams, Discord, and WhatsApp with webhook fan-in
Connect a workspace to the platforms your users already live in. Channel connectors bind the platform; routes map channels and threads to bot apps; inbound webhooks acknowledge instantly while the agent run happens in the background.
Channels
One shared team inbox for every agent conversation
Every conversation your agents have — test chats, Slack threads, webhook traffic — is stored centrally with both sides of every exchange, so humans can review, audit, and step in with full context instead of paging through per-platform histories.
Operations
Organize a growing agent estate with hierarchical buckets
Group bot apps and agents into hierarchical buckets so a workspace that started with one support bot stays navigable when it holds dozens — by team, by client, by environment, or by lifecycle stage.
Operations
Per-execution token, cost, and model audit
Every agent, app, and workflow run writes an execution record — status transitions, input and output, token counts, and cost — with per-agent statistics on top, so debugging and finance work from the same source of truth.
Operations
Know what every agent costs to run
Per-execution cost and token metrics roll up into per-agent and per-workspace economics — the numbers you need to price a client retainer, defend an internal budget, or decide which model a workload actually deserves.
Governance & Security
Codify guardrails: policies, skills, and prompt templates
Express governance as managed objects: policy definitions across seven types with tool-risk levels, reusable skills, and versionable prompt templates with variable rendering — reviewable, auditable, and shareable as store packages.
Governance & Security
Enforced RBAC and machine credentials for API access
Botlit inherits the Burdenoff platform’s identity-based security model: every query and mutation is gated by an RBAC rule enforced on every request, workspaces isolate tenants, and machine credentials give pipelines governed access.
AI Native
Answers grounded in your knowledge — or an honest "I don’t know"
When a RAG-enabled agent answers, Botlit embeds the question, searches every ready knowledge base linked to that agent, and injects the best passages into the prompt with an explicit instruction to admit ignorance rather than invent an answer.
AI Native
Agents with hands: MCP tool calls inside the conversation
Connect an MCP server, and a tool-enabled agent can call its tools mid-conversation: the runtime builds the tool list from the server’s live catalog, executes what the model asks for, feeds results back, and bounds the loop.
AI Native
The router that decides which specialist takes the message
A bot app with several specialist agents needs a decision on every inbound message. Botlit ships that decision as a runtime: single, round-robin, intelligent, and custom strategies, with keyword and pattern scoring first and a model classifier only as fallback.
AI Native
Agents that hand work to other agents — with a leash
Delegation in Botlit runs the target agent for real — its own model, its own tools, its own knowledge — and returns its answer to the caller, with a depth limit, cycle rejection and a message record for every exchange.
AI Native
Guardrails that stop the model, not guidelines that describe it
Policies are evaluated in the execution path: an active rate-limit, budget or content policy is checked before the model is called and again on its response, and a blocked answer is replaced with an explicit refusal.
AI Native
Every AI turn leaves a record you can audit and bill against
Botlit writes an execution record for every agent run — successful or not — with token counts, cost, duration and model, plus per-run metrics for tool calls and retrieved chunks, and meters the product units your plan prices.
AI Native
A copilot that drafts your agents and a supervisor that watches them
Designed and ticketed, not yet shipped: a copilot that turns one sentence into a reviewable draft bot graph and tunes agents from their own run history, plus a scheduled supervisor that surfaces fleet regressions as accept-or-dismiss decision cards.
Ready to start your own story?
Join the waitlist for early access — intelligent agents, deployed instantly.