You do not just need an LLM.

You need a runtime.

You need workflows. You need actions. You need memory. You need channels. You need a way to connect tools, APIs, business logic, and human intervention without letting the LLM improvise everything at runtime.

That is exactly where Hexabot comes in.

Hexabot v3 is an AI automation platform designed for developers who want to build and run agentic workflows across channels using actions, YAML workflows, memory, tools, MCP, and RAG. In this guide, we will set up a fresh Hexabot project, run it locally, understand the generated project structure, and see how to prepare it for AI-assisted development with coding agents such as Claude Code, OpenAI Codex, Cursor, or similar tools.

By the end, you will have a running Hexabot workspace ready for your first workflow automation.

What We Are Going to Build

We will create a new Hexabot project using the official CLI.

The goal is simple:

hexabot create support-automation
cd support-automation
hexabot dev

That gives us a local Hexabot development environment where we can start designing workflows, adding actions, testing automations, and eventually connecting channels, tools, and MCP servers.

For this tutorial, let’s imagine we are preparing a support automation project that can eventually:

• classify incoming support requests,

• extract urgency and customer information,

• create tickets,

• escalate high-priority cases,

• and keep humans in control when needed.

But first, we need the project running.

Prerequisites

Before creating a Hexabot project, make sure you have the following installed:

node -v

Hexabot v3 requires Node.js 20.19.0 or newer.

You also need one JavaScript package manager. Hexabot works with:

npm
pnpm
yarn
bun

For local development, Docker is optional. You can start with the default local setup first, then switch to Docker when you need Docker-based services such as Postgres or other infrastructure components.

A good minimum setup is:

Node.js >= 20.19.0
npm or pnpm
Git
Docker Desktop or Docker Engine, optional

If you are using Docker on Windows, make sure Docker Desktop is configured with WSL 2 support enabled.

Step 1: Install the Hexabot CLI

The Hexabot CLI is the main entry point for creating and managing Hexabot projects.

Install it globally:

npm install -g @hexabot-ai/cli

After installation, check that the command is available:

hexabot --help

You can also use the CLI without installing it globally:

npx @hexabot-ai/cli --help

The global installation is convenient if you expect to create and manage several Hexabot projects.

Step 2: Create a New Hexabot Project

Now create a new project:

hexabot create support-automation

This command scaffolds a new Hexabot automation workspace from the official starter template.

Then enter the project folder:

cd support-automation

During project creation, the CLI will prepare the workspace, install dependencies, bootstrap environment files, and ask for initial admin credentials.

These credentials are used to access your local Hexabot admin interface, so choose something you can remember for development.

Step 3: Run Hexabot Locally

Once the project is created, start the development server:

hexabot dev

This is the simplest local development mode. It is the recommended starting point when you want to explore Hexabot without introducing Docker complexity too early.

By default, the local endpoints are:

Admin UI: http://localhost:3000
API:      http://localhost:3000/api
API docs: http://localhost:3000/docs

Open the Admin UI in your browser:

http://localhost:3000

Log in using the admin credentials you created during setup.

At this point, your Hexabot project is running.

Step 4: Run Hexabot with Docker and Postgres

Local development is great for getting started, but many real-world automations eventually need Docker-based services.

For example, you may want to run Hexabot with Postgres:

hexabot dev --docker --services postgres

This tells the CLI to run the project using Docker Compose and enable the Postgres service overlay.

The CLI handles the Compose configuration for you. It can stitch together the base Docker Compose file with service-specific overlays such as Postgres, API, frontend, or other configured services.

For day-to-day development, you can start simple with:

hexabot dev

Then move to Docker when your project needs a production-like environment:

hexabot dev --docker --services postgres

Step 5: Check Your Environment

Hexabot includes a useful diagnostic command:

hexabot check

This verifies your local environment, project structure, Node.js version, environment files, and optionally Docker readiness.

If you only want to check Docker-related requirements, run:

hexabot check --docker-only

This is especially useful when onboarding a new developer, preparing a demo, or debugging an environment issue before assuming the problem is inside the application.

Step 6: Understand the Important CLI Commands

Once your project is created, these are the commands you will use most often.

Create a project

hexabot create my-project

Creates a new Hexabot project from the starter template.

You can force a package manager:

hexabot create my-project --pm npm

You can also skip dependency installation:

hexabot create my-project --no-install

Run in development mode

hexabot dev

Runs your project locally.

With Docker:

hexabot dev --docker --services postgres

Start in production mode

hexabot start

Or with Docker:

hexabot start --docker --services api,postgres --build

Manage environment files

hexabot env init
hexabot env init --docker
hexabot env list

Use these commands to initialize or inspect local and Docker environment files.

Manage Docker services

hexabot docker up
hexabot docker down
hexabot docker logs
hexabot docker ps

