Blades
A Go framework for composing multimodal agents from models, tools, memory, middleware, and workflows.
- Source repo
- go-kratos/blades
- Stars
- ★ 820
- Last updated
- 6mo ago
- License
- MIT
- Primary language
- Go
- FA score
- 37/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformOpenAI API
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- A Go backend team embedding an OpenAI-backed, multi-turn question-answering agent in an existing service.
- Not a fit if
- Teams wanting a ready-made chat app or CLI
- Users needing a standalone deployment or ops setup
- Teams requiring persistent memory and production config
- Source review
- 37/100 · Major gaps 3 safety controls not found
What does this agent do, and when should you use it?
Blades is a multimodal AI Agent framework for Go, not a separately hosted chat application. Its common Agent execution contract is Run(context.Context, *Invocation), which returns Generator[*Message, error], and Agent, Chain, and ModelProvider can be composed around that model. The framework exposes pluggable ModelProvider, Tool, Memory, and Middleware components, while flow coordinates multi-step reasoning and transfers data and control between Agents. Model output can be collected in full with Generate or consumed incrementally through NewStreaming; the supplied example runs an OpenAI-backed agent through Runner in application code. It fits teams building agent behavior inside Go services, but the README does not document a standalone deployment, CLI, or installation command.
An application creates a ModelProvider, such as openai.NewModel("gpt-5", openai.Config{APIKey: os.Getenv("OPENAI_API_KEY")}), then creates an agent with blades.NewAgent plus WithModel and WithInstruction. The caller builds a blades.UserMessage, invokes blades.NewRunner(agent).Run(context.Background(), input), and reads Text() from the returned message. For extensions, Tool uses InputSchema and Handle to represent callable external capabilities; Memory saves and searches messages by session; Middleware adds behavior around Runner execution. Skills can be loaded with skills.NewFromDir("./skills") or skills.NewFromEmbed(embed.FS) and passed through WithSkills(...).
- A Go backend team embedding an OpenAI-backed, multi-turn question-answering agent in an existing service.
- A developer connecting several Agents or Chains into a multi-step reasoning workflow in a Go application.
- A team exposing database queries or API calls as model-callable functions with an InputSchema for invocation parameters.
- An application that needs session-scoped conversation memory so later turns can retain context.
- An engineering team adding logging, monitoring, authentication, or rate limiting around agent execution without changing Runner core logic.
How do you install or deploy this agent?
The README does not provide a copyable installation command, a required Go version, or module setup instructions, so an exact dependency-installation procedure is undocumented. The explicit prerequisites are a Go environment and, for the OpenAI example, OPENAI_API_KEY; the application must also be able to import github.com/go-kratos/blades and github.com/go-kratos/blades/contrib/openai.
How do you use this agent?
In a Go program, read OPENAI_API_KEY and create openai.NewModel("gpt-5", openai.Config{APIKey: os.Getenv("OPENAI_API_KEY")}). Create an agent with blades.NewAgent("Blades Agent", blades.WithModel(model), blades.WithInstruction("You are a helpful assistant that provides detailed and accurate information.")). Build input with blades.UserMessage("What is the capital of France?"), then run runner := blades.NewRunner(agent) followed by runner.Run(context.Background(), input). After checking err, call output.Text() to obtain the text response.
What are this agent's strengths and limitations?
- A shared Agent interface and Generator-based output model connect Agent, Chain, and ModelProvider as composable execution units.
- The ModelProvider abstraction is explicitly pluggable, with OpenAI, DeepSeek, and Gemini named as services it can integrate.
- It combines tools, session memory, streaming generation, and middleware for Go applications that need agent capabilities.
- Skills can be loaded from a directory or packaged into the binary with embed.FS.
- The README lacks installation commands, a Go version, module-version guidance, and a standalone deployment path, leaving initial project setup to adopters.
- The OpenAI example requires network access and OPENAI_API_KEY; cost and availability depend on the chosen model provider.
- Persistent and more advanced memory strategies are left to extensions; the README explicitly identifies only an InMemory implementation.
- No CLI, HTTP service surface, or production operations configuration is shown, so adopters must define the application boundary themselves.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Blades This agent | 37 · Major gaps | FrameworkFree + model costs | ★ 820 | 6mo ago | Go | OpenAI API |
| Agently AI Application Runtime | 64 · Some gaps | Library / SDKFree + model costs | ★ 1.7k | 26d ago | Python | OpenAI API · Claude API |
| Dynamiq Agent Orchestration | 61 · Some gaps | Library / SDKFree + model costs | ★ 1.1k | 3d ago | Python | OpenAI API |
| DSPy-Go | 44 · Major gaps | CLIFree + model costs | ★ 203 | 6d ago | Go | OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
The README describes tools that can call APIs, databases, and file systems, but gives no permission limits, call confirmation, or rollback procedure, so least privilege, user confirmation, and rollback score low. The example reads an OpenAI key from an environment variable, offering limited data-flow guidance; broader sensitive-data handling and dependency-security practices are not shown. The README describes the main components and uses, but source attribution is limited; publisher identity and a maintainer update path are not verifiable here.
The README, AGENTS.md, and Go workflow all point to multi-module Go builds and tests, but README descriptions of Agent, Chain, and Flow overlap, and the provided examples do not establish full consistency across claims. go.mod pins direct dependency versions, but no transitive lock or dependency-security handling is shown. The example returns and logs runtime errors, while framework-level failure modes and user-facing error guidance remain thin.
The README clearly targets Go developers and names scenarios such as multi-turn conversation, structured output, pluggable models, tools, memory, and middleware. It also says tools can access external systems without defining boundaries, permissions, or conditions of use; the weather skill gives concrete trigger steps. The materials specify Go 1.25 but provide little guidance on deployment, runtime, or other environment requirements.
The README is organized around architecture, concepts, quick start, skills, and contribution, with code examples, but it lacks user installation steps and an FAQ, and some concept sections repeat. The LICENSE states the MIT terms. No changelog is included in the provided files; AGENTS.md is contributor guidance with development and test procedures, but does not establish product maintenance responsibility or a user-facing support and update path.
The chat-agent and skill examples make usage understandable, and the framework's model, tool, memory, and workflow abstractions show practical value. Cost-benefit guidance is limited: the documentation does not discuss resource use, external-service costs, or operating constraints.
The README's main capability claims can be associated with interface snippets and examples, though many remain descriptive assertions. AGENTS.md and the CI workflow provide limited corroboration of multi-module build and test procedures; static materials contain no run results, so execution correctness is not assessed. The files do not systematically distinguish implemented behavior from aspirational claims.
- Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
- Not found in source: dependency securityPin versions and run a dependency audit (npm audit, pip-audit) before installing; prefer running it in a container.
- Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
- Tools can access file systems, databases, and APIs; integrating applications should define allowed permissions and review each tool's side effects.
- The example stores the API key in an environment variable; the materials do not explain how sensitive data is handled in logs, memory, or model requests.
- The README describes the project as early-stage and iterating rapidly, while the provided materials include no changelog or clear maintainer contact path.
Maintain this project? Add the FARS badge to your README
[](https://followagents.com/en/agents/blades)<a href="https://followagents.com/en/agents/blades"><img src="https://followagents.com/badge/blades.svg" alt="FARS review"></a>Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
Release notes excerpt
🎉 Release v0.5.0 This release introduces context management and loop tool support, enhances metadata handling and cache control, and includes various optimizations and fixes. What's Changed - Features: - Add recipe feat by @longXboy in [#203](https://github.com/go-kratos/blades/pull/203) - Add context control option and stateless mode by @tonybase in [#223](https://github.com/go-kratos/blades/pull/223) - Add loop execution mode support to recipe by @tonybase in [#221](https://github.com/go-kratos/blades/pull/221) …View on GitHub ↗ -
Release notes excerpt
🎉 Release v0.4.0 This release introduces middleware support for agents and skill injection capabilities, along with several important bug fixes and improvements. --- 🚀 What's Changed ✨ Features - feat(flow): allow adding middlewares as an option to DeepAgent and RoutingAgent (#188) — thanks @yuchanns - feat(skills): add skill injection support for agents (#192) — thanks @tonybase - feat(example): add Claude weather example (#194) — thanks @tonybase 🐛 Bug Fixes - fix(contrib): correct assistant role mapping and improve error handling (#191) — thanks @tonybase …View on GitHub ↗ -
Release notes excerpt
What's Changed * trying to marshal unsupported type func() *github.com/google/jsonsc… by @TomYang1024 in https://github.com/go-kratos/blades/pull/179 * r.Evaluate undefined (type evaluate.Evaluator has no field or method by @TomYang1024 in https://github.com/go-kratos/blades/pull/178 * fix token usage zero issue for streaming mode of openai model by @jayn1985 in https://github.com/go-kratos/blades/pull/180 * feat(example): add image-to-text example and update message parts API by @tonybase in https://github.com/go-kratos/blades/pull/181 …View on GitHub ↗
FAQ
Can I deploy it directly as a chat service?
Is it limited to OpenAI?
What credential does the OpenAI example require?
How is conversation context retained?
Thanks — we use this to improve the page.