Galdor – a Go LLM agent framework with built-in tracing and replay

Galdor, a Go-native framework for building and observing AI agents, launched v1.0.0 in June 2026 with built-in OpenTelemetry tracing, an embedded SQLite dashboard, and first-party support for both MCP and A2A protocols. The framework distinguishes itself from alternatives like LangChain and Eino by offering a fully self-hostable, single-binary observability stack without external SaaS dependencies.

galdor n., Old English, c. 9th century : incantation, spell, a chanted word that bends reality. A Go-native framework for building, orchestrating and observing AI agents. Native OpenTelemetry. Embedded dashboard. One binary. No external SaaS. Apache 2.0. The table below was last verified against each project's repo, releases and official docs in May 2026. Sources are linked under the table; PRs welcome when something drifts. | galdor | LangChain Python + LangSmith | LangChainGo | Eino | Genkit Go | | |---|---|---|---|---|---| | Latest release | v1.0.0 Jun 2026 | langchain-core v1.4.0 May 2026 | v0.1.14 Oct 2025 | v0.8.13 stable, v0.9.0-alpha active May 2026 — pre-1.0 | mcp plugin v1.8.0 GA May 2026 | | Language / runtime | Go | Python | Go | Go | Go | | Observability story | OTel-native, with an embedded SQLite trace store + dashboard served from the same binary | LangSmith closed-source SaaS | callbacks only, no OTel | callbacks; the shipped tracing target is Langfuse, not OTel | OTel-native; Genkit Monitoring the hosted dashboard is Google-Cloud only | | End-to-end self-hostable incl. dashboard | yes | no — self-hosted LangSmith requires the paid Enterprise plan | yes BYO observability stack | yes Apache framework + self-hosted Langfuse | partial — OTel exporters point anywhere, but the polished Genkit Monitoring dashboard is GCP-only | | Dependency footprint | core module pulls 6 direct + 13 indirect the OTel + SQLite stack | n/a | monolithic module; go.sum is 1,523 lines ≈200+ unique upstream modules | core + per-component modules under eino-ext | per-plugin Go packages under firebase/genkit/go/plugins/ | | MCP Anthropic spec | client + server; stdio, SSE, Streamable HTTP | client + tool-as-server, first-party | client only, via 3rd-party adapters e.g. i2y/langchaingo-mcp-adapter | client only, first-party | client + server, first-party stdio / SSE / StreamableHTTP | | A2A Google spec | client + server | not first-party | no | no | no — even though Google authored A2A, its Go support lives in the separate a2aproject/a2a-go SDK and in ADK Go, not in Genkit | | Multi-agent built in | Supervisor + Swarm in pkg/council | LangGraph: supervisor, hierarchy, swarm | agents package ReAct, conversational ; no supervisor/swarm/hierarchy | DeepAgent supervisor + sub-agent delegation + graph orchestration | Flows + tool-calling agents; supervisor/swarm not first-class | | Replay record real run → deterministic re-run | yes record-to-fixture, replay anywhere | LangSmith dataset replay in the SaaS | no mock + conformance suite, not record/replay | no | no documented offline fixture replay | | Eval framework | yes, in-tree | langchain.evaluation + LangSmith eval UI | none | none | yes, evaluators plugin | | License | Apache 2.0 | LangChain MIT; LangSmith proprietary | MIT | Apache 2.0 | Apache 2.0 | galdor's distinctive position: OTel-native + a single-binary self-hosted dashboard + first-party MCP server + first-party A2A server , all in Go. None of the other four projects ship all of those today. If your stack runs Python comfortably and you're happy paying for LangSmith, LangChain is the most mature option. If you need broad Go provider coverage today more adapters than galdor's four , Eino is further along — at the cost of no OTel and no A2A. If you need Go and MCP server-side exposure and A2A interop in one place, galdor is currently the only framework that ships both first-party. Sources verified May 2026 : langchain-ai/langchain https://github.com/langchain-ai/langchain , LangSmith self-host docs https://docs.langchain.com/langsmith/architectural-overview , tmc/langchaingo https://github.com/tmc/langchaingo , cloudwego/eino https://github.com/cloudwego/eino + eino-ext https://github.com/cloudwego/eino-ext , firebase/genkit/go/plugins/mcp https://pkg.go.dev/github.com/firebase/genkit/go/plugins/mcp , firebase/genkit/go/plugins https://github.com/firebase/genkit/tree/main/go/plugins , a2aproject/a2a-go https://github.com/a2aproject/a2a-go . v1.0.0 released. Looking for early integrators. The 10-phase roadmap is functionally complete: provider abstraction Anthropic, OpenAI/MiniMax/Groq/Together/DeepSeek/vLLM/Ollama via BaseURL or providerset /YasserCR/galdor/blob/main/providerset , Google Gemini, AWS Bedrock · type-safe tools with reflection-derived JSON schemas · directed graph runtime with checkpoints, interrupt/resume and branch-map conditional edges · ReAct and Plan-and-Execute agent helpers · native OTel observability with embedded SQLite trace store, auto-WAL-checkpointing exporter, auto-stamped run ids, and an orphan-span warning banner · embedded web dashboard with live SSE, per-run DAG, time-travel · short-term memory windows + long-term memory backends in-mem, SQLite/BM25, pgvector, qdrant · provider-backed and HTTP/TEI embedders · Council multi-agent patterns Supervisor, Swarm · MCP client + server over stdio, SSE, and Streamable HTTP · A2A protocol Google · inline eval framework with LLM-as-judge · schema-bound structured output a Go struct in, a decoded value out · deterministic replay with prompt fingerprinting · per-provider retry/backoff, run/node timeouts, panic recovery, structured logging, goroutine leak gates, capability-aware validation · thinking-block strip middleware for OpenAI-compat thinking models. What's next: real-world integration feedback. If you're shipping agents in Go and the table at the top resonates, try galdor on your stack and open an issue — the framework has covered the surface; the remaining edges only show up in actual deployments. The pragma-galdor https://github.com/YasserCR/galdor/blob/main/docs/patterns/queue-worker.md retro is one such report, and it shaped most of v0.1.0; more would be welcome. As of v1.0.0 , the public API under pkg/ is stable under SemVer : breaking changes only land in a future v2. See ROADMAP.md /YasserCR/galdor/blob/main/ROADMAP.md for full phase tracking and what's next. go get github.com/YasserCR/galdor@v1.0.0 plus the provider s you need: go get github.com/YasserCR/galdor/providers/anthropic@v1.0.0 go get github.com/YasserCR/galdor/providers/openai@v1.0.0 or pick a provider at runtime via env var: go get github.com/YasserCR/galdor/providerset@v1.0.0 The core module pulls only what it needs — providers, memory backends and protocol adapters live in their own Go modules so your dependency tree stays tight. For the CLI + dashboard: go install github.com/YasserCR/galdor/cmd/galdor@v1.0.0 galdor ui --db ./traces.db open http://127.0.0.1:7777 If galdor isn't found after installing, the go install bin directory isn't on your PATH — add it export PATH="$ go env GOPATH /bin:$PATH" , or run galdor doctor from the full path to diagnose your setup. A complete ReAct agent in 20 lines: package main import "context" "fmt" "log" "os" "github.com/YasserCR/galdor/pkg/agent" anthropic "github.com/YasserCR/galdor/providers/anthropic" func main { p, err := anthropic.New anthropic.Config{APIKey: os.Getenv "ANTHROPIC API KEY" } if err = nil { log.Fatal err } answer, err := agent.Run context.Background , agent.Config{ Provider: p, Model: "claude-haiku-4-5", }, "What is the capital of Ecuador?" if err = nil { log.Fatal err } fmt.Println answer } Swap anthropic for openai works with MiniMax / Groq / Together / Mistral via BaseURL , google Gemini , or bedrock and nothing else changes. import "context" "github.com/YasserCR/galdor/pkg/tool" type weatherIn struct { City string json:"city" jsonschema:"required, city to look up" } type weatherOut struct { Temp float64 json:"temp c" Sky string json:"sky" } weather := tool.MustNewTool "weather", "Look up the weather for a city", func ctx context.Context, in weatherIn weatherOut, error { return weatherOut{Temp: 18.5, Sky: "clear"}, nil } reg, := tool.NewRegistry weather answer, := agent.Run ctx, agent.Config{ Provider: p, Tools: reg, Model: "claude-haiku-4-5", }, "How's the weather in Quito?" In and Out are real Go types — the JSON schema published to the LLM is derived from In 's reflection metadata. No magic strings, no interface{} . import sdktrace "go.opentelemetry.io/otel/sdk/trace" "github.com/YasserCR/galdor/pkg/observability" exporter, := observability.NewSQLiteExporter "./traces.db" tp := sdktrace.NewTracerProvider sdktrace.WithBatcher exporter tracer := tp.Tracer "my-agent" // Wrap your provider — every LLM call now produces a span. p = observability.InstrumentProvider p, tracer, observability.WithCaptureContent true Every LLM call, tool invocation, and graph node becomes an OTel span following the GenAI semantic conventions. Inspect them with galdor ui or pipe them to your existing Datadog / Honeycomb / Grafana stack — same data, your choice of consumer. import "github.com/YasserCR/galdor/pkg/council" supervisor, := council.NewSupervisor council.SupervisorConfig{ Provider: p, Model: "claude-haiku-4-5", Workers: council.Worker{ {Name: "billing", Description: "handles invoices, refunds", Run: billingWorker}, {Name: "technical", Description: "diagnoses bugs, outages", Run: technicalWorker}, }, } final, := supervisor.Invoke ctx, council.SupervisorState{Input: userMessage} A scripted-LLM routing supervisor that delegates each turn to specialists. See the full example: examples/integration-support-bot /YasserCR/galdor/blob/main/examples/integration-support-bot . g := graph.New TransferState . AddNode "validate", validate . AddNode "execute", execute . AddEdge graph.START, "validate" . AddEdge "validate", "execute" . InterruptBefore "execute" // ← pause for human approval r, := g.Compile ckpt := graph.NewMemoryCheckpointer TransferState // Phase 1: run until the gate. Returns ErrInterrupted. , err := r.InvokeWith ctx, init, graph.RunOptions TransferState { RunID: runID, Checkpointer: ckpt, } // Phase 2: human reviews and edits state. ck, , := ckpt.Load ctx, runID decision := promptHuman ck.State // your UI / Slack bot / etc. // Phase 3: resume with the decision injected. final, := r.Resume ctx, graph.RunOptions TransferState { RunID: runID, Checkpointer: ckpt, OverrideState: &decision, } Auditable, safe-by-construction approval flows. See examples/integration-approval-gate /YasserCR/galdor/blob/main/examples/integration-approval-gate . // One-time: record a real run with prompt/completion capture on, // then export the recording. // // galdor scry replay <run-id -o fixture.json // Forever after: replay the run for free in CI. rec, := replay.LoadFromFile "fixture.json" mock := replay.NewProvider rec.Calls, replay.ModeStrict r, := agent.NewReAct agent.Config{Provider: mock, Model: "...", Tools: reg} final, := r.Invoke ctx, state // If your prompts drifted, ErrPromptMismatch tells you exactly which call. Regression tests for prompts and agents that don't hit the network and don't burn tokens. See examples/integration-cost-tracked /YasserCR/galdor/blob/main/examples/integration-cost-tracked for the complementary budget-enforcement pattern. import "github.com/YasserCR/galdor/pkg/mcp" "github.com/YasserCR/galdor/pkg/tool/builtins" func main { now, := builtins.NewTimeTool math, := builtins.NewMathTool reg, := tool.NewRegistry now, math, yourCustomTool srv := mcp.NewServer reg, mcp.ServerInfo{Name: "my-tools", Version: "0.1"} transport := mcp.NewStdioTransport os.Stdin, os.Stdout = srv.Serve context.Background , transport } Build the binary, point Claude Desktop's claude desktop config.json at it, restart Claude Desktop. Your tools appear in the picker. Full instructions in examples/integration-mcp-server /YasserCR/galdor/blob/main/examples/integration-mcp-server . For long-lived daemons that many clients share, swap the transport — SSE for IDE-compatibility today, Streamable HTTP for the post-2024-11-05 spec: // pre-2024-11-05 spec the SSE transport Cursor/Claude Desktop still default to transport := mcp.NewSSETransport ":4000" // 2024-11-05 spec single endpoint, session id via Mcp-Session-Id header transport := mcp.NewStreamableHTTPTransport ":4000" import "github.com/YasserCR/galdor/providerset" // Reads LLM PROVIDER, LLM API KEY, LLM BASE URL, LLM HTTP TIMEOUT. // Supports anthropic, openai, google, bedrock + 7 OpenAI-compatible // aliases: groq, together, mistral, minimax, deepseek, vllm, ollama. p, err := providerset.FromEnv The equivalent of LiteLLM for Go: one switch, every supported provider, no per-app boilerplate. Lives in its own module so the core stays lean. See docs/concepts/providerset.md /YasserCR/galdor/blob/main/docs/concepts/providerset.md . import "github.com/YasserCR/galdor/pkg/embedder" // Works against HuggingFace TEI, Infinity, vLLM-embeddings, or any // OpenAI-compatible /embeddings endpoint. Stdlib-only, no CGO. emb, := embedder.NewHTTPEmbedder embedder.HTTPConfig{ URL: "http://localhost:8080", Shape: embedder.ShapeTEI, } Plugs into memory.Retriever directly; satisfies memory.Embedder . See docs/concepts/embedder.md /YasserCR/galdor/blob/main/docs/concepts/embedder.md . import "github.com/YasserCR/galdor/pkg/provider" // Opt-in middleware that strips <think ...</think blocks emitted // inline by OpenAI-compat thinking models MiniMax, DeepSeek, Qwen . // Handles closing tags split across stream deltas. p = provider.StripThinkingBlocks p import "github.com/YasserCR/galdor/pkg/provider" // Automatic retry with exponential backoff + jitter; respects the // server's Retry-After header; never retries auth/invalid-request. p = provider.Retry p, provider.RetryConfig{ MaxAttempts: 5, OnRetry: func n int, d time.Duration, err error { slog.Warn "retrying", "attempt", n, "delay", d, "err", err }, } // Per-run and per-node timeouts; panic recovery in nodes, tools, // and hooks; structured logging via slog. final, err := r.InvokeWith ctx, state, graph.RunOptions State { Timeout: 2 time.Minute, NodeTimeout: 30 time.Second, Logger: slog.New slog.NewJSONHandler os.Stdout, nil , } ┌─────────────────────────────────────────────────────────────┐ │ CLI galdor scry/ui Web dashboard with SSE + per-run DAG│ ├─────────────────────────────────────────────────────────────┤ │ Eval Framework │ Replay Engine │ Time-travel UI │ ├─────────────────────────────────────────────────────────────┤ │ Agent Runtime graph executor over goroutines + channels │ ├─────────────────────────────────────────────────────────────┤ │ Tools │ Memory │ Embedder │ Council │ MCP │ A2A │ ├─────────────────────────────────────────────────────────────┤ │ Provider Abstraction + Providerset env-driven selection │ ├─────────────────────────────────────────────────────────────┤ │ Observability Core OTel-native, embedded SQLite backend │ └─────────────────────────────────────────────────────────────┘ See ARCHITECTURE.md /YasserCR/galdor/blob/main/ARCHITECTURE.md for the full module map and for design decisions. /YasserCR/galdor/blob/main/docs/adr docs/adr/ Each one is a runnable end-to-end demo with its own README. | Example | What it shows | |---|---| integration-support-bot | integration-approval-gate InterruptBefore + MemoryCheckpointer + Resume . Banking-style transfers with low/high/over-cap scenarios. integration-mcp-server tool.Registry as an MCP server over stdio, connectable from Claude Desktop. integration-cost-tracked BudgetProvider middleware enforcing a token cap with $-denominated reporting. integration-http-interpret Smaller, feature-focused examples live alongside: | Example | What it shows | |---|---| agent-react | tools-loop graph-counter graph-interrupt InterruptBefore primitive on its own memory-rag observability-trace scry-store provider-interface Provider eval-suite eval.Config + scorers + RunAndExit structured-output GenerateStructured T : a Go struct in, a decoded value out trial-suite galdor trial eval suite in YAML — the CI gate, no Go cast-agent galdor cast agent in YAML, with --trace into the dashboard council-team galdor council supervisor/swarm topology in YAML spellbook galdor spellbook | Provider | Module path | Streaming | Tools | Vision | Notes | |---|---|---|---|---|---| | Anthropic | providers/anthropic | yes | yes | yes | reference adapter; prompt caching honored | | OpenAI | providers/openai | yes | yes | yes | also works against Mistral, MiniMax, Together, Groq, vLLM via BaseURL | | Google Gemini | providers/google | yes | yes | yes | AI Studio surface; Vertex AI via custom HTTPClient | | AWS Bedrock | providers/bedrock | yes | yes | yes | Converse API; SigV4 via AWS SDK Go v2 | For runtime selection across all of the above plus seven OpenAI-compatible aliases groq , together , mistral , minimax , deepseek , vllm , ollama , pick a provider via env var with providerset.FromEnv /YasserCR/galdor/blob/main/providerset instead of importing each adapter directly. Embedders ship in the same provider modules: openai.NewEmbedder covers OpenAI-compatible endpoints and google.NewEmbedder . For self-hosted embeddings TEI, Infinity, vLLM-embeddings, or any OpenAI-compatible /embeddings endpoint , use pkg/embedder.HTTPEmbedder /YasserCR/galdor/blob/main/pkg/embedder . | Backend | Module path | Best for | |---|---|---| | in-memory | pkg/memory InMemoryStore | tests, getting-started | | SQLite + BM25 | memory/sqlite | single-process production, embedded apps | | pgvector | memory/pgvector | Postgres-centric stacks | | qdrant | memory/qdrant | dedicated vector DB | All four implement the same memory.Store interface, so you swap by changing one constructor. A few semantics differ by design, so check these when porting: | in-memory | SQLite + BM25 | pgvector | qdrant | | |---|---|---|---|---| Empty Chunk.ID on Add | auto-assigned UUID | rejected | rejected | rejected | | Query mode | lexical + vector | lexical BM25 + vector | vector-only | vector-only | | Chunks without an embedding | allowed | allowed lexical | rejected | rejected | The persistent backends require caller-stable IDs so re-ingesting the same chunk is an idempotent upsert a random ID would create duplicates — that's why they reject an empty ID rather than minting one. The vector-only backends need an embedding on every chunk and every query. - You're shipping into infrastructure that can't reach an external SaaS compliance, data residency, air-gap . - You want a single binary you can drop into a container, no Python runtime, no GCP or LangSmith dependency. - You care about audit trails — the SQLite store + replay engine make every run reconstructable from disk. - You're already invested in OTel — galdor's spans drop into your existing pipeline Datadog, Honeycomb, Grafana, Tempo without glue code. - Your team is more comfortable in Go than in Python. - You need the broadest possible ecosystem of pre-built tools, vector stores, and document loaders — LangChain Python still wins on raw integration count. - You need broader Go provider coverage today than the four galdor ships — Eino currently has more provider components in eino-ext . - You need very specific provider features galdor hasn't surfaced yet audio, file uploads, certain vision modes . Check the provider matrix above. - You're an early-stage prototyper who wants a rich hosted GUI to poke at — galdor's dashboard is intentionally lean. Observability galdor ui --db ./traces.db galdor scry list --db ./traces.db galdor scry show <run-id --db ./traces.db galdor scry stats --db ./traces.db --by overall|provider|model galdor scry tail --db ./traces.db --interval 1s galdor scry replay <run-id --db ./traces.db -o fixture.json galdor weave <run-id --db ./traces.db -o graph.svg | --check Config-driven agents YAML in, no Go required galdor cast agent.yaml "your input" --trace galdor council topology.yaml "your input" galdor trial suite.yaml eval gate for CI exit 0/1/2 Tooling galdor mcp serve --http ADDR --base-dir DIR --allow-host H galdor mcp ls|call <URL | -- <command galdor spellbook list|show|diff|render --dir DIR galdor doctor check your environment for setup problems scry is the introspection family Old English: to perceive, to discern . Every trace-reading command honors $GALDOR DB and ~/.galdor/traces.db as fallback paths. Start at docs/ /YasserCR/galdor/blob/main/docs — the index covers quickstart, one conceptual guide per package, applied patterns, migration guides from langchaingo / Eino / Genkit Go / LangChain Python, and the ops guide. — install → first ReAct agent → first tool → first traced run, in 15 minutes docs/quickstart.md — one page per package provider, schema, tool, graph, agent, memory, observability, council, mcp, a2a, eval, replay, spellbook docs/concepts/ — RAG, multi-agent, human-in-the-loop, cost tracking, MCP server, replay-driven tests docs/patterns/ — coming from another framework? side-by-side translations docs/migration/ — deployment shapes, trace store retention, exporting to your OTel pipeline docs/ops.md — runtime overhead, throughput numbers, sizing guidance docs/benchmarks.md — automated tooling, accepted findings, OWASP LLM Top 10 self-assessment docs/security.md — architectural decision records docs/adr/ — module map and design invariants ARCHITECTURE.md — phase-by-phase delivery tracker ROADMAP.md — how decisions get made GOVERNANCE.md — how to send patches CONTRIBUTING.md godoc reference https://pkg.go.dev/github.com/YasserCR/galdor — API surface galdor uses the Developer Certificate of Origin DCO /YasserCR/galdor/blob/main/DCO.txt — every commit must be signed off: git commit -s -m "..." PRs welcome. We don't require a CLA. See CONTRIBUTING.md /YasserCR/galdor/blob/main/CONTRIBUTING.md for the dev loop. galdor is currently maintained by a single BDFL with an explicit plan to transition to a multi-maintainer model once three contributors with sustained activity exist. See GOVERNANCE.md /YasserCR/galdor/blob/main/GOVERNANCE.md . galdor is licensed under the Apache License 2.0 /YasserCR/galdor/blob/main/LICENSE — permissive, with an explicit patent grant, widely accepted by enterprise legal review. Apache 2.0 is the contract; this README is a description. The code in this repository today is published under Apache 2.0 and any version released under that license stays available under it forever — that's what Apache 2.0 means. Forks are welcome. "The incantation framework for Go agents."