10x-Tool-Calls

10x-tool-calls · perrypixel/10x-Tool-Calls · ★ 863 · last commit 2025-06-11

Maximize the number of tasks accomplished within a single Cursor/Windsurf request by running a user-input loop between tasks.

Best whenTool-call quota optimization is as important as behavioral methodology for real-world AI coding productivity.

Skip ifUsing this with token-based pricing models

vs seeds

claude-conductor(Archetype 4: minimal markdown, zero primitives) but targets a different tool and a completely different value propositi…

Primitive shape

No installable primitives

Summary

10x-Tool-Calls

A minimal, conceptually clever "framework" consisting of two files: rules.md (an alwaysApply: true Cursor IDE rules file) and userinput.py (a 1-line Python script). The mechanism: instead of ending after a task, Claude runs python userinput.py to solicit the next instruction from the terminal, repeating the loop until the user types "stop." This converts one Cursor/Windsurf "request" (each allowing up to 25 tool calls) into an interactive multi-task session, maximizing tool-call quota utilization. The repo targets Cursor/Windsurf Agent Mode specifically (not Claude Code), and its primary value is tool-call efficiency, not behavioral methodology.

differs_from_seeds: This repo does not fit any of the 11 seed archetypes. It is not a command-pack, not a skills framework, not an MCP server, and not a spec-driven methodology. Its closest conceptual relative is claude-conductor (Archetype 4: markdown scaffold, zero primitives) but 10x-Tool-Calls is even simpler — 2 files, 1 behavioral rule, 1 Python script. The framework is unique in explicitly optimizing for quota utilization rather than behavioral quality.

Overview

Overview — 10x-Tool-Calls

Origin

Created by perrypixel. 863 stars, 138 forks. Last commit: 2025-06-11 (dormant). No license specified.

Philosophy (verbatim from README)

"10x-Tool-Calls is a simple rules setup designed for the Cursor IDE, Windsurf, or any other agent-based coding assistant that supports tool calls. It helps you get the maximum value out of your monthly tool call allowance by running your tasks in a loop with user input—without restarting the chat every time."

The quota math (verbatim from README)

"Most AI coding tools (like Cursor) offer 500 monthly requests, but each request can include up to 25 tool calls. Normally, even saying 'hi' uses up a full request, wasting potential.

With 10x-Tool-Calls:

You start with one request.

Inside that session, you can give multiple follow-ups.

All follow-ups run within the same request using available tool calls.

This means you get 10x (or more) actual work done using the same quota."

Important caveat (verbatim)

"Only use this setup with tools that offer a tool call–based quota, not token-based pricing (like OpenAI's pay-per-token). This setup is designed to maximize bundled tool calls, not minimize token usage."

Target tools

Cursor (Agent Mode), Windsurf, any agent-based coding assistant with tool-call quota model.

Architecture

Architecture — 10x-Tool-Calls

Distribution

Standalone GitHub repo. Manual file copy.

Install

# Step 1: Copy userinput.py to project root
cp Basic/userinput.py ./userinput.py

# Step 2: Copy rules.md to IDE rules location
# Cursor: paste into .cursorrules or project rules (set to "always")
# Windsurf: paste into equivalent rules file

Required runtime

Python 3 (for userinput.py)
Cursor Agent Mode or Windsurf Agent Mode

Directory tree

.
├── Basic/
│   ├── readme.md   (copy of README)
│   ├── rules.md    (the actual rules file)
│   └── userinput.py (1-line Python script)
└── readme.md

Target AI tools

Cursor (Agent Mode), Windsurf. Not Claude Code.

Config files

None. The rules file is pasted into the IDE's rules configuration directly.

Components

Components — 10x-Tool-Calls

Rules (1)

Basic/rules.md — an alwaysApply: true rules file with a single behavioral instruction: run python userinput.py after completing each task, read the user's input, act on it, repeat until "stop".

Scripts (1)

Basic/userinput.py — a 1-line Python script:

user_input = input("prompt: ")

Commands

None.

Skills

None.

Subagents

None.

Hooks

None.

MCP servers

None.

Templates

None.

Prompts

Prompts — 10x-Tool-Calls

Verbatim excerpt 1 — `Basic/rules.md` (the entire rules file)

---
description: 
globs: 
alwaysApply: true
---

