dify
Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
- 162k
- Python
- 8 h ago
Dispatch less. Deliver more. Multi-agent dispatch governance for reliable delivery.
Repo cablate/baton, read from GitHub 1 min ago. cablate has not joined Take My Repo.
cablate/baton is a public repo on GitHub by cablate. Dispatch less. Deliver more. Multi-agent dispatch governance for reliable delivery. It declares the MIT license on GitHub. It has 67 stars and last changed on 2026-07-16. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-21.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
English | 繁體中文
Dispatch less. Deliver more.
A governance skill for deciding whether to delegate, how to divide the work, how far to parallelize, and how to bring the result back under control.
Install Baton · Run the smoke tests · Benchmark protocol · Trust & security · Changelog
More agents do not automatically mean faster delivery.
Subagents often reread the same documents and code, only to perform slightly different work. That means duplicated tokens, overlapping writes, repeated verification, and more results for the main agent to reconcile.
Baton makes an AI answer the important questions before delegation: Is delegation worth the cost? Which work can safely run in parallel? Which context should be shared? Who owns each write, verification step, and final decision?
Baton does not help an AI dispatch more agents. It helps every dispatch earn its cost.
Technically, Baton adds a dispatch control plane above subagents, workflows, agent teams, worktrees, and code-intelligence tools. It guides the AI toward the smallest reliable execution structure, then applies context boundaries, artifact ownership, stop conditions, centralized verification, and final synthesis.
It is not a swarm framework. It is the judgment layer that prevents a swarm from becoming the default answer to every large-looking task.
Star this repository if your agents can already spawn workers but still need better judgment about when, where, and how to use them. Fork it when you want to encode your own platform limits, review gates, ownership rules, or workflow adapters without rebuilding the dispatch model from scratch.
There is no honest universal multiplier. The impact ranges from negligible on a task that was already well scoped to run-saving when an ungoverned workflow would have produced conflicts, retry cascades, or results too expensive to verify.
The strongest published boundary condition comes from Anthropic: multi-agent systems can outperform a single agent on highly parallel research, but Anthropic reports roughly 15× the token use of ordinary chat interactions and warns that heavily shared context and inter-agent dependencies are poor fits. This skill is designed to protect that large coordination investment.
Think of total execution cost as:
useful work
+ repeated context reconstruction
+ coordination and handoffs
+ duplicated verification
+ conflict rework
+ failed retries
+ synthesis debt
The skill cannot make the useful work disappear. Its job is to reduce the other six terms—and to refuse multi-agent execution when those terms would exceed the benefit.
These are operational models, not benchmark claims:
| Scenario | Without dispatch governance | With this skill | Practical difference |
|---|---|---|---|
| Known one-file fix | Investigator → builder → verifier, each rebuilding context | Main agent edits and runs one focused check | Avoids unnecessary cold starts, handoffs, and review overhead |
| Multi-surface refactor | Builders independently discover architecture and collide on shared types, registries, or lockfiles | Shared contract converges first; each artifact has one owner; integration gate runs once | Often the difference between clean parallel progress and conflict-driven rework |
| Large homogeneous audit or migration | Item count becomes agent count; strict output failures and rate limits amplify retries | Representative small slice → bounded batches → explicit failure threshold → centralized synthesis | Often the difference between a controllable run and an expensive result set that cannot be trusted |
Measure the same task twice and compare:
Expected direction:
That last point matters: this repository is not claiming that every multi-agent task becomes faster. It makes the decision auditable enough to discover when multi-agent execution is actually worth its cost.
Benchmark status: the first reproducible protocol is published, but paired trials have not yet been run. Baton does not claim a measured savings percentage until raw evidence exists. See benchmarks/.
Most agent platforms are optimized to answer:
How can I run multiple agents?
The harder operational question is:
Should this task use multiple agents at all—and if so, what is the minimum reliable design?
Without an explicit dispatch policy, capable agents repeatedly fall into the same traps:
Anthropic's published multi-agent research is unusually candid about this tradeoff: its multi-agent research system achieved major quality gains on highly parallel research, but used roughly 15× the tokens of ordinary chat interactions, and Anthropic notes that tasks with heavily shared context or inter-agent dependencies are poor fits. The lesson is not “avoid multi-agent systems.” It is “spend that coordination budget only where the task shape earns it.”
User request
│
▼
Dispatch brake
├── Is the outcome clear?
├── Is direct execution cheaper?
├── Are workstreams genuinely independent?
├── Can writes have exclusive owners?
└── Who integrates and verifies?
│
▼
Smallest useful primitive
├── main agent
├── one worker
├── bounded parallel workers
├── batch / workflow
├── collaborative team
├── isolated workspace
└── shared-workspace builders
│
▼
Context pack → ownership → briefs → monitored execution
│
▼
Main-agent synthesis → centralized verification → honest evidence
The result is a behavioral change:
| Without this skill | With this skill |
|---|---|
| “This is large; spawn more agents.” | “Which parts are independent enough to justify delegation?” |
| Every worker reconstructs the project | Shared conclusions are curated once and referenced narrowly |
| Work is divided by vague roles | Work is divided by sources, artifacts, and ownership |
| Parallelism follows item count | Parallelism follows independence and integration capacity |
| Builders verify everything independently | Local checks stay local; expensive gates run centrally |
| Reports are concatenated | Conflicts are adjudicated and coverage gaps remain visible |
| Failure triggers more retries | Same-cause failure changes the design or falls back to direct work |
The ecosystem already has excellent orchestration mechanisms:
Those systems primarily provide execution primitives. Baton sits one level above them:
| Concern | Orchestration frameworks | This skill |
|---|---|---|
| Run agents, routes, graphs, or flows | Primary strength | Uses what is available |
| Decide whether delegation is economically justified | Usually application-defined | Core responsibility |
| Measure shared-context overlap before fan-out | Sometimes supported | Required decision |
| Assign exclusive artifact ownership | Usually application-defined | Required for writes |
| Centralize verification based on cost | Usually application-defined | Explicit policy |
| Detect integration backlog as a stop signal | Runtime-dependent | Global invariant |
| Preserve failed and minority results in synthesis | Implementation-dependent | Explicit reporting rule |
| Fall back cleanly when orchestration fails | Application-dependent | Mandatory exit |
The advantage is composability: this skill does not compete with an agent runtime. It improves the decisions made before and during runtime use.
Before fan-out, require five answers:
If an answer is missing, clarify, scout, converge the shared contract, or design ownership first.
| Task shape | Preferred primitive |
|---|---|
| Small task, final judgment, synthesis | Main agent |
| Bounded scouting or independent validation | One worker |
| A few low-overlap perspectives or surfaces | Bounded parallel workers |
| Repeated homogeneous items | Batch or workflow |
| Workers must challenge or coordinate | Collaborative team |
| Competing or overlapping implementations | Isolated workspace or branch |
| Shared uncommitted state, disjoint writes | Shared-workspace builders |
For work with shared background, create a compact context pack containing conclusions, constraints, rejected directions, and minimum reading sets. For write tasks, create an ownership map that names allowed and forbidden artifacts—including secondary writes such as indexes, generated files, configuration, and lockfiles.
Workers produce scoped changes or findings. The main agent checks ownership, samples evidence, adjudicates contradictions, and runs integration-wide verification once. Results are classified as:
Every delegated phase stops on success, budget exhaustion, repeated no-progress, same-cause failure, invalid ownership boundaries, or integration cost exceeding remaining benefit.
The core skill is platform-neutral. Adapters are loaded only when relevant.
The Ultracode adapter improves workflow use without freezing this skill to a particular Claude Code version. It requires current-capability discovery, a representative small-slice trial, bounded batches, phase boundaries, stop conditions, explicit treatment of partial results, and a direct-execution fallback.
This is especially valuable when “Ultracode” would otherwise be interpreted as permission to maximize fan-out.
The CodeGraph adapter uses repository-graph evidence at three points:
CodeGraph improves the evidence available to the dispatcher. It does not replace source verification or artifact ownership.
For the safest path, ask your agent to inspect the versioned runbook, show an exact plan, and wait for approval before writing:
Read https://raw.githubusercontent.com/cablate/baton/v0.1.1/install/AGENT-INSTALL.md
and prepare a plan to install Baton as $baton-dispatch.
Inspect my current skill directories first. Do not overwrite existing files.
Show the source, destination, changed files, non-changes, and verification steps.
Wait for my approval before writing anything.
The runbook is idempotent, refuses to overwrite modified or unrelated directories, and installs only one baton-dispatch skill directory. Review the exact installation manifest and trust boundary first.
Clone the tagged release into the skill directory used by your agent harness:
git clone --branch v0.1.1 --depth 1 https://github.com/cablate/baton.git baton-dispatch
Then place or link the cloned folder where your environment discovers SKILL.md packages. Common examples include a personal skills directory or a project-local skills directory. Exact discovery paths vary by product, so follow the current documentation for your harness.
The installable skill entrypoint is SKILL.md. Human-facing documentation such as this README is not required at runtime.
After installation, start a fresh session if your product caches skill discovery, then run the three smoke tests. To update, repeat the runbook with a newer tag after reviewing CHANGELOG.md. To remove Baton, follow UNINSTALL.md.
Invoke it explicitly when planning complex execution:
Use $baton-dispatch to decide whether this migration should
use direct execution, workers, a workflow, or isolated branches. Include
ownership, verification, synthesis, and stop conditions.
Other useful prompts:
Use $baton-dispatch before launching Ultracode. Start with
a small slice and show me the dispatch design.
Use $baton-dispatch with CodeGraph evidence to divide this
repository refactor without overlapping writes.
Use $baton-dispatch to audit this proposed multi-agent plan
for context duplication, verification waste, and integration risk.
.
├── SKILL.md
├── VERSION
├── agents/
│ └── openai.yaml
├── references/
├── dispatch-planning.md
├── context-and-briefs.md
├── execution-and-verification.md
├── examples.md
├── claude-code-ultracode.md
└── codegraph.md
├── install/
│ ├── AGENT-INSTALL.md
│ ├── MANIFEST.md
│ ├── SMOKE-TESTS.md
│ └── UNINSTALL.md
├── benchmarks/
└── docs/
This skill synthesizes recurring lessons from agent orchestration, context engineering, and production workflow systems. Recommended primary sources:
MIT © 2026 CabLate. See LICENSE.
cablate/baton is a public repo on GitHub by cablate. Dispatch less. Deliver more. Multi-agent dispatch governance for reliable delivery.
It declares the MIT license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-07-16. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
Reverse engineer anything with agents, from app behavior down to native binaries.

An MCP server plus a CLI tool that indexes local code into a graph database to provide context to AI assistants.
An open-source long-horizon SuperAgent harness that researches, codes, and creates. With the help of sandboxes, memories, tools, skill, subagents and message gateway, it handles different levels of tasks that could take minutes to hours.

18 Google Maps tools and 3 Agent Skills for place search, routes, travel planning, and local SEO—via MCP or standalone CLI.
巴逆逆(8zz)反指標追蹤器 — Facebook 抓取 + 影片轉錄 + AI 分析 + 多平台推送(Telegram / Discord / LINE)
Independent research on Claude Code internals, Claude Agent SDK, and related tooling.

An extension of Karpathy's LLM Wiki pattern: atom layer, topic-branches, two-layer Lint. Distilled from running the pattern end-to-end.
Claude Code mod: hands off to a fresh conversation when context fills up, keeps the cache warm while you're away, and turns what you teach Claude into project notes
Take My Repo has not tested this on your machine. Requirements come from the project's own documentation.
