hexabot.ai

Hexabot is a self-hostable AI workflow automation platform for teams that need to build agents and business automations while keeping production data under their own control. Its feature set covers the full path from trigger to action: workflows can start from chat, forms, schedules, or events; call models, tools, APIs, and back-office systems; and pause for human judgment when automation isn't enough. The features below are the ones to evaluate if you're deciding whether Hexabot fits your operational use case.

How workflows are triggered and what they can call

Hexabot workflows are not limited to conversational input. A workflow can be started by:

• A chat message
• A form submission
• A schedule
• An event

Once running, a workflow can call language models, tools, APIs, and back-office systems. This makes the platform suited to service operations where a conversation needs to produce a real action — a lookup, a ticket, a routed request — rather than just a reply.

How flows are modeled and validated

Hexabot supports two ways to define a flow:

Both are backed by typed contracts and schema validation, so the shape of inputs and outputs is defined rather than implied. For teams that treat workflows as code, the YAML option is the relevant one; for teams that need non-engineers to inspect a flow, the graph view matters more.

Reusable actions and capability bindings

Workflows are assembled from reusable actions, LLM calls, and capability bindings. Each has a clear contract for inputs, outputs, and settings. The practical effect is that an action built once — say, a call to an internal system — can be reused across workflows without redefining its interface each time. When evaluating the platform, check whether your existing systems can be expressed as actions with clean input/output contracts; that is where most integration effort goes.

Memory, RAG, and MCP integration

Hexabot gives workflows managed memory, retrieval-augmented context, and MCP integration points for sanctioned tools. In practice:

• Memory lets a workflow retain context across interactions rather than treating each turn as isolated.
• RAG supplies retrieved context to model calls, so answers can draw on your knowledge rather than only the model's training.
• MCP provides a defined integration point for tools you have approved, rather than ad hoc connections.

If your automation depends on remembering prior interactions or grounding responses in internal documents, these are the features to test first.

Human review and control flow

Automation rarely covers every case. Hexabot includes:

• Conditionals and loops for branching logic
• Segmentation for dividing audiences or cases
• Inbox workflows for queued human handling
• Live handoff when a conversation needs a person

This is the part to scrutinize if your use case involves complex or sensitive requests. The Orange success story on the site describes exactly this pattern: handling frequent requests automatically while routing complex cases and keeping the customer experience consistent across website and social channels.

Multichannel delivery and team operations

Hexabot runs multilingual assistants across web, messaging, social, and custom channels, with roles and analytics for team control. That means the same workflow runtime can serve different channels, and access can be governed by role rather than shared credentials.

Self-hosting and getting started

The platform is self-hosted, which is the basis for the data-control claim: you run the runtime and keep production data under your control. The documented local path is:

1. Install the CLI: npm install -g @hexabot-ai/cli
2. Create a project: hexabot create my-project
3. Enter the workspace: cd my-project
4. Run the local stack: hexabot dev

The starter template produces a working automation workspace where you can define workflows, connect channels, and extend the runtime with actions and tools.

Choosing based on your situation

Hexabot is a reasonable fit if you need self-hosted operation, workflows that both converse and act, and a mix of visual and version-controlled flow definitions. It is less obviously the right choice if you only need a simple chatbot without actions or memory, or if you cannot run and maintain your own stack.

Pricing is tiered — the site lists Starter, Pro, and Unlimited plans and describes starting free before upgrading as users, workflows, and license activations become production signals. Check the pricing page for current terms rather than assuming any tier's limits.

Hexabot offers three paid plans — Starter, Pro, and Unlimited — and you can start free before upgrading. The right tier depends on your operational usage: how many users you bring on, how many workflows you run, and how many license activations you need in production. Hexabot's own pricing page frames the decision this way rather than around fixed feature lists, so the practical approach is to begin on the free tier, watch those three signals grow, and upgrade when one of them becomes a constraint.

