draftcrew

DraftCrew

High-performance Go framework for AI agent orchestration.

Inspired by CrewAI — built for Go. Agents, tasks, crews, and all 6 process types (sequential, hierarchical, consensual, reflective, flow, state machine) in a single binary with zero runtime dependencies.

go get github.com/bzdvdn/draftcrew@latest

Why DraftCrew?

Python-based agent frameworks (CrewAI, AutoGen, LangGraph) are powerful but hit walls in production: GIL contention, no native concurrency, heavy dependency trees, and complex deployment. DraftCrew brings agent orchestration to Go's world:

• Goroutines, not GIL — true parallel agent execution via Go's concurrency model
• Static typing — catch misconfigurations at compile time, not runtime
• Single binary — no Python runtime, no pip install, no virtualenvs
• Type-safe tools — GetOutput[T](result) via generics, zero reflection
• Production observability — built-in event bus, telemetry, OpenTelemetry bridging
• MCP-native — Model Context Protocol client for tool discovery (stdio + SSE)

Status: v0.9 — Built-in Tools & Provider Ecosystem (database tools ✅, cloud tools ✅, web scraping ✅, document RAG ✅, directory/website RAG ✅, research tools ✅, additional LLM providers ✅, advanced guardrails ✅, storage backends ✅, conditional tasks ✅, otel metrics ✅)

Core primitives + A2A delegation + MCP server + WASM/Docker sandbox + knowledge ingestion (RAG) + browser automation + output guardrails + DAG flow bridge + dashboard v2 with real telemetry data. v0.6 quick wins done: file I/O tools, calculator, web search, ask human, Gemini tool calling, MCP stdio server, more LLM providers (Groq, Together AI, Bedrock, Vertex AI). v0.7: output streaming (frame + chunk + SSE bridge) + unified memory with hierarchical scopes, composite scoring, pluggable backends (in-memory + SQLite), callback events, agent/crew integration, and typed event bus with 72+ event types across 13 categories, wildcard/matcher subscriptions, goroutine pool, CallbackBridge migration bridge, OTEL bridge, dashboard SSE bridge. v0.8: tool result caching, JSONC config format, async crew execution, replay system, skills system, CLI enrichment (chat, train, test, version, reset-memories, log-tasks-outputs) — all done. v0.9: storage backends, conditional tasks, OTEL metrics — Prometheus-exported histograms and counters for LLM/tool/task/crew durations, token usage, and error rates. 22+ packages, race-detector clean.

What works today

Where we're heading

DraftCrew aims to match CrewAI's feature set and then surpass it in areas where Go excels. The roadmap:

Completed (v0.1–v0.7)

• Agent/Task/Crew core — ReAct loop, 6 process types, context passing ✅ done
• A2A Protocol — agent-to-agent delegation with HTTP+WebSocket ✅ done
• MCP Server + Sandbox — MCP protocol, WASM/Docker code execution ✅ done
• Knowledge ingestion — RAG with PDF/CSV/URL sources ✅ done
• Browser automation — chromedp-based web interaction ✅ done
• Output guardrails — regex, length, contains, banned words, JSON schema ✅ done
• Training/HITL loop — feedback-loop agent improvement ✅ done
• Flow ↔ Crew bridge — DAG flow engine wired into crew process types ✅ done
• Dashboard v2 — real-time monitoring with live telemetry data ✅ done
• Quick wins — file I/O tools, calculator, web search, ask human, Gemini, MCP stdio, more LLMs ✅ done
• Output streaming — frame + chunk streaming with SSE bridge ✅ done
• Unified Memory — hierarchical scopes, composite scoring, MemVectorStore + SQLiteVecStore, agent/crew integration ✅ done
• Event Bus — 72+ typed events across 13 categories, wildcard/matcher, ScopedBus, Listener, OTEL bridge, CallbackBridge, dashboard SSE bridge ✅ done
• Tool Result Caching — ToolCache interface, LRU backend, CachedTool wrapper, agent/crew config, cache counters, per-tool policy ✅ done
• JSONC Config Format — JSONC parser, auto-detect, split layout, CLI routing, placeholder prompting, 20 tests, 0 external deps ✅ done
• Async Crew Execution — KickoffAsync, Awaitable, KickoffForEach, KickoffForEachAsync, streaming for all 6 process types, ErrCrewBusy, context cancellation, error isolation ✅ done
• Replay System — Replay, ReplayFromCheckpoint, Fork, enhanced checkpoint schema, CLI commands, ListCheckpoints ✅ done
• Skills System — SKILL.md format, agent/crew injection, registry, CLI commands ✅ done
• Planner — agent-level planning, plan generation/injection/refinement, crew propagation, checkpoint storage, YAML/JSONC config, runnable example ✅ done
• Database Tools — SQLiteSearchTool, PGSearchTool, MySQLSearchTool, NL2SQLTool ✅ done
• Cloud Tools — S3ReaderTool, S3WriterTool, GitHubTool, SlackTool ✅ done
• Web Scraping Tools — ScrapeWebsiteTool, FirecrawlTool ✅ done
• Document RAG Tools — PDFSearchTool, CSVSearchTool, JSONSearchTool, TXTSearchTool ✅ done
• Directory & Website RAG — DirectorySearchTool, WebsiteSearchTool ✅ done
• Research Tools — ArxivTool, WikipediaTool, ExaTool ✅ done
• Advanced Guardrails — LLMGuardrail, Chain, structured ValidationError ✅ done
• Storage Backends — pluggable knowledge pipeline (Qdrant, ChromaDB, Weaviate, Pinecone, pgvector) + RedisVecStore with RediSearch ✅ done
• Conditional Tasks — TaskConfig.Condition for runtime task skip ✅ done

