        ·   ✦   ·
         \  │  /
          \ │ /
  · ✦ ───── ★ ───── ✦ ·
          / │ \
         /  │  \
        ·   ✦   ·

Vega

Fault-tolerant AI agent orchestration for Go

Erlang-style supervision trees, a YAML DSL for non-programmers, and a built-in web dashboard with real-time streaming.

View on GitHub → Quick Start

Install

# CLI via Homebrew

brew install everydev1618/tap/vega

# Go library

go get github.com/everydev1618/govega

Features

⟳

Erlang-style supervision

OneForOne, OneForAll, RestForOne strategies. Processes restart automatically with exponential backoff. Process linking and monitors included.

⬡

Go library + YAML DSL

Full programmatic control via Go, or define multi-agent workflows in YAML with if/else, for-each, parallel, and try/catch.

◈

Built-in web dashboard

Chat UI, process explorer, spawn tree, cost dashboard, SSE event stream, and REST API. Run vega serve and open localhost:3001.

⌬

MCP server support

Connect any Model Context Protocol server. Tools are registered automatically as servername__toolname and available to agents.

◎

Smart error classification

7 error classes (RateLimit, Overloaded, Timeout…). Rate-limited calls get retried with backoff. Auth errors are not retried.

≋

Real-time streaming

Token-by-token SSE streaming with inline tool call panels. ChatStream API makes rich UIs straightforward to build.

Quick Start

Go library

package main

import (

"context"

"fmt"

"github.com/everydev1618/govega"

"github.com/everydev1618/govega/llm"

)

func main() {

llm := llm.NewAnthropic()

orch := vega.NewOrchestrator(

vega.WithLLM(llm),

)

agent := vega.Agent{

Name: "assistant",

Model: "claude-sonnet-4-20250514",

System: vega.StaticPrompt("You are helpful."),

}

proc, _ := orch.Spawn(agent)

resp, _ := proc.Send(context.Background(), "Hello!")

proc.Complete(resp)

fmt.Println(resp)

}

YAML DSL

name: MyTeam

agents:

researcher:

model: claude-sonnet-4-20250514

system: You research topics thoroughly.

writer:

model: claude-sonnet-4-20250514

system: You write clear summaries.

workflows:

report:

steps:

- researcher:

send: "Research {{topic}}"

save: findings

- writer:

send: "Summarise: {{findings}}"

# Run it

vega run team.vega.yaml \

--workflow report \

--task "topic=Go concurrency"

Why Vega?

Not ready for production

Vega is an early-stage project and very much a work in progress. APIs will break, features are incomplete, and it has not been hardened under real production load. Use it to learn, experiment, and contribute — but not yet to run anything you depend on.

A fair comparison requires an honest framing. Vega and OpenClaw are both AI agent projects from the same author, but they solve fundamentally different problems. Neither is a substitute for the other.

OpenClaw

A personal AI assistant for end users

OpenClaw runs as a daemon on your devices and connects to messaging channels you already use — WhatsApp, Telegram, Slack, Discord, iMessage, and more. It pairs with your phone and Mac so the agent can take real-world actions: browse the web, run shell commands, control your screen. It is built for one person, local-first, and privacy-centric.

Vega

A framework for building backend agent services

Vega is a Go library and CLI for developers who need to run multi-agent systems reliably in production. Its core concern is fault tolerance: processes restart automatically, errors are classified and retried intelligently, costs are tracked per agent, and everything is observable through a built-in dashboard. It is not an end-user product.

Dimension	OpenClaw	Vega
Target use	Personal AI assistant	Backend agent services
Language / runtime	TypeScript · Node.js	Go
LLM providers	Claude, OpenAI, Gemini, Bedrock…	Anthropic only (for now)
Messaging channels	10+ (WhatsApp, Telegram, Slack, Discord, Signal, iMessage, Matrix…)	Telegram
Device integration	iOS · Android · macOS apps	—
Browser automation	✓ Playwright	—
Fault tolerance	Session recovery	Erlang-style supervision trees
Process linking	—	✓ Links · monitors · trap-exit
Smart error retry	—	✓ 7 error classes
Per-process cost caps	—	✓ Budget per agent
Workflow engine	—	✓ YAML DSL with if/else, loops, parallel
Built-in dashboard	—	✓ Process explorer, spawn tree, cost graph
Multi-agent teams	Via session tools	✓ Process groups + shared blackboard
MCP server support	Via mcporter bridge	✓ Native client
Vector memory	✓ LanceDB plugin	—
Multi-host clustering	—	—

Current limitations in Vega

These are real gaps, not roadmap promises. We'd rather you know them upfront than discover them after adopting the project.

Anthropic only

No OpenAI, Gemini, or local model support yet. The LLM interface makes this possible to add, but it doesn't exist today.

In-memory process registry

All process state lives in a single process. No clustering, no multi-host coordination, no hand-off across restarts.

Crude token estimation

Context trimming uses ~4 chars per token — not actual tokenisation. Works well enough in practice, but it's an approximation.

Limited DSL expressions

The YAML expression language has no custom functions and global-only variable scope. Complex logic still needs Go code.

Basic sandboxing

Tool sandboxing is path-based only. No memory limits, I/O quotas, or capability restrictions beyond file paths.

No companion apps

No mobile or desktop apps. Vega is a server-side library and CLI, not an end-user product.

About the author

Etienne de Bruin

@everydev1618 · @etdebruin · everydev.com

I'm a software developer with a long background in building developer tools and communities. Vega is my attempt to understand agent orchestration from the inside — by building it myself, making mistakes in public, and learning from people who are doing this at a far greater depth and scale than I am.

I think of myself as a student of this space more than an expert in it. The Erlang supervision model has been quietly solving distributed reliability problems for forty years, and it struck me that almost nobody in the AI agent world has reached for it yet. Vega is that experiment. Whether the idea is right is still an open question.

People I learn from

Joe Armstrong

Creator of Erlang. Proved that distributed, fault-tolerant systems are achievable by design, not just by hope. The supervision tree concept at the heart of Vega is entirely his.

Andrej Karpathy

His patient, first-principles approach to explaining AI has shaped how I think about LLMs. The idea of software written in natural language rather than code feels increasingly like the right frame.

Harrison Chase

Founder of LangChain. Showed that the developer community was hungry for higher-level agent abstractions. Even where Vega disagrees with the approach, LangChain opened the conversation.

Andrew Ng

A relentless advocate for agentic workflows as the next meaningful frontier. His framing of agents as loops with tools and memory has been a useful mental model throughout this project.

Dario Amodei

CEO of Anthropic. The care Anthropic puts into the reliability and honesty of Claude has made it the right foundation to build on. The API is a joy to work with.

You

If you've used Vega, filed an issue, or had a conversation with me about agent design — you've shaped this project. This is still early enough that every conversation leaves a mark.