The Plans at a Glance

The site lists Starter, Pro, and Unlimited as the paid tiers and provides a "Buy" checkout link for each. It does not publish per-plan prices, user caps, or workflow limits in the page content available, so confirm exact numbers on the pricing page before committing.

How to Decide

1. Start free and measure real usage

Hexabot's guidance is explicit: start free, then upgrade as users, workflows, and license activations become production signals. Don't guess your tier from a feature checklist — build your first workflow, connect a channel, and see what your actual footprint looks like.

2. Identify your binding constraint

Ask which of the three signals will hit a limit first:

• Users — if your team or client base is growing, you'll likely move up on seats.
• Workflows — if you're automating many separate processes (support triage, lead routing, internal ops), workflow count becomes the driver.
• License activations — if you're deploying across multiple environments or instances, activations matter most.

Whichever runs out first tells you which tier to buy.

3. Match the tier to the stage, not the feature list

• Starter fits a first production deployment: a small set of workflows serving real users.
• Pro fits an expanding operation where both workflow count and team size are climbing.
• Unlimited fits deployments where you'd otherwise keep bumping ceilings — multi-channel, multi-team, or multi-instance setups.

Where to View Pricing and Buy

• Pricing overview: https://hexabot.ai/pricing
• Purchase links are provided per tier on the site: "Buy Starter," "Buy Pro," and "Buy Unlimited," each leading to a license checkout.

Because Hexabot is self-hostable, your plan governs licensing and usage rather than hosting — you run the runtime yourself, which is why activations are a meaningful signal.

A Practical Path

1. Install the CLI and scaffold a project: npm install -g @hexabot-ai/cli, then hexabot create my-project, cd my-project, hexabot dev.
2. Build one customer-facing workflow and connect a channel.
3. Track users, workflows, and activations as you add real traffic.
4. When one signal nears its limit, check the pricing page and buy the next tier up.

This keeps you on the cheapest plan that actually fits, and avoids paying for capacity you haven't reached yet.

Common Pitfalls

• Buying before measuring. The free start exists precisely so you can size your usage first.
• Assuming features differ by tier. The site steers plan choice by operational usage, not feature gating — verify any specific capability you depend on before upgrading.
• Ignoring activations. For self-hosted deployments across environments, activation count can be the real ceiling, not users or workflows.

For the underlying platform capabilities — graph/YAML workflows, memory and RAG, MCP tools, human handoff, and multichannel delivery — see the features page; those apply across the runtime regardless of which plan you land on.

Install the official Hexabot CLI, scaffold a project from the starter template, then run the local stack — four commands get you from nothing to a running self-hosted workspace. You need Node.js with npm available on your machine, since the CLI is distributed as an npm package. The result is a complete automation workspace where you can define workflows, connect channels, and extend the runtime with actions and tools.

Prerequisites

• Node.js and npm installed and on your PATH (the CLI is installed globally via npm).
• A terminal in the directory where you want the project created.
• No cloud account is required for the local steps below — the starter template sets up a self-hostable project on your own machine.

Step-by-Step Setup

1. Install the Hexabot CLI

npm install -g @hexabot-ai/cli

This installs the hexabot command globally. Expected result: running hexabot in a terminal shows the CLI's available commands.

2. Create a project from the starter template

hexabot create my-project

Replace my-project with your preferred name. The starter template generates a complete automation workspace rather than an empty skeleton — it includes the structure for defining workflows, connecting channels, and extending the runtime with actions and tools.

3. Move into the project workspace

cd my-project

4. Run the local Hexabot stack

hexabot dev

This starts the local development stack. Expected result: the stack comes up locally and you can begin building and testing workflows against it.

What the Starter Template Gives You

The scaffolded project is the foundation for everything Hexabot does at runtime:

Because flows can be expressed as YAML with typed contracts and schema validation, the project works well with version control — you can review and diff workflow changes like any other code.

Verifying It Works

