AI-powered data discovery platform. Connect your data warehouse, run AI agents that explore your data autonomously, and get actionable insights — no pipelines, no SDKs, no setup complexity.

DecisionBox is designed for product managers, analysts, and developers who want to understand their data without writing SQL or building dashboards. Point it at your warehouse, tell it about your product, and let the AI find what matters.

How It Works

Your Data Warehouse             DecisionBox Agent            Dashboard
(BigQuery, Redshift,      →    (AI explores your data)  →   (Insights & Recommendations)
 Snowflake, PostgreSQL,
 Databricks)
                                 writes SQL, validates
                                 findings, generates
                                 actionable advice

1. Connect your data warehouse (BigQuery, Redshift, Snowflake, PostgreSQL, Databricks, and more)
2. Configure your project (domain, game profile, LLM provider)
3. Run discovery — the AI agent autonomously explores your data
4. Review insights — severity-ranked findings with confidence scores
5. Act on recommendations — specific, numbered action steps

Features

• Autonomous data exploration — AI writes and executes SQL queries, iterates based on results
• Domain-aware analysis — Pluggable domain packs (gaming, social network, ecommerce shipped — bring your own)
• Multiple LLM providers — Claude, OpenAI, Ollama, Vertex AI, Bedrock, Azure AI Foundry
• Multiple warehouses — BigQuery, Amazon Redshift (serverless + provisioned), Snowflake, PostgreSQL, Databricks
• Per-project secrets — API keys encrypted per-project (MongoDB, GCP Secret Manager, AWS Secrets Manager, Azure Key Vault)
• Insight validation — AI claims are verified against your actual data
• Feedback loop — Like/dislike insights, agent learns from feedback on next run
• Reader UX — Bookmark insights and recommendations into named lists, read-state tracking with greyed-out rows, collapsible "technical details" for non-technical users, sticky sidebar of related items on detail pages
• Cost estimation — Estimate LLM + warehouse costs before running
• Live progress — Watch the agent explore in real-time with step-by-step updates
• Editable prompts — Customize all AI prompts per-project from the dashboard
• Extensible — Add your own domain packs, LLM providers, warehouse providers via plugin architecture

Use Cases

DecisionBox works with any queryable data. Point it at your data source and it discovers insights specific to your domain.

Gaming — "Players who fail level 12 more than 3 times have 68% higher Day-7 churn. Consider adding a hint system or difficulty adjustment at this stage."

Social Network — "Posts published between 6–8 PM with images get 3.2x more shares, but only 12% of creators post during this window. A scheduling nudge could boost platform-wide engagement."

E-commerce — "Cart abandonment spikes 40% when shipping cost exceeds 8% of cart value. Free shipping threshold at $75 would recover an estimated 1,200 orders/month."

Fraud Detection — "Accounts created in the last 48 hours with 5+ high-value transactions account for 82% of chargebacks. Flagging this pattern would prevent $34K/month in losses."

SaaS — "Teams that don't use the dashboard feature within 14 days of signup have 3x higher churn. An onboarding email on Day 3 highlighting dashboards could improve activation."

SQL Performance — "The top 10 slowest queries consume 62% of warehouse compute. 7 of them scan full tables where a partition filter would reduce cost by ~$4,800/month."

These are examples — create a domain pack for any industry and DecisionBox adapts its analysis accordingly.

Quick Start

Prerequisites: Docker and Docker Compose

# Clone the repository
git clone https://github.com/decisionbox-io/decisionbox-platform.git
cd decisionbox-platform

# Start MongoDB + API + Dashboard
docker compose up -d

# Open the dashboard
open http://localhost:3000

The dashboard will guide you through creating your first project. You'll need:

• A data warehouse connection (BigQuery project ID, Redshift workgroup, Snowflake account, or Databricks workspace)
• An LLM API key (Anthropic, OpenAI, or configure Vertex AI / Bedrock)

