What makes tool-economy notable?

2.5K downloads. Trust evidence available

How should tool-economy be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

tool-economy

Minimize tool call overhead. Every tool call costs tokens and latency. This skill teaches agents to batch independent calls, avoid redundant reads, cache results within a session, prefer single powerful commands over multiple weak ones, and track a 'tool budget'.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

2.5k

Updated

Oct 9, 2026

Version

0.1.1

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 2.5K downloads reported by the source. Last updated 10/9/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 9, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 9, 2026
Adoption signal: 2.5K downloadsadoption · observed Oct 9, 2026
Latest release: 0.1.1release · observed Aug 11, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17b6amkd3wzqgg640v03a9r1n83gxs1:tool-economy

Install using `clawhub skill install s17b6amkd3wzqgg640v03a9r1n83gxs1:tool-economy` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/voronindenis5/tool-economy before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-voronindenis5-tool-economy/snapshot"

Documentation

CLAWHUB

43,603 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: tool-economy
description: >
  Minimize tool call overhead. Every tool call costs tokens and latency.
  This skill teaches agents to batch independent calls, avoid redundant
  reads, cache results within a session, prefer single powerful commands
  over multiple weak ones, and track a 'tool budget'.
version: 1.0.0
author: Denis Voronin
license: MIT
tags:
  - efficiency
  - optimization
  - tool-use
  - cost
  - latency
  - agent
---

# Tool Economy

> Every tool call is an expense. Spend wisely.

`Tool Economy` is a discipline for AI agents: treat each tool invocation as a
costed operation (tokens + latency) and minimize total overhead while preserving
correctness. The goal is not to avoid tool use — it is to make every call count.

## When to Use

Activate this skill whenever you are:

- About to issue multiple tool calls in a single turn
- Reading files or data you may have already read this session
- Considering whether to call a tool at all
- Planning a multi-step workflow where calls can be parallelized
- Reviewing your own agent behavior for efficiency

## Core Principles

### 1. Batch Independent Calls

If two or more tool calls do not depend on each other's output, issue them in the
**same turn** (parallel). Do not serialize calls that could run concurrently.

**Bad** (3 serial round-trips, 3x latency):
```
read_file(A)  -> wait
read_file(B)  -> wait
read_file(C)  -> wait
```

**Good** (1 round-trip, 1x latency):
```
[ read_file(A), read_file(B), read_file(C) ]   # one turn
```

See `references/batching.md`.

### 2. Avoid Redundant Reads

If you already read a file this session and it has not changed, **do not read it
again**. Track what you have seen. Prefer `session_search` or in-context memory
over a fresh fetch. If a file was modified by your own action, you already know
its new state — patch in place, don't re-read.

### 3. Cache Within Session

Treat the current session as a short-lived cache. The first expensive query
(search, web fetch, build) populates it; subsequent identical needs reuse it.
This does not mean stale data — invalidate when the underlying source changes
(e.g. you edited the file you previously read).

### 4. Prefer One Powerful Command Over Many Weak Ones

- `read_file` over a chain of `cat`, `head`, `tail`
- `search_files` (content mode) over manual `grep` + `find` + `wc`
- A single `patch` over `sed` + `awk` + redirect
- One `web_extract` with 5 URLs over 5 separate fetches
- `gh repo clone` over manually `git init` + `git remote add` + `git pull`

Each "weak" command adds a full round-trip of tokens + latency for a sub-result
you could have gotten in one call.

### 5. Track a Tool Budget

Before a multi-step task, estimate how many calls it *should* take, and compare
against reality during and after. The companion script
`scripts/analyze_session.py` computes:

- **Total calls** and **redundant calls** (duplicates within a window)
- **Serializable-but-parallel calls** (independent calls you issued seria

README.md

# Tool Economy

> Every tool call is an expense. Spend wisely.

A [Hermes Agent](https://hermes-agent.nousresearch.com/docs) / OpenClaw skill that
teaches AI agents to **minimize tool-call overhead** — tokens and latency —
without sacrificing correctness.

## Why

Every tool invocation costs:

- **Tokens** — the call's arguments and its full result travel through context.
- **Latency** — each call is at least one network/compute round-trip.
- **Reasoning overhead** — serial calls force extra planning turns between them.

Wasteful patterns (re-reading files, serializing independent calls, chaining weak
commands) compound quickly. `Tool Economy` gives the agent a discipline and a
measurable score so it can self-correct.

## What's Included

- **`SKILL.md`** — the core skill: principles, checklist, quick-reference table.
- **`references/`**
  - `batching.md` — how and when to parallelize independent tool calls.
  - `budgeting.md` — estimating, tracking, and reconciling a tool budget.
  - `antipatterns.md` — catalog of 10 wasteful patterns and their fixes.
- **`scripts/analyze_session.py`** — analyze a session log and report:
  - total / redundant calls
  - serializable-but-parallel (missed batching) calls
  - estimated overhead (extra round-trips × latency)
  - a **tool economy score** (0–100)
- **`scripts/sample_session.json`** — example input for the analyzer.

## Quick Start

```bash
# Analyze a session log
python3 scripts/analyze_session.py scripts/sample_session.json
```

Example output:

```
Tool Economy Report
===================
Total tool calls              : 12
Redundant calls               : 2
Missed parallel opportunities : 3
Estimated extra round-trips   : 5
Estimated overhead            : 1500 ms
Tool economy score            : 58/100  [Fair]

Top waste sources:
  1. redundant_read        x2   (~600 ms)
  2. missed_batching       x3   (~900 ms)
```

## Session Log Format

The analyzer accepts a JSON array of tool-call records:

```json
[
  {
    "turn": 1,
    "tool": "read_file",
    "args": {"path": "src/main.py"},
    "calls_in_turn": 1
  },
  ...
]
```

Only `tool` and `args` are required; `turn` and `calls_in_turn` are used for
missed-batching detection (see `scripts/analyze_session.py --help`).

## Installation (Hermes Agent)

Copy or symlink this directory into your skills folder:

```bash
cp -r tool-economy ~/.hermes/skills/
```

Hermes auto-discovers skills with a valid `SKILL.md`. See the
[skills docs](https://hermes-agent.nousresearch.com/docs) for details.

## Principles (TL;DR)

1. **Batch** independent calls into one turn.
2. **Don't re-read** what's already in context.
3. **Cache** expensive results for the session.
4. **Prefer one strong command** over a chain of weak ones.
5. **Track a tool budget** and replan when over.

## License

MIT © Denis Voronin

_meta.json

{
  "ownerId": "kn75wwn4x6djaf28jbykeamazd81gtdp",
  "slug": "tool-economy",
  "version": "0.1.1",
  "publishedAt": 1786449527623
}

references/antipatterns.md

# Anti-Patterns Catalog

Common ways agents waste tool budget, and the economy pattern that replaces each.

---

## AP-1: Serial Cascade of Independent Reads

**Symptom:** Three `read_file` calls in three separate turns.

**Cost:** 2 extra round-trips of latency + 2 extra reasoning passes.

**Fix:** Batch into one turn. See `batching.md`.

---

## AP-2: Re-Reading a Static File

**Symptom:** `read_file(config.yaml)` in turn 3, again in turn 7, with no edit
in between.

**Cost:** 1 redundant call (tokens + latency) for stale-identical data.

**Fix:** Reuse the content already in context. Re-read only after the file is
known to have changed (e.g. you patched it, or an external mtime check differs).

---

## AP-3: Weak Command Chains

**Symptom:**
```
terminal("grep -rn foo .")
terminal("grep -rn foo . | wc -l")
terminal("find . -name '*.py'")
```

**Cost:** 3 calls for what one `search_files` call returns.

**Fix:** Use the powerful built-in:
```
search_files("foo", target=content, output_mode=count)
```

---

## AP-4: Read-Then-Patch-Then-Read

**Symptom:** Read a file, patch one line, then read the whole file again to
"verify."

**Cost:** 1 redundant full-file read. The patch result already tells you the new
content.

**Fix:** Trust the patch output (or diff). Re-read only a *specific* region if
you must confirm layout, not the whole file.

---

## AP-5: Exploratory Ping-Pong

**Symptom:** Alternating `search_files` → `read_file` → `search_files` →
`read_file` across many turns without a plan.

**Cost:** Many small calls, high latency, low signal.

**Fix:** Do a single broad search (or a batched set of searches) up front, then
batch-read the relevant files, then act. Plan the exploration before executing.

---

## AP-6: Re-Fetching External Data

**Symptom:** `web_extract(url)` called twice for the same URL in one session.

**Cost:** Network latency + tokens for identical content.

**Fix:** Cache the result in context. Re-fetch only if the source is
time-sensitive (news, prices, live status) and enough time has passed.

---

## AP-7: Confirm-Then-Do

**Symptom:**
```
T1: terminal("ls")           # "is the file there?"
T2: terminal("cat file")     # "ok read it"
```

**Cost:** 1 extra call to confirm something the actual operation would have
reported anyway.

**Fix:** Just attempt the real operation; handle the error if it fails. Most
tools return clear errors for missing files/paths.

---

## AP-8: Forgetting `replace_all`

**Symptom:** Five separate `patch` calls to rename one identifier in five spots.

**Cost:** 4 extra calls.

**Fix:** One `patch(..., replace_all=true)` or a single targeted sed via
`terminal`.

---

## AP-9: Human-Style Click-Through

**Symptom:** Navigating a browser one click at a time when a direct URL or API
call would do.

**Cost:** Many slow browser round-trips.

**Fix:** Prefer `web_extract` / direct API / direct URL navigation over
incremental UI clicks.

---

## AP-10: No Budget, No Awareness

**Symptom:** Agent never

references/batching.md

# Batching Independent Tool Calls

The single highest-impact economy technique: **issue independent calls in the
same turn.** Most agent runtimes execute independent tool calls concurrently, so
batching collapses N round-trips into one.

## What "Independent" Means

Call B is *independent* of call A if B does not need A's output to be formed.
You can write out all N calls before seeing any result.

| Independent (batch)             | Dependent (serial)                          |
|---------------------------------|---------------------------------------------|
| Read 3 unrelated files          | Read file → patch line found in it          |
| Fetch 5 URLs                    | Search web → extract top result             |
| Run tests + lint + typecheck    | Read config → run build with that config    |
| `git status` + `git log` + `git diff` | `git add` → `git commit` → `git push` |

## How to Batch

1. Scan your planned next steps.
2. Partition into "rounds": each round contains calls whose inputs are already
   known.
3. Issue each round as a single assistant turn with multiple tool calls.

### Example: Inspecting a Repo Before a Change

**Wasteful (5 serial turns):**
```
T1: read_file(package.json)
T2: read_file(tsconfig.json)
T3: search_files("TODO", target=content)
T4: terminal("git log --oneline -5")
T5: search_files("*.test.ts", target=files)
```

**Economical (1 turn, 5 parallel calls):**
```
T1: [ read_file(package.json),
      read_file(tsconfig.json),
      search_files("TODO"),
      terminal("git log --oneline -5"),
      search_files("*.test.ts", target=files) ]
```

Same information, ~5× lower wall-clock latency, same token cost for the calls
themselves (but far fewer reasoning tokens between turns).

## Pitfalls

- **False independence:** if call B's *arguments* depend on call A's result, you
  cannot batch them. Re-check each pair.
- **Resource contention:** two heavy `terminal` builds may fight for CPU. Stagger
  if needed, but most read-only calls (file reads, searches, web fetches) are
  safe to parallelize freely.
- **Token budget per turn:** batching more calls grows the single response. If a
  batch would be enormous, split into a few medium rounds rather than one huge
  turn.

## Rule of Thumb

> If you can write all the calls before any of them returns, they belong in the
> same turn.

Github ReposUpdated 6h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.