SyntheticBrew Engine

SyntheticBrew is an open-source, self-hosted AI agent runtime with a no-code dashboard. Build and orchestrate agents from a web UI — or describe what you need in plain English to your coding assistant and let it provision them over MCP. Agents are grounded in your business data, not guesswork, and wired to the tools, memory, and knowledge specific to your business. One Docker command, any LLM provider, your infrastructure.

AI is now a baseline expectation for modern software. Customers expect products that understand context, automate work, answer questions, and act on your business logic — and a company without AI is falling behind the ones that have it. But shipping reliable AI isn't just picking a model. It takes infrastructure: RAG and vector search, knowledge bases and knowledge graphs, tool integration, multi-agent orchestration, memory, permissions, and observability. Building that yourself is hard, slow, expensive, and demands expertise most teams don't have to spare.

That's the gap SyntheticBrew closes. The usual options all fall short — build it from scratch (months before the first useful feature), rent a closed cloud platform (per-token markup, vendor lock-in, your data on someone else's servers), or cobble a dozen frameworks together (glue code you now own forever). SyntheticBrew ships the whole runtime in the box instead: self-hosted, no lock-in, and you pay only your own LLM provider. Everything is included — see Features.

Your agents answer grounded in your business data, not guesswork — knowledge-graph taxonomy gives typed, grounded retrieval so they don't make things up. Feed in your data three ways: upload documents (RAG over PDF, DOCX, TXT, Markdown, and CSV files), define a knowledge graph for structured records, or connect live systems via MCP tools.

No in-house AI team to wire it up? Synthetic AI Inc also builds custom AI integrations on SyntheticBrew — see Custom integrations.

Dashboard

Everything runs from a no-code admin dashboard — no config files required. Build and configure agents (model, system prompt, tools, memory), connect LLM providers and MCP tool servers, and load knowledge bases (RAG) and knowledge graphs. Test agents in a live chat playground, queue background tasks with priorities and approval gates, manage API keys and settings, import/export config for GitOps, and review every run through the tool-call log and an immutable audit log.

Features

• Multi-Agent Orchestration — agents spawn and coordinate with each other via ReAct framework
• MCP Tool Ecosystem — connect any Model Context Protocol server (stdio, HTTP, SSE, Streamable HTTP)
• Visual Admin Dashboard — configure agents, models, schemas, and tools from a web UI
• Task System — async background tasks with priorities, dependencies, and approval gates
• Knowledge Base / RAG — vector search over uploaded documents with pgvector
• Knowledge Graphs — typed, grounded retrieval over your structured data via auto-generated list_/get_ MCP tools (exact answers, not fuzzy similarity)
• Agent Memory — cross-session persistent memory, scoped per end user and schema
• Headless API — REST + SSE chat for any frontend (web, mobile, CLI). No proprietary clients.
• BYOK — bring your own keys for any OpenAI-compatible LLM provider
• Self-Hosted — deploy on your infrastructure with Docker, Kubernetes, or bare metal

Quick Start

# 1. Download the Compose file
curl -fsSL https://syntheticbrew.ai/releases/docker-compose.yml -o docker-compose.yml

# 2. Create .env — both values are required, Compose fails fast without them
cat > .env <<EOF
POSTGRES_PASSWORD=$(openssl rand -hex 16)
SYNTHETICBREW_BOOTSTRAP_ADMIN_TOKEN=bb_$(openssl rand -hex 32)
EOF

# 3. Start
docker compose up -d

# 4. Open the admin dashboard in your browser
#    http://localhost:8443/admin/

There is no login form and no password. The engine runs in local auth mode: it generates its own Ed25519 keypair on first boot and mints a short-lived admin session for the dashboard automatically. The SYNTHETICBREW_BOOTSTRAP_ADMIN_TOKEN you generated above is seeded into the API-token table on first boot — use it as Authorization: Bearer bb_… for headless/CI access:

curl http://localhost:8443/api/v1/health
# {"status":"ok","version":"...","agents_count":0}

Configure your LLM provider, model, and API key in the onboarding wizard on first launch (or later via Admin → Models). See the Quick Start guide for creating your first agent and sending a message.

Or build from source:

cd engine
go build -o syntheticbrew ./cmd/ce
DATABASE_URL=postgresql://user:pass@localhost:5432/syntheticbrew ./syntheticbrew

A reachable PostgreSQL instance with the pgvector extension is required; run the Liquibase migrations in engine/migrations/ before the first start.

Use it from your coding agent (MCP)

SyntheticBrew exposes a Model Context Protocol server over Streamable HTTP, so you can build and ship an embeddable chat agent by talking to your coding assistant — no dashboard clicks, no YAML.

Try it hosted on SyntheticBrew Cloud (OAuth sign-in, no token to paste):

Or connect any MCP client (Claude Code, Cursor, VS Code, Cline) to https://app.syntheticbrew.ai/api/v1/mcp/rpc. Self-hosting? Point it at <ENGINE_URL>/api/v1/mcp/rpc instead. See the connect-a-coding-agent guide.

Configuration

SyntheticBrew can be configured via:

Key environment variables:

DATABASE_URL=postgresql://user:pass@host:5432/syntheticbrew
SYNTHETICBREW_AUTH_MODE=local            # local (default) | external
SYNTHETICBREW_JWT_KEYS_DIR=/var/lib/syntheticbrew/keys
SYNTHETICBREW_BOOTSTRAP_ADMIN_TOKEN=bb_… # optional: seeds an admin API token on first boot

There are no ADMIN_USER / ADMIN_PASSWORD variables — the engine has no password auth. Every API request is authenticated with an Ed25519-signed JWT or a bb_… API token. In local mode the engine generates its own keypair in SYNTHETICBREW_JWT_KEYS_DIR; in external mode it validates tokens against a pre-provisioned public key (SYNTHETICBREW_JWT_PUBLIC_KEY_PATH).

LLM provider, model and API key are configured through the onboarding wizard on first launch (or later via Admin → Models). Engine does not read LLM credentials from env or config files.

The full list lives in engine/.env.example.

Architecture

SyntheticBrew follows Clean Architecture with strict layer separation. All Go code lives under engine/:

engine/
  cmd/ce/              Community Edition entry point
  internal/
    domain/            Pure domain entities
    usecase/           Business logic + consumer-side interfaces
    service/           Task worker, orchestrator, session processing
    infrastructure/    DB, LLM, MCP, agents, tools
    delivery/          HTTP handlers
    app/               Application bootstrap
  admin/               React/TypeScript admin dashboard
  widget/              Embeddable chat widget
  deploy/              Docker, Helm, systemd assets

Deployment

Documentation

• Website: https://syntheticbrew.ai
• Docs: https://syntheticbrew.ai/docs/
• API Reference: https://syntheticbrew.ai/docs/api/

Custom integrations

Don't have the in-house expertise to build it yourself? Synthetic AI Inc designs, builds, and deploys custom AI integrations on SyntheticBrew — your data, your tools, your workflows, taken all the way into production. Whether your AI is internal-facing or customer-facing, we make it speak your business.

Get in touch at syntheticbrew.ai or info@syntheticbrew.ai.

Contributing

We welcome contributions! Please read CONTRIBUTING.md before submitting a PR.

• Code of Conduct
• Security Policy

License

Licensed under Business Source License 1.1. Contact info@syntheticbrew.ai for alternative licensing.