After hexabot dev starts, confirm the stack is running locally before investing time in workflow design. Then build a minimal flow — for example, a chat-triggered workflow that calls a model or an API — and test it in the local environment. If the stack starts but a workflow fails, the problem is in the flow definition or a binding contract, not the installation.

Common Sticking Points

• hexabot command not found after install: the global npm bin directory isn't on your PATH. Check your npm prefix and shell configuration.
• Wrong directory: hexabot create must run where you want the project folder to appear; cd into the new folder before hexabot dev.
• Port conflicts on the local stack: if another service occupies a required port, the stack may fail to start — stop the conflicting service or adjust the configuration.
• Skipping the starter template: starting from an empty project means you lose the pre-wired structure for workflows, channels, and actions that the template provides.

When to Move Beyond Local

The local stack is for building and testing. When you're ready for production, Hexabot is designed to be self-hosted so your production data stays under your control. Pricing is tiered by operational usage — the site lists Starter, Pro, and Unlimited plans and notes that you start free and upgrade as users, workflows, and license activations become production signals. Check the pricing page for current terms before committing to a plan.

Hexabot is a self-hostable AI workflow automation platform for building AI agents and agentic workflows that can talk, act, and remember across channels. You use it when you want conversational automation connected to real actions and back-office systems, while keeping production data under your own control. It fits teams that need multichannel service delivery with human review points, and that are prepared to run and extend the runtime themselves.

What Hexabot actually does

Hexabot combines several capabilities in one runtime:

• Conversations that do work. Workflows can be triggered from chat, forms, schedules, or events, then call models, tools, APIs, and back-office systems.
• Graph and YAML control. You can model flows visually or as portable YAML with typed contracts, schema validation, and version control.
• Actions and bindings. Reusable actions, LLM calls, capability bindings, and external systems connect through clear input, output, and settings contracts.
• Memory, RAG, and MCP. Workflows get managed memory, retrieval-augmented context, and MCP integration points for sanctioned tools.
• Human review points. Conditionals, loops, segmentation, inbox workflows, and live handoff cover cases where automation needs human judgment.
• Service operations. Multilingual assistants run across web, messaging, social, and custom channels, with roles, analytics, and team control.

Who it is for

Hexabot suits teams building customer-facing or internal automation where the conversation must lead to an action — routing a request, calling a system, or handing off to a person. The published Orange success story describes multilingual service automation across website and social channels, handling frequent requests, routing complex cases, and keeping the customer experience consistent. That pattern — high-volume routine requests plus escalation — is a reasonable signal of the intended use.

It is less suitable if you want a fully managed SaaS with no operational involvement, since self-hosting is the core premise.

How you start

The documented path is a CLI-based local setup:

1. Install the official CLI: npm install -g @hexabot-ai/cli
2. Create a project from the starter template: hexabot create my-project
3. Move into the workspace: cd my-project
4. Run the local stack: hexabot dev

The starter template produces a complete automation workspace where you define workflows, connect channels, and extend the runtime with actions and tools. Expect to need a local environment capable of running the stack; the documentation is the place to confirm prerequisites before installing.

Pricing and licensing

The site presents plans named Starter, Pro, and Unlimited, each with a purchase link, and states you can start free and upgrade as users, workflows, and license activations become production signals. Specific prices, limits, and what each tier includes are not stated in the available material, so check the pricing page directly before committing.

Decision guide

The practical next step is to scaffold the local project, build one narrow workflow end to end, and confirm the channel and tool integrations you need before evaluating plans.

Hexabot keeps AI workflow data under your control because the workflow runtime runs in your own environment rather than on a vendor-hosted service. You self-host the platform, so the conversations, memory, knowledge, and tool calls that your agents process stay inside infrastructure you operate. This fits teams that need to connect chat and messaging channels to internal systems but cannot send production data to a third-party runtime. The trade-off is that you take on deployment, upgrades, and operational responsibility yourself.