### ✅ Task: Interactive Task Loop with User Feedback

1. **Check if `userinput.py` exists** in the root directory.

   * If it doesn't exist, create it with the following content:

     ```python
     # userinput.py
     user_input = input("prompt: ")
     ```

2. **Main Workflow**:

   * Perform your assigned tasks.

   * Run:

     ```bash
     python userinput.py
     ```
   * The terminal should be opened in the chat window itself.

   * Read the user's input.

   * Based on the input, perform the next set of tasks.

   * Repeat the process.

3. **Exit Condition**:

   * If the user enters `"stop"` when prompted, exit the loop and terminate the process.

Prompting technique: Numbered behavioral loop instruction with alwaysApply: true. This is the Cursor .cursorrules format — not a Claude Code slash command or skill. The alwaysApply: true YAML front matter makes this active on every single interaction. The prompting pattern is a minimal state machine with two states: execute→prompt or terminate.

Verbatim excerpt 2 — `Basic/userinput.py`

user_input = input("prompt: ")

Prompting technique: Not a prompt — this is the I/O bridge. The Python input() call is what enables bidirectional communication within a single "request." The AI runs this script to yield control back to the human.

Uniqueness

Uniqueness — 10x-Tool-Calls

differs_from_seeds

No close seed match. The 11 seeds are all behavioral methodology frameworks; 10x-Tool-Calls is a quota optimization trick. The closest archetype is claude-conductor (Archetype 4: markdown scaffold + zero primitives), but claude-conductor is for Claude Code while 10x-Tool-Calls is for Cursor/Windsurf. Against all seeds, this is categorically different: it ships no commands, no skills, no hooks, no agents — just 1 rules file and 1 Python script targeting a different pricing model (tool-call quota vs token-based).

Positioning

"Maximize your tool call quota." This is the only framework in the batch whose value proposition is entirely economic/operational rather than methodological. The 863 stars suggest real demand for this kind of quota optimization.

Observable failure modes

Dormant: last commit 2025-06-11. The quota model for Cursor/Windsurf may have changed.
Tool-call model dependency: only valid for IDEs with quota-based pricing; irrelevant for token-based pricing.
No persistent state: if Cursor disconnects mid-session, all context is lost.
2-file limit: has no capacity to evolve into a methodology framework.
Wrong target tool for this batch: this batch is "Claude Code / CC plugin frameworks" — 10x-Tool-Calls is Cursor/Windsurf only.

Workflow

Workflow — 10x-Tool-Calls

Phases

Phase	Description	Artifact
Setup	Copy files, configure IDE rules	Rules active in IDE
Task start	User sends initial message	AI completes task
Input prompt	AI runs `python userinput.py`	Terminal prompts "prompt: "
Continue	User types next instruction	AI continues
Exit	User types "stop"	Session ends

The loop (verbatim from rules.md)

1. Check if userinput.py exists in root directory
   - If not, create it: user_input = input("prompt: ")
2. Perform assigned tasks
3. Run: python userinput.py
4. Read the user's input
5. Based on input, perform next set of tasks
6. Repeat
7. Exit if user enters "stop"

Approval gates

Effectively every iteration — the python userinput.py prompt IS the approval gate, requiring explicit user input to continue.

Memory Context

Memory & Context — 10x-Tool-Calls

State storage

None. The conversation context within the single "request" is the only state.

Persistence

Session only (within one Cursor/Windsurf request). When the session ends (user types "stop" or quota is exhausted), all context is lost.

Compaction handling

Not applicable — this is a Cursor/Windsurf rules file, not a Claude Code framework.

Context handoff

None. The value proposition is staying within one request as long as possible, not persisting context across requests.

Orchestration

Orchestration — 10x-Tool-Calls

Multi-agent

No.

Orchestration pattern