For detailed setup instructions, see the Installation Guide.

Deployment

Method	Use case	Guide
Docker Compose	Local dev, single server	Docker
Kubernetes (Helm)	Production on any K8s cluster	Kubernetes
Terraform (GCP)	Automated GKE provisioning	Terraform GCP
Terraform (AWS)	Automated EKS provisioning	Terraform AWS
Terraform (Azure)	Automated AKS provisioning	Terraform Azure
Setup Wizard	One-command GKE/EKS/AKS + Helm deploy	Setup Wizard

Resources: Helm charts | Terraform modules | Helm values reference

Development

Run locally without Docker (recommended for development):

# Start MongoDB only
docker compose up -d mongodb

# Terminal 1: Run the API
make dev-api

# Terminal 2: Run the Dashboard
make dev-dashboard

# Open http://localhost:3000

Build binaries:

make build              # Build agent + API binaries
make build-dashboard    # Build dashboard

Run tests:

make test               # All tests (Go + UI)
make test-go            # Go unit tests only
make test-integration   # Integration tests (needs Docker)
make test-llm           # LLM provider tests (needs API keys)

Extending DecisionBox

DecisionBox is built on a plugin architecture. You can add:

Domain Packs

Domain packs define how the AI analyzes data for a specific industry. A domain pack includes:

• Analysis areas (what to look for)
• Prompt templates (how the AI reasons)
• Profile schemas (what context users provide)

Domain packs are stored in MongoDB and managed from the dashboard. Built-in packs (gaming, ecommerce, social) are seeded on first startup. Create your own from the dashboard or import a portable JSON file -- no code changes needed.

See Creating Domain Packs.

LLM Providers

Add support for any LLM by implementing the llm.Provider interface (one method: Chat).

See Adding LLM Providers.

Warehouse Providers

Add support for any SQL warehouse by implementing the warehouse.Provider interface.

See Adding Warehouse Providers.

Middleware Hooks

Wrap warehouse providers or HTTP handlers with custom logic using the middleware registration system:

• Warehouse middleware — warehouse.RegisterMiddleware() wraps the warehouse provider (e.g., query logging, access controls, cost tracking)
• HTTP middleware — apiserver.RegisterGlobalMiddleware() wraps all API requests (e.g., audit logging, custom auth)
• Custom agent builds — Import agentserver.Run() and register middleware via init() blank imports

Configuration

Key environment variables:

Variable	Default	Description
MONGODB_URI	(required)	MongoDB connection string
MONGODB_DB	decisionbox	Database name
SECRET_PROVIDER	mongodb	Secret storage: mongodb, gcp, aws
RUNNER_MODE	subprocess	Agent runner: subprocess, kubernetes
LLM_TIMEOUT	300s	Timeout per LLM API call
TELEMETRY_ENABLED	true	Anonymous usage telemetry (details)

Full reference: Configuration.

Telemetry

DecisionBox collects anonymous usage telemetry to help improve the product. No PII, query content, or credentials are ever collected. Disable with TELEMETRY_ENABLED=false or DO_NOT_TRACK=1. See TELEMETRY.md for full details.

Documentation

decisionbox.io/docs — Full documentation including:

• Quick Start
• Installation Guide
• Architecture
• Providers
• Domain Packs
• API Reference
• Configuration Reference
• Contributing

Tech Stack

Component	Technology
Agent	Go 1.25
API	Go 1.25, net/http (stdlib)
Dashboard	Next.js 16, React 19, TypeScript, Mantine 8
Database	MongoDB
CI/CD	GitHub Actions, GHCR
Deployment	Docker Compose, Kubernetes (Helm), Terraform (GCP, AWS, Azure)

Contributing

We welcome contributions. See Contributing Guide for development setup, testing, and PR process.

Community

• GitHub Issues — Bug reports, feature requests
• GitHub Discussions — Questions, ideas

Roadmap

See the full roadmap on the project board.