What "self-hosted" means for your data

The core idea is that Hexabot is a runtime you install and run, not a SaaS dashboard you log into. The site describes it as a "Self-Hosted AI Workflow Automation Platform" and states that you can "self-host Hexabot, connect every channel, orchestrate tools and actions, use memory and knowledge, and keep your production data under your control."

In practice, that means:

• Workflow execution happens in your environment. The agents, flows, and tool calls run on infrastructure you provision.
• Memory and knowledge stay with the runtime. Managed memory and retrieval-augmented context are part of the runtime you host, not a separate vendor store.
• Channel connections are yours to configure. Web, messaging, social, and custom channels connect to your instance.
• You control the surrounding systems. Actions and bindings call your APIs and back-office systems directly.

The site's framing is "Own Your AI Workflow Runtime," which is the clearest statement of the model: control comes from operating the runtime, not from a data-processing agreement.

Where the data actually lives

A useful way to check whether self-hosting meets your requirements is to map each data type to where it resides:

The site does not publish a detailed data-residency or storage-architecture document in the material available, so confirm specifics like database backends and retention settings against the documentation before committing to a compliance-sensitive deployment.

The mechanisms that support control

Self-hosting alone is not the whole story. Several features are designed to keep automation governed and auditable:

Memory, RAG, and MCP inside the runtime

Hexabot gives workflows "managed memory, retrieval-augmented context, and MCP integration points for sanctioned tools." Because these run inside your instance, the context your agents retrieve and the tools they are allowed to call are defined by your configuration rather than a vendor's defaults. MCP integration points are described as "sanctioned," which suggests an allow-list style of control over which tools workflows can reach.

Human review and handoff

Conditionals, loops, segmentation, inbox workflows, and live handoff let you insert human judgment where automation should not act alone. For data-sensitive operations, this is a control point: a workflow can pause and route to a person before taking an action on production systems.

Roles and team oversight

The platform includes "roles, analytics, and team control" for service operations. That supports operational governance — who can build, edit, and monitor workflows — though the site does not detail the permission model, so verify role granularity in the docs.

Version-controlled workflow definitions

Flows can be modeled visually or as "portable YAML with typed contracts, schema validation, and project-friendly version control." Keeping workflow logic in YAML in your own repository means changes are reviewable and traceable, which matters when workflows touch regulated or sensitive data.

A concrete example

Consider a customer-service team that wants an AI assistant on its website and social channels but must keep customer conversations and internal order data inside its own network.

1. The team scaffolds a project with the Hexabot CLI and runs the local stack.
2. They connect web and messaging channels to their instance.
3. They build a workflow that answers frequent questions using RAG over their own knowledge base, and calls an internal order-status API through an action binding.
4. They add a conditional so complex or sensitive cases route to a human inbox.
5. Because the runtime, memory, and API calls all sit in their environment, customer messages and order data never leave infrastructure they control.

The site cites Orange as a success story running "multilingual service automation across website and social channels," handling frequent requests and routing complex cases — a pattern that matches this kind of setup.

What self-hosting does not guarantee

Control over the runtime is not the same as control over every model call. If your workflows call external LLM providers, the prompts and context sent to those models leave your environment. The site does not specify which model providers are supported or whether fully local models are an option, so treat model-call data flow as a separate decision you must verify. Similarly, self-hosting shifts patching, backup, and uptime responsibility to your team.

How to decide

Self-hosting Hexabot is a good fit if:

• You need conversations, memory, and tool calls to stay in infrastructure you operate.
• You want workflow logic version-controlled in your own repository.
• You can staff deployment, upgrades, and monitoring.

It is a weaker fit if you want a fully managed service, or if your compliance requirements extend to model inference and you cannot confirm a local-model path. To evaluate, start with the local stack using the CLI, then test one workflow that touches your most sensitive data and trace where that data flows before scaling to production channels.