{"slug": "galdor-a-go-llm-agent-framework-with-built-in-tracing-and-replay", "title": "Galdor – a Go LLM agent framework with built-in tracing and replay", "summary": "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.", "body_md": "galdor(n., Old English, c. 9th century): incantation, spell, a chanted word that bends reality.\n\n**A Go-native framework for building, orchestrating and observing AI agents.**\nNative OpenTelemetry. Embedded dashboard. One binary. No external SaaS. Apache 2.0.\n\nThe 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.\n\n| galdor | LangChain Python + LangSmith | LangChainGo | Eino | Genkit Go | |\n|---|---|---|---|---|---|\n| 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) |\n| Language / runtime | Go | Python | Go | Go | Go |\n| 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 |\n| 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 |\n| 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) |\ncore + per-component modules under `eino-ext` |\nper-plugin Go packages under `firebase/genkit/go/plugins/*` |\n| 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` ) |\nclient only, first-party | client + server, first-party (stdio / SSE / StreamableHTTP) |\n| 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 |\n| Multi-agent built in | Supervisor + Swarm in `pkg/council` |\nLangGraph: supervisor, hierarchy, swarm | `agents` package (ReAct, conversational); no supervisor/swarm/hierarchy |\nDeepAgent (supervisor + sub-agent delegation) + graph orchestration | Flows + tool-calling agents; supervisor/swarm not first-class |\n| 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 |\n| Eval framework | yes, in-tree | `langchain.evaluation` + LangSmith eval UI |\nnone | none | yes, `evaluators` plugin |\n| License | Apache 2.0 | LangChain MIT; LangSmith proprietary | MIT | Apache 2.0 | Apache 2.0 |\n\ngaldor'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.\n\nIf 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.\n\nSources (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).\n\n`v1.0.0`\n\nreleased. Looking for early integrators.\n\nThe 10-phase roadmap is functionally complete: provider abstraction (Anthropic, OpenAI/MiniMax/Groq/Together/DeepSeek/vLLM/Ollama via `BaseURL`\n\nor [ 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.\n\n**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.\n\nAs of `v1.0.0`\n\n, the public API under `pkg/`\n\nis **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.\n\n```\ngo get github.com/YasserCR/galdor@v1.0.0\n# plus the provider(s) you need:\ngo get github.com/YasserCR/galdor/providers/anthropic@v1.0.0\ngo get github.com/YasserCR/galdor/providers/openai@v1.0.0\n# or pick a provider at runtime via env var:\ngo get github.com/YasserCR/galdor/providerset@v1.0.0\n```\n\nThe 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.\n\nFor the CLI + dashboard:\n\n```\ngo install github.com/YasserCR/galdor/cmd/galdor@v1.0.0\ngaldor ui --db ./traces.db   # open http://127.0.0.1:7777\n```\n\nIf `galdor`\n\nisn't found after installing, the `go install`\n\nbin directory isn't on your PATH — add it (`export PATH=\"$(go env GOPATH)/bin:$PATH\"`\n\n), or run `galdor doctor`\n\nfrom the full path to diagnose your setup.\n\nA complete ReAct agent in 20 lines:\n\n```\npackage main\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"log\"\n\t\"os\"\n\n\t\"github.com/YasserCR/galdor/pkg/agent\"\n\tanthropic \"github.com/YasserCR/galdor/providers/anthropic\"\n)\n\nfunc main() {\n\tp, err := anthropic.New(anthropic.Config{APIKey: os.Getenv(\"ANTHROPIC_API_KEY\")})\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\tanswer, err := agent.Run(context.Background(), agent.Config{\n\t\tProvider: p,\n\t\tModel:    \"claude-haiku-4-5\",\n\t}, \"What is the capital of Ecuador?\")\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\tfmt.Println(answer)\n}\n```\n\nSwap `anthropic`\n\nfor `openai`\n\n(works with MiniMax / Groq / Together / Mistral via `BaseURL`\n\n), `google`\n\n(Gemini), or `bedrock`\n\nand nothing else changes.\n\n```\nimport (\n\t\"context\"\n\t\"github.com/YasserCR/galdor/pkg/tool\"\n)\n\ntype weatherIn struct {\n\tCity string `json:\"city\" jsonschema:\"required, city to look up\"`\n}\ntype weatherOut struct {\n\tTemp float64 `json:\"temp_c\"`\n\tSky  string  `json:\"sky\"`\n}\n\nweather := tool.MustNewTool(\"weather\", \"Look up the weather for a city\",\n\tfunc(ctx context.Context, in weatherIn) (weatherOut, error) {\n\t\treturn weatherOut{Temp: 18.5, Sky: \"clear\"}, nil\n\t})\n\nreg, _ := tool.NewRegistry(weather)\n\nanswer, _ := agent.Run(ctx, agent.Config{\n\tProvider: p, Tools: reg, Model: \"claude-haiku-4-5\",\n}, \"How's the weather in Quito?\")\n```\n\n`In`\n\nand `Out`\n\nare real Go types — the JSON schema published to the LLM is derived from `In`\n\n's reflection metadata. No magic strings, no `interface{}`\n\n.\n\n```\nimport (\n\tsdktrace \"go.opentelemetry.io/otel/sdk/trace\"\n\t\"github.com/YasserCR/galdor/pkg/observability\"\n)\n\nexporter, _ := observability.NewSQLiteExporter(\"./traces.db\")\ntp := sdktrace.NewTracerProvider(sdktrace.WithBatcher(exporter))\ntracer := tp.Tracer(\"my-agent\")\n\n// Wrap your provider — every LLM call now produces a span.\np = observability.InstrumentProvider(p, tracer,\n\tobservability.WithCaptureContent(true))\n```\n\nEvery LLM call, tool invocation, and graph node becomes an OTel span following the GenAI semantic conventions. Inspect them with `galdor ui`\n\nor pipe them to your existing Datadog / Honeycomb / Grafana stack — same data, your choice of consumer.\n\n```\nimport \"github.com/YasserCR/galdor/pkg/council\"\n\nsupervisor, _ := council.NewSupervisor(council.SupervisorConfig{\n\tProvider: p, Model: \"claude-haiku-4-5\",\n\tWorkers: []council.Worker{\n\t\t{Name: \"billing\", Description: \"handles invoices, refunds\",\n\t\t\tRun: billingWorker},\n\t\t{Name: \"technical\", Description: \"diagnoses bugs, outages\",\n\t\t\tRun: technicalWorker},\n\t},\n})\n\nfinal, _ := supervisor.Invoke(ctx, council.SupervisorState{Input: userMessage})\n```\n\nA 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).\n\n```\ng := graph.New[TransferState]().\n\tAddNode(\"validate\", validate).\n\tAddNode(\"execute\", execute).\n\tAddEdge(graph.START, \"validate\").\n\tAddEdge(\"validate\", \"execute\").\n\tInterruptBefore(\"execute\")  // ← pause for human approval\n\nr, _ := g.Compile()\nckpt := graph.NewMemoryCheckpointer[TransferState]()\n\n// Phase 1: run until the gate. Returns ErrInterrupted.\n_, err := r.InvokeWith(ctx, init, graph.RunOptions[TransferState]{\n\tRunID: runID, Checkpointer: ckpt,\n})\n\n// Phase 2: human reviews and edits state.\nck, _, _ := ckpt.Load(ctx, runID)\ndecision := promptHuman(ck.State)  // your UI / Slack bot / etc.\n\n// Phase 3: resume with the decision injected.\nfinal, _ := r.Resume(ctx, graph.RunOptions[TransferState]{\n\tRunID: runID, Checkpointer: ckpt, OverrideState: &decision,\n})\n```\n\nAuditable, safe-by-construction approval flows. See [ examples/integration-approval-gate](/YasserCR/galdor/blob/main/examples/integration-approval-gate).\n\n```\n// One-time: record a real run with prompt/completion capture on,\n// then export the recording.\n//\n//   galdor scry replay <run-id> -o fixture.json\n\n// Forever after: replay the run for free in CI.\nrec, _ := replay.LoadFromFile(\"fixture.json\")\nmock := replay.NewProvider(rec.Calls, replay.ModeStrict)\n\nr, _ := agent.NewReAct(agent.Config{Provider: mock, Model: \"...\", Tools: reg})\nfinal, _ := r.Invoke(ctx, state)\n// If your prompts drifted, ErrPromptMismatch tells you exactly which call.\n```\n\nRegression 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.\n\n```\nimport (\n\t\"github.com/YasserCR/galdor/pkg/mcp\"\n\t\"github.com/YasserCR/galdor/pkg/tool/builtins\"\n)\n\nfunc main() {\n\tnow, _ := builtins.NewTimeTool()\n\tmath, _ := builtins.NewMathTool()\n\treg, _ := tool.NewRegistry(now, math, yourCustomTool)\n\n\tsrv := mcp.NewServer(reg, mcp.ServerInfo{Name: \"my-tools\", Version: \"0.1\"})\n\ttransport := mcp.NewStdioTransport(os.Stdin, os.Stdout)\n\t_ = srv.Serve(context.Background(), transport)\n}\n```\n\nBuild the binary, point Claude Desktop's `claude_desktop_config.json`\n\nat 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).\n\nFor long-lived daemons that many clients share, swap the transport — SSE for IDE-compatibility today, Streamable HTTP for the post-2024-11-05 spec:\n\n```\n// pre-2024-11-05 spec (the SSE transport Cursor/Claude Desktop still default to)\ntransport := mcp.NewSSETransport(\":4000\")\n// 2024-11-05 spec (single endpoint, session id via Mcp-Session-Id header)\ntransport := mcp.NewStreamableHTTPTransport(\":4000\")\nimport \"github.com/YasserCR/galdor/providerset\"\n\n// Reads LLM_PROVIDER, LLM_API_KEY, LLM_BASE_URL, LLM_HTTP_TIMEOUT.\n// Supports anthropic, openai, google, bedrock + 7 OpenAI-compatible\n// aliases: groq, together, mistral, minimax, deepseek, vllm, ollama.\np, err := providerset.FromEnv()\n```\n\nThe 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).\n\n```\nimport \"github.com/YasserCR/galdor/pkg/embedder\"\n\n// Works against HuggingFace TEI, Infinity, vLLM-embeddings, or any\n// OpenAI-compatible /embeddings endpoint. Stdlib-only, no CGO.\nemb, _ := embedder.NewHTTPEmbedder(embedder.HTTPConfig{\n    URL:   \"http://localhost:8080\",\n    Shape: embedder.ShapeTEI,\n})\n```\n\nPlugs into `memory.Retriever`\n\ndirectly; satisfies `memory.Embedder`\n\n. See [ docs/concepts/embedder.md](/YasserCR/galdor/blob/main/docs/concepts/embedder.md).\n\n```\nimport \"github.com/YasserCR/galdor/pkg/provider\"\n\n// Opt-in middleware that strips <think>...</think> blocks emitted\n// inline by OpenAI-compat thinking models (MiniMax, DeepSeek, Qwen).\n// Handles closing tags split across stream deltas.\np = provider.StripThinkingBlocks(p)\nimport \"github.com/YasserCR/galdor/pkg/provider\"\n\n// Automatic retry with exponential backoff + jitter; respects the\n// server's Retry-After header; never retries auth/invalid-request.\np = provider.Retry(p, provider.RetryConfig{\n\tMaxAttempts: 5,\n\tOnRetry: func(n int, d time.Duration, err error) {\n\t\tslog.Warn(\"retrying\", \"attempt\", n, \"delay\", d, \"err\", err)\n\t},\n})\n\n// Per-run and per-node timeouts; panic recovery in nodes, tools,\n// and hooks; structured logging via slog.\nfinal, err := r.InvokeWith(ctx, state, graph.RunOptions[State]{\n\tTimeout:     2 * time.Minute,\n\tNodeTimeout: 30 * time.Second,\n\tLogger:      slog.New(slog.NewJSONHandler(os.Stdout, nil)),\n})\n┌─────────────────────────────────────────────────────────────┐\n│  CLI (galdor scry/ui)    Web dashboard with SSE + per-run DAG│\n├─────────────────────────────────────────────────────────────┤\n│  Eval Framework  │  Replay Engine  │  Time-travel UI        │\n├─────────────────────────────────────────────────────────────┤\n│  Agent Runtime (graph executor over goroutines + channels)  │\n├─────────────────────────────────────────────────────────────┤\n│  Tools  │  Memory  │  Embedder  │  Council  │  MCP  │  A2A  │\n├─────────────────────────────────────────────────────────────┤\n│  Provider Abstraction + Providerset (env-driven selection)  │\n├─────────────────────────────────────────────────────────────┤\n│  Observability Core (OTel-native, embedded SQLite backend)  │\n└─────────────────────────────────────────────────────────────┘\n```\n\nSee [ ARCHITECTURE.md](/YasserCR/galdor/blob/main/ARCHITECTURE.md) for the full module map and\n\n[for design decisions.](/YasserCR/galdor/blob/main/docs/adr)\n\n`docs/adr/`\n\nEach one is a runnable end-to-end demo with its own README.\n\n| Example | What it shows |\n|---|---|\n`integration-support-bot` |\n\n`integration-approval-gate`\n\n`InterruptBefore`\n\n+ `MemoryCheckpointer`\n\n+ `Resume`\n\n. Banking-style transfers with low/high/over-cap scenarios.`integration-mcp-server`\n\n`tool.Registry`\n\nas an MCP server over stdio, connectable from Claude Desktop.`integration-cost-tracked`\n\n`BudgetProvider`\n\nmiddleware enforcing a token cap with $-denominated reporting.`integration-http-interpret`\n\nSmaller, feature-focused examples live alongside:\n\n| Example | What it shows |\n|---|---|\n`agent-react` |\n\n`tools-loop`\n\n`graph-counter`\n\n`graph-interrupt`\n\n`InterruptBefore`\n\nprimitive on its own`memory-rag`\n\n`observability-trace`\n\n`scry-store`\n\n`provider-interface`\n\n`Provider`\n\n`eval-suite`\n\n`eval.Config`\n\n+ scorers + `RunAndExit`\n\n`structured-output`\n\n`GenerateStructured[T]`\n\n: a Go struct in, a decoded value out`trial-suite`\n\n`galdor trial`\n\neval suite in YAML — the CI gate, no Go`cast-agent`\n\n`galdor cast`\n\nagent in YAML, with `--trace`\n\ninto the dashboard`council-team`\n\n`galdor council`\n\nsupervisor/swarm topology in YAML`spellbook`\n\n`galdor spellbook`\n\n| Provider | Module path | Streaming | Tools | Vision | Notes |\n|---|---|---|---|---|---|\n| Anthropic | `providers/anthropic` |\nyes | yes | yes | reference adapter; prompt caching honored |\n| OpenAI | `providers/openai` |\nyes | yes | yes | also works against Mistral, MiniMax, Together, Groq, vLLM via `BaseURL` |\n| Google Gemini | `providers/google` |\nyes | yes | yes | AI Studio surface; Vertex AI via custom `HTTPClient` |\n| AWS Bedrock | `providers/bedrock` |\nyes | yes | yes | Converse API; SigV4 via AWS SDK Go v2 |\n\nFor runtime selection across all of the above plus seven OpenAI-compatible aliases (`groq`\n\n, `together`\n\n, `mistral`\n\n, `minimax`\n\n, `deepseek`\n\n, `vllm`\n\n, `ollama`\n\n), pick a provider via env var with [ providerset.FromEnv()](/YasserCR/galdor/blob/main/providerset) instead of importing each adapter directly.\n\nEmbedders ship in the same provider modules: `openai.NewEmbedder`\n\n(covers OpenAI-compatible endpoints) and `google.NewEmbedder`\n\n. For self-hosted embeddings (TEI, Infinity, vLLM-embeddings, or any OpenAI-compatible `/embeddings`\n\nendpoint), use [ pkg/embedder.HTTPEmbedder](/YasserCR/galdor/blob/main/pkg/embedder).\n\n| Backend | Module path | Best for |\n|---|---|---|\n| in-memory | `pkg/memory` (`InMemoryStore` ) |\ntests, getting-started |\n| SQLite + BM25 | `memory/sqlite` |\nsingle-process production, embedded apps |\n| pgvector | `memory/pgvector` |\nPostgres-centric stacks |\n| qdrant | `memory/qdrant` |\ndedicated vector DB |\n\nAll four implement the same `memory.Store`\n\ninterface, so you swap by changing one constructor. A few semantics differ by design, so check these when porting:\n\n| in-memory | SQLite + BM25 | pgvector | qdrant | |\n|---|---|---|---|---|\nEmpty `Chunk.ID` on `Add` |\nauto-assigned (UUID) | rejected |\nrejected |\nrejected |\n| Query mode | lexical + vector | lexical (BM25) + vector | vector-only | vector-only |\n| Chunks without an embedding | allowed | allowed (lexical) | rejected | rejected |\n\nThe 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.\n\n- You're shipping into infrastructure that can't reach an external SaaS (compliance, data residency, air-gap).\n- You want a single binary you can drop into a container, no Python runtime, no GCP or LangSmith dependency.\n- You care about audit trails — the SQLite store + replay engine make every run reconstructable from disk.\n- You're already invested in OTel — galdor's spans drop into your existing pipeline (Datadog, Honeycomb, Grafana, Tempo) without glue code.\n- Your team is more comfortable in Go than in Python.\n\n- You need the broadest possible ecosystem of pre-built tools, vector stores, and document loaders — LangChain Python still wins on raw integration count.\n- You need broader Go provider coverage today than the four galdor ships — Eino currently has more provider components in\n`eino-ext`\n\n. - You need very specific provider features galdor hasn't surfaced yet (audio, file uploads, certain vision modes). Check the provider matrix above.\n- You're an early-stage prototyper who wants a rich hosted GUI to poke at — galdor's dashboard is intentionally lean.\n\n```\n# Observability\ngaldor ui              --db ./traces.db\ngaldor scry list       --db ./traces.db\ngaldor scry show       <run-id> --db ./traces.db\ngaldor scry stats      --db ./traces.db [--by overall|provider|model]\ngaldor scry tail       --db ./traces.db [--interval 1s]\ngaldor scry replay     <run-id> --db ./traces.db [-o fixture.json]\ngaldor weave           <run-id> --db ./traces.db [-o graph.svg | --check]\n\n# Config-driven agents (YAML in, no Go required)\ngaldor cast            agent.yaml \"your input\"  [--trace]\ngaldor council         topology.yaml \"your input\"\ngaldor trial           suite.yaml               # eval gate for CI (exit 0/1/2)\n\n# Tooling\ngaldor mcp serve       [--http ADDR] [--base-dir DIR] [--allow-host H]\ngaldor mcp ls|call     <URL> | -- <command>\ngaldor spellbook       list|show|diff|render [--dir DIR]\ngaldor doctor          # check your environment for setup problems\n```\n\n`scry`\n\nis the introspection family (Old English: *to perceive, to discern*). Every trace-reading command honors `$GALDOR_DB`\n\nand `~/.galdor/traces.db`\n\nas fallback paths.\n\nStart 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.\n\n— install → first ReAct agent → first tool → first traced run, in 15 minutes`docs/quickstart.md`\n\n— one page per package (provider, schema, tool, graph, agent, memory, observability, council, mcp, a2a, eval, replay, spellbook)`docs/concepts/`\n\n— RAG, multi-agent, human-in-the-loop, cost tracking, MCP server, replay-driven tests`docs/patterns/`\n\n— coming from another framework? side-by-side translations`docs/migration/`\n\n— deployment shapes, trace store retention, exporting to your OTel pipeline`docs/ops.md`\n\n— runtime overhead, throughput numbers, sizing guidance`docs/benchmarks.md`\n\n— automated tooling, accepted findings, OWASP LLM Top 10 self-assessment`docs/security.md`\n\n— architectural decision records`docs/adr/`\n\n— module map and design invariants`ARCHITECTURE.md`\n\n— phase-by-phase delivery tracker`ROADMAP.md`\n\n— how decisions get made`GOVERNANCE.md`\n\n— how to send patches`CONTRIBUTING.md`\n\n[godoc reference](https://pkg.go.dev/github.com/YasserCR/galdor)— API surface\n\ngaldor uses the [Developer Certificate of Origin (DCO)](/YasserCR/galdor/blob/main/DCO.txt) — every commit must be signed off:\n\n```\ngit commit -s -m \"...\"\n```\n\nPRs welcome. We don't require a CLA. See [ CONTRIBUTING.md](/YasserCR/galdor/blob/main/CONTRIBUTING.md) for the dev loop.\n\ngaldor 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).\n\ngaldor 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.\n\nApache 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.\n\n*\"The incantation framework for Go agents.\"*", "url": "https://wpnews.pro/news/galdor-a-go-llm-agent-framework-with-built-in-tracing-and-replay", "canonical_source": "https://github.com/YasserCR/galdor", "published_at": "2026-06-13 19:04:09+00:00", "updated_at": "2026-06-13 19:16:54.322057+00:00", "lang": "en", "topics": ["ai-agents", "developer-tools", "artificial-intelligence", "ai-infrastructure", "mlops"], "entities": ["Galdor", "LangChain", "LangSmith", "Eino", "Genkit", "OpenTelemetry", "MCP", "A2A"], "alternates": {"html": "https://wpnews.pro/news/galdor-a-go-llm-agent-framework-with-built-in-tracing-and-replay", "markdown": "https://wpnews.pro/news/galdor-a-go-llm-agent-framework-with-built-in-tracing-and-replay.md", "text": "https://wpnews.pro/news/galdor-a-go-llm-agent-framework-with-built-in-tracing-and-replay.txt", "jsonld": "https://wpnews.pro/news/galdor-a-go-llm-agent-framework-with-built-in-tracing-and-replay.jsonld"}}