None (it's an interactive loop, not an orchestration pattern).

Isolation mechanism

None.

Multi-model

No.

Execution mode

Interactive-loop (uniquely: within a single "request" that spans multiple tasks).

Consensus mechanism

None.

Prompt chaining

Yes in effect: each user input within the loop references the accumulated context of all prior tasks in the session.

Ui Cli Surface

UI/CLI Surface — 10x-Tool-Calls

Dedicated CLI binary

None.

Local web dashboard

None.

IDE integration

Cursor IDE (.cursorrules or project rules) and Windsurf (equivalent rules). Not Claude Code.

Observability

None.

Surface area

Two files. The UX is a prompt: terminal prompt shown in the Cursor Agent Mode chat window.

Related frameworks

same archetype · same primary tool · same memory type

BMAD-METHOD ★ 48k

A4 Markdown scaffold

Provides a full agile delivery lifecycle with named expert-persona AI collaborators that elicit the human's best thinking rather…

Agent OS ★ 4.6k

A4 Markdown scaffold

Extracts implicit codebase conventions into token-efficient markdown standards files and injects them selectively into AI agent…

Claude Conductor ★ 367

A4 Markdown scaffold

Gives Claude Code a persistent, cross-linked, auto-analyzed documentation system so it retains codebase context across sessions.

Spec-Driver (Greenfield Spec-Driven Development) ★ 25

A4 Markdown scaffold

Prevents spec rot in AI-assisted development by making implementation changes flow back into evergreen, authoritative specs via…

Anthropic Knowledge Work Plugins ★ 16k

A4 Markdown scaffold

Role-specialized plugin bundles with live MCP connectors that turn Claude into a domain expert for enterprise knowledge workers.

Codex Integration for Claude Code (skill-codex) ★ 1.3k

A4 Markdown scaffold

Single Claude Code skill that handles Codex CLI invocation correctly (stdin blocking, thinking token suppression, session resume)…

Distribution

Type: bash-script-bundle
Install: clone-and-configure
Version: unknown (last commit 2025-06-11)

Surfaces

CLI binary: No
CLI subcmds: 0
Local UI: No

Components

Commands: 0
Skills: 0
Subagents: 0
Hooks: 0
MCP servers: 0
MCP tools: 0
Scripts: 1
Templates: 1

Workflow

Phases: 4
Approval gates: 1
Spec format: none
Spec storage: none
Delta or full: none

Orchestration

Multi-agent: No
Pattern: none
Max concurrent: 1
Isolation: none
Consensus: none
Prompt chaining: Yes

Multi-model

Multi-model: No
BYOK: No
Modal: text

Execution

Mode: interactive-loop
Crash recovery: No
Compaction: No
Session handoff: No
Streaming: No

Memory

Type: none
Persistence: session
Search: none

Quality

TDD: No
TDD mechanism: none
Self-review: none

Git / Observability

Auto commit: No
Auto PR: No
Auto merge: No
Worktree/feat: No
Audit log: No
Audit format: none
Replay: No

Tools

Primary: cursor
Targets: 2
Portability: medium

Signals

Stars: 863
Last commit: 2025-06-11
Contributors: 1
Maintainer: dormant
Quality score: 0.5/10

Summary

10x-Tool-Calls

Overview

Overview — 10x-Tool-Calls

Origin

Philosophy (verbatim from README)

The quota math (verbatim from README)

Important caveat (verbatim)

Target tools

Architecture

Architecture — 10x-Tool-Calls

Distribution

Install

Required runtime

Directory tree

Target AI tools

Config files

Components

Components — 10x-Tool-Calls

Rules (1)

Scripts (1)

Commands

Skills

Subagents

Hooks

MCP servers

Templates

Prompts

Prompts — 10x-Tool-Calls

Verbatim excerpt 1 — Basic/rules.md (the entire rules file)

Verbatim excerpt 2 — Basic/userinput.py

Uniqueness

Uniqueness — 10x-Tool-Calls

differs_from_seeds

Positioning

Observable failure modes

Workflow

Workflow — 10x-Tool-Calls

Phases

The loop (verbatim from rules.md)

Approval gates

Memory Context

Memory & Context — 10x-Tool-Calls

State storage

Persistence

Compaction handling

Context handoff

Orchestration

Orchestration — 10x-Tool-Calls

Multi-agent

Orchestration pattern

Isolation mechanism

Multi-model

Execution mode

Consensus mechanism

Prompt chaining

Ui Cli Surface

UI/CLI Surface — 10x-Tool-Calls

Dedicated CLI binary

Local web dashboard

IDE integration

Observability

Surface area

Related frameworks

Verbatim excerpt 1 — `Basic/rules.md` (the entire rules file)

Verbatim excerpt 2 — `Basic/userinput.py`