Next (v0.9+ — in progress)

Long-term vision

• Visual workflow builder — DAG-based crew designer
• gRPC mesh server — distributed agent orchestration across machines
• Cloud control plane — fleet management for production agent deployments
• Training/fine-tuning pipeline — feedback-loop agent improvement

Out of scope (for now)

DraftCrew will not become a vector database, a training framework, or a cloud platform. We build the orchestration layer — you bring the infrastructure.

Quick start

package main

import (
    "context"
    "fmt"

    "github.com/bzdvdn/draftcrew/src/pkg/agent"
    "github.com/bzdvdn/draftcrew/src/pkg/crew"
    "github.com/bzdvdn/draftcrew/src/pkg/llm"
    "github.com/bzdvdn/draftcrew/src/pkg/task"
)

func main() {
    llmClient := llm.NewOpenAI("sk-...", "gpt-4")

    a := agent.New(agent.Config{
        Role:    "Researcher",
        Goal:    "Research Go 1.22 features",
        LLM:     llmClient,
        MaxIter: 15,
    })

    t := task.New(task.Config{
        Description:    "Find key features",
        ExpectedOutput: "List of features",
        Agent:          a,
    })

    c := crew.New(crew.Config{
        Agents:  []*agent.Agent{a},
        Tasks:   []*task.Task{t},
        Process: crew.ProcessSequential,
    })

    result, err := c.Kickoff(context.Background())
    if err != nil {
        panic(err)
    }
    fmt.Printf("%+v\n", result)
}

See the Quickstart Guide for the full walkthrough.

Installation

go get github.com/bzdvdn/draftcrew@latest

Or install the CLI:

go install github.com/bzdvdn/draftcrew/cmd/draftcrew@latest

Requires Go 1.22+.

Documentation

• Quickstart Guide — 5-minute tutorial
• Getting Started — installation and basic usage
• Core Concepts — architecture, agents, tasks, processes
• LLM Providers — setup for all supported backends
• Tools Reference — built-in tool descriptions
• YAML / JSONC Reference — configuration file reference
• MCP Server — expose agents as MCP-compatible endpoints
• Sandbox — secure code execution via WASM and Docker
• Knowledge Sources — RAG document ingestion and agent integration
• Output Streaming — real-time frame + chunk streaming, SSE bridge
• Skills System — SKILL.md format, agent/crew injection, registry, CLI
• Conditional Tasks — condition-based task skip and error handling
• OTEL Metrics — Prometheus-exported OpenTelemetry metric instruments
• Storage Backends — pluggable knowledge vector stores + RedisVecStore memory
• API Reference — full package API
• Compatibility — versioning policy

Roadmap

Detailed roadmap: ROADMAP.md

Contributing

We welcome contributions. See the specs for active work items and AGENTS.md for workflow conventions.

License

MIT — see LICENSE.