These commands are convenience wrappers around Docker Compose.

Run diagnostics

hexabot check

This is your first stop when something does not start correctly.

Step 7: What Makes a Hexabot Project Different?

A Hexabot project is not just another chatbot app.

The core idea is to separate workflow logic, actions, channels, memory, and integrations in a way that gives developers more control over how AI automation behaves.

Instead of asking an LLM to reason through every step every time, Hexabot lets you define deterministic business logic as actions and orchestrate those actions through workflows.

That matters because production AI automation needs more than creativity. It needs structure.

A support workflow, for example, may include:

flow:
  - do: classify_issue

  - conditional:
      when:
        - condition: "=$output.classify_issue.urgency = 'high'"
          steps:
            - do: escalate_to_human
      else:
        steps:
          - do: create_ticket
          - do: send_confirmation

In this kind of workflow, the LLM can help classify, summarize, or extract information, but your business rules remain explicit.

That is the difference between “the AI decided something” and “the workflow executed a controlled automation.”

Step 8: Prepare Your Project for AI Coding Agents

One of the most exciting parts of Hexabot v3 is that it can fit naturally into modern AI-assisted development workflows.

If you use tools like Claude Code, OpenAI Codex, Cursor, or similar coding agents, you can use them to help create actions, write workflows, and interact with your Hexabot project.

The recommended setup is to install the Hexabot skills:

npx skills add hexabot-ai/action-creator
npx skills add hexabot-ai/workflow-writer

These skills help your AI coding agent understand how to generate Hexabot-compatible actions and workflows.

For example, instead of asking your coding agent:

Create some code that calls HubSpot.

You can be more specific:

Use the Hexabot action creator skill to create an action called create_hubspot_lead.

The action should accept:
- email
- firstName
- lastName
- company
- message

It should call the HubSpot API and return:
- leadId
- status

Or for workflows:

Use the Hexabot workflow writer skill to create a support triage workflow.

The workflow should:
1. classify the user message,
2. detect urgency,
3. create a ticket,
4. escalate to a human if urgency is high,
5. send a confirmation message otherwise.

This gives your AI coding agent better context, better constraints, and a better chance of producing code that matches Hexabot conventions.

Step 9: Enable MCP for Deeper Agent Integration

Hexabot also includes MCP support, which allows compatible AI coding agents to interact with Hexabot through the Model Context Protocol.

In practical terms, this means an AI coding agent can inspect and manage parts of your Hexabot project through a structured interface instead of relying only on static files.

Hexabot’s MCP server can expose capabilities such as:

• workflows,

• workflow runs,

• actions,

• memory definitions,

• credentials metadata,

• MCP servers,

• CMS content,

• and RAG content.

To enable the MCP server, configure the MCP environment variables in your API environment file:

MCP_ENABLED=true
MCP_SERVER_NAME=hexabot-api
MCP_SERVER_TITLE=Hexabot API MCP Server
MCP_SERVER_VERSION=1.0.0

Then restart the API.

The local MCP endpoint is:

http://localhost:3000/api/mcp

A typical MCP client configuration looks conceptually like this:

{
  "mcpServers": {
    "hexabot": {
      "type": "http",
      "url": "http://localhost:3000/api/mcp",
      "headers": {
        "Authorization": "Bearer hbt_mcp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}

The bearer token should be created from your Hexabot account and used by your MCP-compatible client.

Once connected, an AI coding agent can work with Hexabot in a much more structured way. It can inspect existing workflows, validate YAML, check actions, review workflow runs, and help you iterate faster.

Step 10: Recommended Developer Workflow

A clean Hexabot development workflow looks like this:

npm install -g @hexabot-ai/cli

hexabot create support-automation
cd support-automation

hexabot check
hexabot dev

Then, when you need Docker:

hexabot dev --docker --services postgres

When you need to inspect the environment:

hexabot env list

When you want AI-assisted workflow development:

npx skills add hexabot-ai/action-creator
npx skills add hexabot-ai/workflow-writer

And when you want deeper integration with coding agents:

MCP_ENABLED=true
MCP_SERVER_NAME=hexabot-api
MCP_SERVER_TITLE=Hexabot API MCP Server
MCP_SERVER_VERSION=1.0.0

This gives you a strong foundation for building production-ready AI automation.

Common Troubleshooting Tips

The hexabot command is not found

Make sure the CLI is installed globally:

npm install -g @hexabot-ai/cli

Or use the npx version:

npx @hexabot-ai/cli --help

The project does not start

Run:

hexabot check

This will help you identify missing environment files, unsupported Node.js versions, or Docker issues.

Docker services fail to start

Check Docker status:

docker ps

Then inspect Hexabot services:

hexabot docker ps
hexabot docker logs

If needed, restart with:

hexabot docker down
hexabot dev --docker --services postgres

Environment variables are missing

Initialize local env files:

hexabot env init

For Docker:

hexabot env init --docker

Then verify:

hexabot env list

Why This Setup Matters

The best AI automation systems are not built by throwing every decision at an LLM.

They are built by combining:

• predictable workflow logic,

• typed actions,

• business rules,

• human escalation,

• memory,

• retrieval,

• and AI reasoning where it actually adds value.

Hexabot gives developers a structured way to build exactly that.

You can start small with a local project, define your first workflow, add custom actions, connect channels, expose tools through MCP, and gradually move toward production.

The setup is simple:

npm install -g @hexabot-ai/cli
hexabot create support-automation
cd support-automation
hexabot dev

But what you get is much more than a starter app.

You get a foundation for building AI automation systems that are controlled, extensible, and ready for real business workflows.

Final Thoughts

If you are a developer, startup founder, CTO, or AI automation builder, Hexabot is worth exploring because it gives you a practical middle ground between rigid no-code automation and fully improvised agentic systems.

You keep the flexibility of AI.

You keep the control of software engineering.

And you get a framework where workflows, actions, memory, MCP, and channels are designed to work together from the beginning.

Start with a new project, run it locally, and build your first workflow.

That is where the real fun begins.

This release is more than a technical upgrade. It represents a significant product repositioning: Hexabot is evolving from a classic conversational AI builder into a self-hosted AI workflow automation platform designed for developers, automation builders, agencies, and teams who want more control over how AI is used in real business workflows.

Hexabot started with a clear mission: help teams build powerful conversational experiences across channels. With v3, we are expanding that mission.

The future of automation is not only about chatbots. It is about connecting conversations, business logic, tools, memory, AI reasoning, human review, and scheduled processes into reliable workflows.

That is exactly what Hexabot v3 is built for.

Why Hexabot v3?

AI automation is moving fast.

Many teams are experimenting with AI agents, workflow builders, LLM-powered assistants, and tool-calling systems. But as these systems become more powerful, they also create new challenges:

• How do you keep automation reliable?

• How do you avoid making the LLM reason through every deterministic step?

• How do you combine AI decisions with structured business logic?

• How do you connect conversations to real actions?

• How do you maintain control over costs, data, deployment, and extensibility?

Hexabot v3 was designed around these questions.

Instead of treating AI automation as a black box, Hexabot gives developers a structured way to design, run, extend, and control agentic workflows.

The goal is simple: combine the flexibility of AI with the reliability of software engineering.

From Conversational Flows to Agentic Workflows

In previous versions, Hexabot was mainly understood as a chatbot builder.

The core concepts were familiar to anyone building conversational automation: flows, blocks, conversations, plugins, and channels.

That model worked well for chatbot-first use cases. But modern AI automation needs a broader foundation.

With Hexabot v3, the center of gravity has changed.

Hexabot is now organized around:

• Workflows: structured automation definitions that describe what should happen.

• Actions: reusable execution units that perform real operations.

• Bindings: reusable configuration and capability definitions.

• Memory: explicit memory definitions for AI-powered workflows.

• Channels: communication interfaces that connect workflows to users.

• MCP integration: support for Model Context Protocol interoperability.

In other words, conversation is no longer the whole product.

Conversation is now one possible mode of automation.

A workflow can be conversational, manual, scheduled, or triggered by other automation patterns. This makes Hexabot much more flexible for real-world use cases such as customer support triage, lead qualification, CRM updates, internal operations, reporting, and AI-assisted business processes.

YAML Workflows: A More Developer-Friendly Foundation

One of the biggest changes in Hexabot v3 is the introduction of YAML-based workflow definitions.

This gives developers a clearer and more portable way to define automation logic.

Instead of relying only on a visual builder, teams can now express workflows as structured definitions. This makes automation easier to review, version, document, and maintain.

For developer teams, this matters a lot.

Workflows can now become part of the engineering lifecycle. They can be reviewed in pull requests, stored in repositories, tested, reused, and evolved over time.

This also makes Hexabot more aligned with how modern software teams already work.

Actions: Extensibility That Feels Like Software Engineering

In Hexabot v3, actions become a central extension mechanism.

An action is a reusable unit of work. It can call an API, transform data, create a ticket, send a notification, update a CRM, fetch information, or execute any business operation your workflow needs.

This is important because not every step should be handled by an LLM.

Many workflow steps are deterministic. For example:

• Creating a HubSpot lead

• Sending a Slack notification

• Searching a product catalog

• Updating a support ticket

• Checking an order status

• Scheduling a meeting

• Fetching data from an internal API

These steps should be implemented as reliable actions, not repeatedly reasoned through by a language model.

This is one of the core ideas behind Hexabot v3: use AI where AI adds value, and use structured actions where reliability matters.

That balance helps teams build automation systems that are more predictable, more maintainable, and easier to control at scale.

Memory and Context for Smarter Automation

AI workflows often need context.

They may need to remember user preferences, conversation history, previous decisions, customer status, or domain-specific information.

Hexabot v3 introduces memory as a more explicit domain concept. This makes it easier to design workflows that can use memory intentionally instead of treating it as an invisible side effect of the conversation.

For AI automation builders, this opens the door to more advanced use cases:

• Personalized customer interactions

• Context-aware support workflows

• Long-running automation processes

• AI assistants that can reason with structured memory

• Workflows that combine user input, previous interactions, and external data

Memory is becoming a key part of agentic systems. Hexabot v3 gives it a dedicated place in the architecture.

MCP Support: Toward Better Tool and Context Interoperability

Hexabot v3 also introduces integration points for the Model Context Protocol, also known as MCP.

MCP is becoming an important standard for connecting AI systems to tools, context, and external capabilities.

By supporting MCP, Hexabot moves closer to a future where AI workflows can interact with a broader ecosystem of tools and services in a more standardized way.

For developers, this means Hexabot can become part of a larger AI automation stack instead of being isolated from it.

A Modernized Developer Experience

Hexabot v3 also brings major changes under the hood.

The project now uses a PNPM workspace monorepo orchestrated with Turborepo. Core packages are organized more clearly, including packages for the API, frontend, widget, graph, agentic runtime, and CLI.

The frontend has moved to a more focused React SPA architecture powered by Vite and React Router.

The backend data layer has also been modernized around TypeORM, with SQLite and Postgres as first-class database options.

This is a major improvement for teams that want to run Hexabot locally, deploy it in production, customize it, or contribute to the platform.

Hexabot v3 also makes broader use of Zod for schema-driven validation and configuration. This helps make extensions, actions, settings, and workflow contracts more explicit and safer to work with.

The result is a cleaner, more modular, more developer-friendly platform.

Channels Still Matter

Even though Hexabot v3 is moving beyond a chatbot-first model, channels remain an important part of the platform.

Businesses still need to meet users where they are.

That could mean a website widget, WhatsApp, Messenger, Telegram, or other communication channels.

The difference is that channels are no longer the whole story. They are now entry points into broader workflows.

A user message can trigger an AI workflow. A workflow can call actions. Actions can connect to external systems. The result can return to the user, notify a human, update a CRM, or continue asynchronously.

This makes Hexabot useful not only for chatbots, but also for end-to-end automation.

What This Means for Existing Hexabot Users

Hexabot v3 is a conceptual shift.

If you used Hexabot v2, you may be familiar with the flow, block, and plugin model. In v3, those ideas evolve into workflows, steps, actions, bindings, and memory.

That means some mental models will change.

But the direction is clear: Hexabot is becoming more powerful, more flexible, and better suited for modern AI automation use cases.

The goal is not to abandon conversational AI. The goal is to place conversational AI inside a broader automation framework.

This gives builders more freedom.

You can still build chat-based experiences. But now, you can also build workflows that combine conversation, AI reasoning, business logic, external APIs, memory, and human control.

Who Is Hexabot v3 For?

Hexabot v3 is especially useful for:

• Developers building AI automation systems

• Agencies creating workflow solutions for clients

• Startups integrating AI into customer operations

• Teams that want self-hosted AI automation

• Builders who need more control than no-code agent tools provide

• Companies that want to combine LLMs with deterministic business logic

• Technical teams looking for an extensible alternative to closed automation platforms

If you want a platform where AI workflows can be customized, extended, deployed, and controlled, Hexabot v3 is designed for you.

The Bigger Vision

We believe the next generation of AI automation will not be built only with prompts.

It will be built with structured workflows, typed actions, reusable components, memory, channels, and strong developer tooling.

LLMs are powerful, but they should not carry the entire burden of your automation system.

A good AI workflow platform should let you decide what should be handled by AI, what should be handled by code, what should be reviewed by humans, and what should be automated safely.

That is the vision behind Hexabot v3.

A platform where developers can build AI automation that is powerful, reliable, extensible, and self-hosted.

What’s Next?

The launch of Hexabot v3 is an important milestone, but it is also the beginning of a new phase.

We will continue improving the workflow engine, developer experience, documentation, examples, integrations, and extension ecosystem.

We are especially excited to see what the community builds with actions, workflows, channels, memory, and MCP support.

If you are building AI workflows, customer support automation, internal assistants, lead qualification systems, or AI-powered business processes, now is a great time to explore Hexabot v3.

Get Started with Hexabot v3

Hexabot v3 is here, and we invite developers, AI builders, automation experts, and agencies to try it, test it, challenge it, and build with it.

Explore the project, read the documentation, and join the community.

The future of Hexabot is no longer just about building chatbots.

It is about building reliable AI automation workflows.

And this is just the beginning.