Agentic Flow: five CLIs, 213 MCP tools, and version numbers that go backwards
Easily switch between alternative low-cost AI models in Claude Code/Agent SDK. For those comfortable using Claude agents and commands, it lets you take what you've created and deploy fully hosted agents for real business purposes. Use Claude Code to get the agent working, then deploy it in your favorite cloud.
At a glance
- What is it?
- A TypeScript orchestration platform for Claude Code built around pretraining hooks, keyword-triggered background workers and agent routing. The feature surface is large and the numbers are self-contradictory in useful ways, which is what this article is about.
- Who is it for?
- Agentic Flow fits someone already living in Claude Code who wants routing metrics and background workers rather than hand-rolled dispatch logic, and the hooks system is the part most likely to pay for the setup time. Skip it if you need a small, stable dependency, because the version numbers move backwards and the agent count is quoted two ways.
- Can I use it commercially?
- Not without permission. GitHub finds no licence file in the repository, and without a licence all rights are reserved by default: you may read the code but not reuse it. Check the README, or ask the authors, before using it.
- Is it still maintained?
- Yes. The repository last received commits 4 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- ruvnet/agentic-flow844 ★ · +32
| Repository | 2026-09-21 | 2026-11-15 |
|---|---|---|
| ruvnet/agentic-flow | 812 | 844 |
32 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Sixty-six agents in the headline, eighty-plus in the quick start
Start with the numbers, because they are where this project is least consistent. The headline calls it production-ready orchestration with 66 self-learning agents, 213 MCP tools and autonomous multi-agent swarms. A dozen lines later, the quick start says your project now has 80 or more specialized agents. Later still, a section heading returns to 66. Two of those three figures are describing the same thing.
The quick start itself is three commands:
# 1. Initialize your project
npx agentic-flow init
# 2. Bootstrap intelligence from your codebase
npx agentic-flow hooks pretrain
# 3. Start Claude Code with self-learning hooks
claudeThe middle command is the interesting one. Pretraining reads your codebase before any agent runs, which is the mechanism behind the routing quality claims: the agents are not routing into a void, they are routing against patterns extracted from your own repository.
The rest of the command surface is small and legible. `hooks route` sends a task to an agent, `hooks metrics` shows learning metrics, `workers dispatch` fires a background worker, and `mcp start` runs the MCP server for Claude Code. The background workers are triggered by keywords such as ultralearn, optimize and audit, which is a blunt but effective way to expose an escape hatch without a config file.
Five command line binaries ship from one package
The package manifest is where the real surface area shows. One npm package installs five executables, and they cover four different tools.
The main one is `agentic-flow`, whose entry point is a CLI proxy script rather than the library itself. There is a separate `agentdb` binary for the database CLI, a separate billing CLI named `ajj-billing`, and then two names for the same Jujutsu integration, `agentic-jujutsu` and `jj-agent`, both pointing at one script in a package directory. Two aliases for one binary is the kind of detail that appears when something is being adopted under more than one name.
The exports map is more careful than the bin list. Beyond the root entry, there are wrapper subpaths for the GNN layer, a fast database wrapper, attention fallbacks and an embedding service, plus router, agent-booster and transpiler entries. The reasoning bank export carries a conditional: a Node implementation for the server and a WASM adapter for the browser. That is a deliberate design choice rather than an accident, since the learning memory is the one component that has to run on both sides.
The manifest version is `2.0.2-alpha`, and the module is ESM with type definitions shipped alongside the entry point.
The newest tag is a lower version number than two earlier ones
Here is the release history as published: v2.3.5 and v2.3.6 both on 2025-11-24, then v2.1.3 on 2026-09-16. The most recent tag is numerically lower than two tags published before it.
So the repository has three different version claims in play at once. The README describes v2. The manifest says 2.0.2-alpha. The newest published tag says 2.1.3. There is no way to infer one from the others, and anyone pinning by caret or by dist-tag will get something different from what the README implies.
The content of that newest tag is at least informative about what was changing: it is described as a Windows fix, cleaner local model routing, and Jujutsu compatibility. So the tag numbering looks like it is tracking a branch rather than a line, which is consistent with a project carrying several parallel lines of work.
The last push to the default branch was 2026-09-16, the same day as that tag, so the branch and its newest tag are in sync even though the numbering is not monotonic.
For a package with 178 forks and 112 open issues, that combination, active work plus inconsistent versioning, is a normal early-stage state and an argument for pinning exactly rather than trusting the newest version.
Routing returns an agent name and a confidence percentage
The library API is three calls long, which is worth showing because it defines the contract everything else depends on. You construct the flow, initialize it, then route a task string. What comes back is an agent name and a confidence percentage, so the routing decision is inspectable rather than hidden behind a log line.
That inspection point is what makes the learning story meaningful. If routing tells you it picked an agent with 62 percent confidence, you can look at the metrics and find out why. The same reasoning applies to the router's model selection, which is described as quality-aware with scores in the 0.8 to 0.95 range, budget constraints and fallback handling, choosing between two model tiers rather than always using the larger one.
The cost claim attached to that is concrete: the README states a move from 720 dollars a month to 288 dollars a month, framed as 60 percent savings. Treat it as the project's figure rather than a measured result, because no protocol is given for it.
Quality claims are split by profile, and the spread is instructive. Five profiles are offered, from a real-time one at 2200 operations per second and under 0.5 milliseconds, to a research profile with a 55 percent quality improvement. Per-domain gains listed alongside are much smaller: code plus 5 percent, creative writing plus 4.3, reasoning plus 3.6, chat plus 2.1, math plus 1.2. The large headline number belongs to a specific profile, not to the default one.
Pretraining hooks turn a codebase into routing signal
The self-learning claim rests on one hook and one memory store.
Pretraining scans the codebase and builds what the project calls patterns. From there, specialized agents are described as learning from past successes and failures through a reasoning bank, with the coder learning code patterns, the tester learning from test failures, the reviewer detecting issues by pattern, the planner assigning work by routing, and the researcher recognising patterns and synthesising from them.
Two mechanisms make the memory less local than it looks. Continual learning is claimed through EWC++ with a stated lambda range, which is the standard tool for stopping a small model from forgetting old tasks while it learns new ones, and the README claims cross-agent pattern sharing on top of it. The other is graph-enhanced retrieval, where a small graph neural network refines queries and is credited with a 12.4 percent recall improvement.
That last number deserves care. It is written as a target in one place and as an achieved improvement in another, and a three-layer GNN sitting in the retrieval path of every agent is a component that would be worth measuring yourself before believing either number.
The rest of the architecture is attention mechanisms: flash attention, multi-head, linear for long sequences, hyperbolic for hierarchical swarms, and mixture-of-experts routing, plus topology-aware position embeddings for the graph. Each is listed with a latency under 0.1 milliseconds.
A committed package tarball, database shards and ad-hoc benchmarks
The repository root is unusually crowded, and a few entries say more about the project's stage than any documentation would.
There is a packaged tarball sitting at the root, a version 1.10.0 archive, committed alongside a database shared-memory file for AgentDB. Both are build output, and both are in version control. There are also result directories for tests, test reports, validation logs, benchmark results and generated charts, plus several standalone performance scripts named for what they probe: GNN float32 performance, remaining GNN functions, typed-array GNN paths, agent booster overhead, and an all-fixes script. Test configuration files sit next to them, including one Jest config dedicated to a medical test suite.
Alongside that, the structured parts: a `packages/` directory, a `crates/` directory for Rust, a `reasoningbank/` directory, a `docker/` directory, `bench/` and `benchmarks/`, `docs/`, `plans/`, and `.gitmodules` for submodules. There is also a directory whose name is a theorem statement, and example scenarios for climate prediction, medical imaging, optimal deployment, peer-to-peer game content and protein-folding consensus, plus QUIC-based swarm coordination examples.
For a reader, the practical advice is that the README is a pitch document and the examples and `docs/` directories are the specification. Nothing here is a criticism of the maintainer; it is what an actively developed platform looks like when the working tree is committed alongside the product.
Benchmark figures arrive as targets, grades and speedup ranges
The performance section is a list of figures with three different rhetorical forms, and learning to tell them apart saves time.
Some are targets: GNN query refinement at plus 12.4 percent recall is labelled a target in one place and presented as a result elsewhere. Some are self-assessed grades: the database integration is marked performance grade A plus with a 100 percent pass rate, and the test count is given as 129 tests fully passing. Some are ranges against an unnamed baseline: flash attention at 2.49 times in a JavaScript runtime and 7.47 times through the native binding, with 50 to 75 percent memory reduction, and sparse attention claimed at 10 to 100 times.
The database claims have the most specific engineering detail, which is a good sign for them: graph partitioning credited with 50 to 80 percent memory reduction using named algorithms, a fused attention kernel reported at 40 times beyond its own 20 to 25 percent target, zero-copy work cutting allocations by 90 percent, a refactor from 782 lines into six classes of under 200 lines each, and WASM and NAPI binaries optimised to 730 KB. Those are checkable claims with a shape you could reproduce.
The self-optimising architecture figures are softer: sub-millisecond pattern retrieval described as 300 times faster, a specific operations-per-second number with SIMD, and an edge profile under 5MB.
One governance detail matters more than any of it. The README links an MIT licence badge, and the repository root contains no licence file. The published package metadata in the repository also does not name one in its visible fields. If you intend to reuse code from this project, resolve that before you copy anything.
Editorial conclusion
Agentic Flow fits someone already living in Claude Code who wants routing metrics and background workers rather than hand-rolled dispatch logic, and the hooks system is the part most likely to pay for the setup time. Skip it if you need a small, stable dependency, because the version numbers move backwards and the agent count is quoted two ways. Before depending on it, read the package rather than the README for the licence question, since the badge says MIT and the repository root has no licence file at all.
Frequently asked questions
what is agentic flow
Agentic Flow is a TypeScript orchestration platform for AI agents built with the Claude Agent SDK, with self-learning specialized agents, background workers and a large MCP tool surface. You drive it through the agentic-flow CLI, starting with npx agentic-flow init and a pretraining hook that reads your codebase.
how does agentic flow relate to MCP?
MCP is one of its output surfaces: the project claims 213 MCP tools for swarm coordination, and npx agentic-flow mcp start runs the MCP server that Claude Code connects to.
how does agentic flow differ from a fixed workflow
A fixed workflow is a sequence you write down. Agentic Flow routes each task to an agent at runtime, reports a confidence percentage for the choice, and dispatches background workers on keyword triggers, with metrics you can inspect afterwards.
what does agentic flow mean in ai terms
It describes systems where an LLM decides which specialised agent or tool handles a task rather than following a hard-coded path. Agentic Flow is one implementation of that idea, built around routing, self-learning hooks and multi-agent swarms.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/ruvnet-agentic-flow)Star history chart for your README
[](https://hysenlabs.com/projects/ruvnet-agentic-flow)Was this useful?