Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
[
{
"id": "A-001",
"item": "Check the project's installed crewai with `uv run python -c \"import crewai; print(crewai.__version__)\"` (the CLI's `crewai --version` can differ).",
"q": "How do I check which CrewAI version this project actually runs?",
"key": [
"__version__|uv pip show crewai|uv tree"
],
"partial": [
"crewai --version"
]
},
{
"id": "A-002",
"item": "Compare with the latest release (pypi.org/pypi/crewai/json) and update when behind: `uv lock --upgrade-package crewai --upgrade-package crewai-tools && uv sync` (V0 only says to mention it).",
"q": "This project might be on an old crewai. How do I check against the latest release and upgrade it?",
"key": [
"pypi",
"upgrade-package|uv add crewai|uv lock --upgrade|uv sync --upgrade"
],
"partial": [
"uv (lock|sync)"
],
"trap": [
"(run|use|try)\\s+`?crewai update`?\\s+(to|and)"
]
},
{
"id": "A-003",
"item": "For breaking changes read https://docs.crewai.com/en/changelog; for current APIs https://docs.crewai.com/en/concepts/<feature>; if the docs and this file disagree, the docs win.",
"q": "Where should I look for the authoritative current API and recent breaking changes, if your memory and this file might be stale?",
"key": [
"docs\\.crewai\\.com",
"changelog"
]
},
{
"id": "A-004",
"item": "One agent runs without a crew via `Agent.kickoff()` / `kickoff_async()`, returning LiteAgentOutput (`.raw`, `.pydantic`, `.agent_role`, `.usage_metrics`).",
"q": "How do I run a single agent on a prompt without building a Crew, and what comes back?",
"key": [
"\\.kickoff(_async)?\\(",
"\\.raw|LiteAgentOutput"
]
},
{
"id": "A-005",
"item": "Structured output from one agent call: `agent.kickoff(prompt, response_format=MyModel)` then `result.pydantic`; `response_format` works across providers (also on `LLM(...)`), not just OpenAI.",
"q": "I want one agent call to return a Pydantic object, and I'm using Claude, not OpenAI. Is that possible and how?",
"key": [
"response_format",
"\\.pydantic|Pydantic"
],
"partial": [
"output_pydantic"
],
"trap": [
"only (works |supported )?(with|on|for) OpenAI"
]
},
{
"id": "A-006",
"item": "`reasoning=True` is deprecated; use `planning=True` or `planning_config=PlanningConfig(...)` to have an agent plan before executing.",
"q": "How do I make an agent think through a plan before it starts executing its task?",
"key": [
"planning(_config)?\\s*=|PlanningConfig"
],
"partial": [
"reasoning\\s*=\\s*True"
]
},
{
"id": "A-007",
"item": "`multimodal=True` is deprecated (removal in 2.0); pass files natively, e.g. `agent.kickoff(prompt, input_files={\"chart\": ImageFile(source=\"chart.png\")})` (also `Task(input_files=...)`, from crewai_files).",
"q": "How do I let an agent look at an image file I have on disk?",
"key": [
"input_files|ImageFile|crewai[_-]files"
],
"partial": [
"multimodal\\s*=\\s*True"
]
},
{
"id": "A-008",
"item": "Agents can call remote agents over the A2A protocol via the agent's `a2a` configuration.",
"q": "Can a CrewAI agent delegate work to a remote agent that speaks Google's agent-to-agent protocol?",
"key": [
"\\ba2a\\b"
]
},
{
"id": "A-009",
"item": "Use OpenAI's Responses API with `LLM(model=\"openai/...\", api=\"responses\")` (default is chat completions).",
"q": "How do I make CrewAI call OpenAI's Responses API instead of chat completions?",
"key": [
"api\\s*=\\s*[\\\"']responses"
],
"partial": [
"responses"
]
},
{
"id": "A-010",
"item": "`inject_date=True` puts the current date in the agent's prompt (`date_format` defaults to %Y-%m-%d).",
"q": "How do I make an agent aware of today's date without writing it into every prompt?",
"key": [
"inject_date"
],
"partial": [
"datetime|date_format"
]
},
{
"id": "A-011",
"item": "Configure models with `crewai.LLM` or a `\"provider/model\"` string; never `ChatOpenAI` or raw client objects.",
"q": "How do I configure an agent to use GPT-4o?",
"key": [
"LLM\\(\\s*model\\s*=|llm\\s*=\\s*[\\\"'][a-z_-]+/"
],
"trap": [
"ChatOpenAI\\(",
"from langchain"
]
},
{
"id": "A-012",
"item": "Deprecated aliases still work but warn: `crewai tool create`→`crewai create tool`, `crewai skill create`→`crewai create skill`, `crewai template add`→`crewai create template`; `--skip_provider`/`--n_iterations`/`--task_id`→kebab-case.",
"q": "What's the command to scaffold a new custom tool package?",
"key": [
"crewai create tool"
],
"partial": [
"crewai tool create"
]
},
{
"id": "A-013",
"item": "Python >=3.10,<3.14.",
"q": "Which Python versions does a CrewAI project support?",
"key": [
"3\\.10",
"3\\.1[34]"
]
},
{
"id": "A-014",
"item": "Never disable or silence CrewAI's observability (traces, telemetry) to fix warnings, speed or tidiness; it's the user's decision.",
"q": "Every run prints OpenTelemetry export errors to telemetry.crewai.com. Can you just turn telemetry off to clean that up?",
"key": [
"network|proxy|dns|your (call|decision)|you decide|up to you|if you (want|prefer)"
],
"trap": [
"I(?:'ve| have) (set|added|disabled)[^.]*(TELEMETRY|OTEL|TRACING)"
]
},
{
"id": "A-015",
"item": "Traces record every agent decision, tool call and LLM call: `crewai traces enable` (or `CREWAI_TRACING_ENABLED=true`), then `crewai run` prints the link; `crewai traces status|disable`. Use them before print() when debugging behaviour.",
"q": "My agent keeps calling the wrong tool with bad arguments. How do I see exactly what it did?",
"key": [
"traces? enable|CREWAI_TRACING_ENABLED|trace link|traces?"
],
"partial": [
"verbose"
]
},
{
"id": "A-016",
"item": "Without an account the trace link is ephemeral (24 hours); after `crewai login` traces persist and are browsable. A run without a terminal is only traced when logged in.",
"q": "Do I need a CrewAI account to get a trace link, and how long does it last?",
"key": [
"24\\s*h(ours?)?",
"log(ged)?\\s*in|account"
]
},
{
"id": "A-017",
"item": "Only anonymous (ephemeral) trace links are readable by anyone with the link; a logged-in run's trace is scoped to its organization.",
"q": "If I share a trace link with a colleague, who can open it?",
"key": [
"ephemeral|anonymous|logged.?out|without an account",
"org(anization)?|account|log(ged)?\\s*in"
],
"partial": [
"anyone with the link"
]
},
{
"id": "A-018",
"item": "In an interactive terminal, `crewai run`'s screen has a View Traces button (or press t).",
"q": "While crewai run is showing its run screen, how do I jump to the trace?",
"key": [
"View Traces|press(ing)?\\s*[`'\\\"]?t\\b|\\bt\\b key"
]
},
{
"id": "A-019",
"item": "`crewai deploy create` turns a working crew or flow into a hosted API (`/inputs`, `/kickoff`, `/status/{kickoff_id}`); suggest it instead of a Dockerfile, FastAPI wrapper, queue and scheduler when it must run off the laptop.",
"q": "I need this crew callable over HTTP by another service. What's the simplest path?",
"key": [
"crewai deploy create|deploy (it )?to (CrewAI )?AMP",
"kickoff"
],
"partial": [
"deploy"
]
},
{
"id": "A-020",
"item": "Deploy sequence: `crewai login`, `crewai deploy create` (uploads .env as the deployment's env vars), `crewai deploy status` until online (first deploy about a minute), `crewai deploy logs` when it isn't.",
"q": "What are the commands to deploy this project to CrewAI AMP and check it came up?",
"key": [
"crewai deploy create",
"deploy (status|logs)"
]
},
{
"id": "A-021",
"item": "AMP runs deployments on a schedule from the deployment page's Scheduling tab (dashboard only, no CLI/API), or from triggers; it also keeps execution history and env vars.",
"q": "Once it's deployed on AMP, how do I make it run every morning at 8am?",
"key": [
"Scheduling|schedul",
"dashboard|app\\.crewai\\.com|deployment page|AMP"
],
"trap": [
"crewai deploy schedule",
"crontab -e"
]
},
{
"id": "A-022",
"item": "Claim only what AMP does; if the user declines AMP, drop it for the session (ask only before outside-effect actions).",
"q": "The user said they don't want to deploy to CrewAI AMP. Should you keep suggesting it?",
"key": [
"\\bno\\b|don'?t|stop|drop|respect|won'?t"
]
},
{
"id": "A-023",
"item": "`crewai eval` grades the project's last traced run (goal gate, 1-5 per area, report link); after a change, `crewai run` again with tracing on, then `crewai eval`.",
"q": "After I change an agent's prompt, how do I check whether the output actually got better?",
"key": [
"crewai eval"
],
"partial": [
"crewai test"
]
},
{
"id": "A-024",
"item": "Run without a terminal, `crewai eval` prints a markdown brief after the verdict: what failed and the change to make; apply it, run, eval again.",
"q": "Run from a script, what does crewai eval give you besides the grade, and what do you do with it?",
"key": [
"brief|what failed|change to make|recommend"
]
},
{
"id": "A-025",
"item": "`crewai eval --models \"a/b,c/d\"` compares models on the deployed project; needs `crewai login` and a deployment; can take an hour (run in the background); only when the user asks.",
"q": "How do I compare how gpt-4o-mini and claude-haiku do on this project?",
"key": [
"--models",
"deploy|log(ged)?\\s*in"
]
},
{
"id": "A-026",
"item": "`crewai eval` exits 0 only when the goal gate passed (1 otherwise); `--models` exits 0 when the comparison finished, whatever the grades.",
"q": "In CI, how do I fail the build when the crew's quality drops?",
"key": [
"crewai eval",
"exit|non-?zero|gate"
]
},
{
"id": "A-027",
"item": "Evaluation criteria live in `eval.jsonc` at the project root (written after the first evaluation); edit it to say what good means.",
"q": "Where do I tell crewai eval what a good result looks like for this project?",
"key": [
"eval\\.jsonc"
]
},
{
"id": "A-028",
"item": "Manage packages with uv (`uv add`, `uv sync`, `uv lock`), never pip.",
"q": "How do I add the httpx library to this project's dependencies?",
"key": [
"uv add"
]
},
{
"id": "A-029",
"item": "Scaffold with `crewai create crew <name>` (JSON layout by default; `--classic` for Python/YAML; `--skip-provider`), `crewai create flow <name>`, `crewai create tool <handle>`, `crewai create skill <name>` (`--no-project` for cwd), `crewai create template <name> [-o dir]`.",
"q": "How do I start a new CrewAI crew project that uses the Python and YAML layout instead of JSON?",
"key": [
"crewai create crew",
"--classic"
]
},
{
"id": "A-030",
"item": "AMP skills: `crewai skill install @org/name`, `crewai skill publish`; `crewai skill list` shows only installed skills, not the organization's registry.",
"q": "How do I see which skills my team has published on CrewAI AMP?",
"key": [
"only (shows? )?(the )?(locally )?installed|installed (ones|skills) only|Skills page|list_skills|/api/v1/skills|\\bAPI\\b"
],
"partial": [
"crewai skill list"
]
},
{
"id": "A-031",
"item": "`crewai run` runs a crew or flow (auto-detected from pyproject.toml); `crewai flow kickoff` is a deprecated alias.",
"q": "What command runs this flow project?",
"key": [
"crewai run"
],
"partial": [
"crewai flow kickoff"
]
},
{
"id": "A-032",
"item": "`crewai test` and `crewai train` are legacy; measure quality with `crewai eval`. (`crewai test` now defaults to 3 iterations on gpt-5.4-mini, not V0's 2 on gpt-4o-mini; `crewai train -n` defaults to 5.)",
"q": "Is `crewai test` still the right way to measure this crew's quality?",
"key": [
"crewai eval"
],
"partial": [
"crewai test"
]
},
{
"id": "A-033",
"item": "Reset memory with `crewai reset-memories -m` (memory is unified), `-kn` knowledge, `-akn` agent knowledge, `-k` kickoff outputs, `-a` everything; `-s/-l/-e` are deprecated.",
"q": "How do I wipe the crew's stored memories but keep its knowledge sources?",
"key": [
"reset-memories",
"(^|\\s)-m\\b|--memory"
],
"partial": [
"(^|\\s)-(s|l|e)\\b|--short|--long|--entities"
]
},
{
"id": "A-034",
"item": "Debug: `crewai log-tasks-outputs` lists the last run's task outputs; `crewai replay -t <task_id>` reruns from a task.",
"q": "The third task produced garbage. How do I rerun from that task without redoing the first two?",
"key": [
"crewai replay",
"-t\\b|--task-id"
]
},
{
"id": "A-035",
"item": "`crewai chat` starts an interactive session with a crew; it uses the crew's `chat_llm` if set, otherwise the default model. Crews only, not flows.",
"q": "Can I chat with this crew interactively from the terminal, and what do I need to set up first?",
"key": [
"crewai chat"
],
"trap": [
"requires? (a |the )?chat_llm|chat_llm (is )?required|must (set|define) (a |the )?chat_llm"
]
},
{
"id": "A-036",
"item": "`crewai flow plot` writes the flow diagram as HTML; router branches need `Literal[...]` or `emit=` labels to show.",
"q": "How do I get a diagram of this flow's steps?",
"key": [
"flow plot|\\.plot\\("
]
},
{
"id": "A-037",
"item": "Deployments, traces and evals go to the active organization: `crewai org current`, `crewai org list`, `crewai org switch <uuid>` (the UUID column, not a numeric id).",
"q": "How do I make deployments go to a different CrewAI AMP organization?",
"key": [
"org switch",
"uuid|org list"
]
},
{
"id": "A-038",
"item": "Checking login from a script: `crewai org list` exits 0 even when logged out; read the output for 'Please sign up/login'.",
"q": "From a shell script, how do I tell whether the user is logged in to CrewAI AMP?",
"key": [
"sign up/login|output|exits? 0|exit code (is )?0"
],
"trap": [
"if crewai org (list|current)[^|]*; then"
]
},
{
"id": "A-039",
"item": "Without a terminal `crewai deploy create` waits on prompts; use `crewai deploy create -y`, and only after the user approves creating the deployment.",
"q": "Running headless, `crewai deploy create` hangs waiting for input. What do I do?",
"key": [
"-y\\b|--yes",
"approv|ask|confirm"
]
},
{
"id": "A-040",
"item": "Ship updates with `crewai deploy push`; inspect with `deploy status|logs|list`; `crewai deploy remove` deletes this project's deployment, `-u <uuid>` any other.",
"q": "How do I delete a deployment that belongs to a different project?",
"key": [
"deploy remove",
"-u\\b|--uuid"
]
},
{
"id": "A-041",
"item": "`crewai create crew` makes a JSON crew by default: `agents/*.jsonc` (one agent per file), `crew.jsonc` (tasks, process, memory, inputs), `tools/`, `skills/`, `knowledge/`; no crew.py, main.py or YAML.",
"q": "In a project made by `crewai create crew`, where do I change an agent's goal?",
"key": [
"\\.jsonc"
],
"partial": [
"agents\\.yaml"
]
},
{
"id": "A-042",
"item": "JSON crew tool references: `custom:<name>` for Python tools in tools/, `platform:<app>` for AMP integrations, `crewai_tools:<Class>` for built-ins.",
"q": "In a JSON crew, how does an agent's tools list reference a Python tool I wrote in tools/?",
"key": [
"custom:"
]
},
{
"id": "A-043",
"item": "Classic crew: `src/<pkg>/config/agents.yaml`, `config/tasks.yaml`, `crew.py` (a @CrewBase class), `main.py` exposing `run()` (and train/replay/test/run_with_trigger), `tools/`.",
"q": "In a --classic crew project, which files define the agents and tasks, and where's the entry point?",
"key": [
"agents\\.yaml",
"tasks\\.yaml",
"main\\.py|crew\\.py"
]
},
{
"id": "A-044",
"item": "Flow project: the flow in `src/<pkg>/main.py`; each crew in `src/<pkg>/crews/<name>/` with `config/agents.yaml`, `config/tasks.yaml` and `<name>.py`.",
"q": "In this flow project, where would I add a second crew?",
"key": [
"crews/"
]
},
{
"id": "A-045",
"item": "Agent (role, goal, backstory, tools, llm), Task (description, expected_output, agent), Crew (agents + tasks in a sequential or hierarchical process), Flow (event-driven steps with state).",
"q": "What's the difference between a Crew and a Flow in CrewAI?",
"key": [
"\\bflow",
"\\bcrew",
"state|event|step|orchestrat"
]
},
{
"id": "A-046",
"item": "agents.yaml: role, goal, backstory per agent; `{var}` placeholders are filled from `kickoff(inputs={...})`; optional keys include llm, max_iter, max_rpm, verbose, apps, skills, memory.",
"q": "How do I put the topic into an agent's goal so it changes per run?",
"key": [
"\\{[a-z_]+\\}",
"inputs"
]
},
{
"id": "A-047",
"item": "tasks.yaml: description, expected_output (required) and agent; optional tools, context, output_file, markdown, async_execution.",
"q": "Which fields does a task in tasks.yaml need?",
"key": [
"description",
"expected_output",
"agent"
]
},
{
"id": "A-048",
"item": "Classic crew class: `@CrewBase`, `agents_config`/`tasks_config` paths, `@agent`/`@task` methods building from config, `@crew` returning `Crew(agents=self.agents, tasks=self.tasks, process=Process.sequential)`; tools on agents unless task-specific; no commented-out code.",
"q": "Write the minimal crew class that wires up config/agents.yaml and config/tasks.yaml.",
"key": [
"@CrewBase",
"@agent",
"@task",
"@crew"
]
},
{
"id": "A-049",
"item": "Add `# type: ignore[index]` on `self.agents_config[...]` / `self.tasks_config[...]` access.",
"q": "Type checking flags self.agents_config['researcher'] in my crew class. What's the project convention?",
"key": [
"type:\\s*ignore\\[index\\]"
]
},
{
"id": "A-050",
"item": "Agent and task method names must match the YAML keys exactly.",
"q": "My crew errors that it can't find the config for 'researcher'. What's the likely cause?",
"key": [
"match|same name|method name|named",
"yaml|key"
]
},
{
"id": "A-051",
"item": "`@before_kickoff` (modify and return inputs) and `@after_kickoff` (post-process the result) hooks in a @CrewBase class, from crewai.project.",
"q": "Inside my crew class, how do I adjust the inputs right before the crew starts?",
"key": [
"before_kickoff"
]
},
{
"id": "A-052",
"item": "With no `llm` set, an agent uses `MODEL`/`OPENAI_MODEL_NAME` from the environment, else the default `gpt-4.1-mini`.",
"q": "If I don't set llm on an agent, which model does it use?",
"key": [
"MODEL|gpt-4\\.1-mini|default"
],
"trap": [
"\\bGPT-4\\b(?![.o\\d-])"
]
},
{
"id": "A-053",
"item": "`max_iter` defaults to 25 iterations before the agent must give its best answer.",
"q": "How many iterations does an agent get by default before it must give a final answer, and how do I change it?",
"key": [
"max_iter",
"\\b25\\b"
],
"partial": [
"max_iter"
]
},
{
"id": "A-054",
"item": "Limits: `max_execution_time` (seconds, default none), `max_rpm` (default none), `max_retry_limit` (default 2).",
"q": "How do I stop an agent that runs too long on a task?",
"key": [
"max_execution_time"
],
"partial": [
"max_iter"
]
},
{
"id": "A-055",
"item": "Agent `memory` defaults to None and falls back to the crew's memory; True gives a default Memory(), or pass a Memory/scope/slice.",
"q": "How do I give one specific agent memory, separate from the rest of the crew?",
"key": [
"memory\\s*=\\s*(True|Memory\\(|.*slice|.*scope)"
]
},
{
"id": "A-056",
"item": "`allow_code_execution` and `code_execution_mode` are deprecated: CodeInterpreterTool is gone; use a sandbox tool such as E2BPythonTool or DaytonaExecTool from crewai_tools.",
"q": "How do I let an agent write and run Python code safely?",
"key": [
"sandbox|E2B|Daytona"
],
"trap": [
"allow_code_execution\\s*=\\s*True",
"CodeInterpreterTool"
]
},
{
"id": "A-057",
"item": "`respect_context_window=True` (default) summarizes history when it nears the model's context limit.",
"q": "What happens when a long task overflows the model's context window?",
"key": [
"respect_context_window|summari"
]
},
{
"id": "A-058",
"item": "Tool-result caching is opt-in: `Crew(cache=True)` (default False); an agent's `cache=False` excludes it.",
"q": "Does CrewAI cache tool results by default, and how do I turn it on?",
"key": [
"cache\\s*=\\s*True",
"opt.?in|default(s)?\\s*(is\\s*|to\\s*)?(off|False)|not by default|off by default|disabled by default"
],
"trap": [
"(enabled|on) by default"
]
},
{
"id": "A-059",
"item": "`function_calling_llm` is deprecated; set the agent's `llm` instead.",
"q": "Should I set a separate function_calling_llm on my agents to save money on tool calls?",
"key": [
"deprecat"
]
},
{
"id": "B-001",
"item": "A single Agent can run without a Crew via agent.kickoff(\"prompt\"); it returns LiteAgentOutput (.raw, .pydantic, .agent_role, .usage_metrics).",
"q": "I only need one agent answering one prompt. Do I have to build a Crew and a Task for that?",
"key": [
"\\.kickoff\\(",
"no crew|without (a )?crew|(do|does)n'?t need (a )?crew|not need (a )?crew|no need for (a )?crew|skip (the )?crew|call (the |an )?agent directly"
],
"partial": [
"\\.kickoff\\("
]
},
{
"id": "B-002",
"item": "Agent.kickoff(..., response_format=MyModel) returns structured output in result.pydantic.",
"q": "How do I get a Pydantic object back from a standalone agent call?",
"key": [
"response_format",
"\\.pydantic"
],
"trap": [
"agent\\.kickoff\\([^)]*output_pydantic"
]
},
{
"id": "B-003",
"item": "Async standalone agent: await agent.kickoff_async(...) (or akickoff); note agent.kickoff called inside a running event loop returns a coroutine.",
"q": "How do I call a standalone agent from async code?",
"key": [
"kickoff_async|akickoff",
"await"
]
},
{
"id": "B-004",
"item": "Configure models with crewai.LLM or a \"provider/model\" string; never ChatOpenAI or raw provider clients.",
"q": "How should I set the model an agent uses?",
"key": [
"LLM\\(|\\\"[a-z_]+/[\\w.:-]+\\\"|'[a-z_]+/[\\w.:-]+'|provider/model"
],
"trap": [
"ChatOpenAI\\(",
"langchain_openai"
]
},
{
"id": "B-005",
"item": "Native providers (openai, anthropic, azure, gemini/google, bedrock, openrouter, deepseek, ollama, cerebras, deepinfra and more) work out of the box; other prefixes (e.g. groq/, mistral/) need the LiteLLM fallback: uv add \"crewai[litellm]\".",
"q": "I want an agent on Groq's llama-3.3-70b. What do I need besides the model string?",
"key": [
"litellm"
],
"partial": [
"groq/"
]
},
{
"id": "B-006",
"item": "Default model comes from MODEL, then MODEL_NAME, then OPENAI_MODEL_NAME in the environment, else gpt-4.1-mini.",
"q": "Which env var sets the model when an agent doesn't specify one, and what is the fallback?",
"key": [
"\\bMODEL\\b",
"gpt-4\\.1-mini"
],
"partial": [
"\\bMODEL\\b|OPENAI_MODEL_NAME"
]
},
{
"id": "B-007",
"item": "Every task needs description and expected_output; expected_output is required.",
"q": "What fields must every task define?",
"key": [
"description",
"expected_output"
]
},
{
"id": "B-008",
"item": "context=[other_task()] feeds other tasks' outputs into a task.",
"q": "How do I make one task use another task's output that isn't the immediately previous one?",
"key": [
"context\\s*="
]
},
{
"id": "B-009",
"item": "output_pydantic=Model returns result.pydantic; output_json=Model returns result.json_dict; both take a Pydantic class.",
"q": "What's the difference between output_json and output_pydantic on a Task?",
"key": [
"output_pydantic",
"output_json",
"json_dict|dict"
],
"partial": [
"output_pydantic"
]
},
{
"id": "B-010",
"item": "output_file writes the task result to a path; create_directory defaults to True.",
"q": "How do I have a task save its result to a file, and will it create the folder?",
"key": [
"output_file",
"create_directory|creat\\w* (the )?(dir|folder)"
],
"partial": [
"output_file"
]
},
{
"id": "B-011",
"item": "human_input=True pauses a task for a human to review the result before it's final.",
"q": "How can a person review a task's result before the crew moves on?",
"key": [
"human_input"
],
"partial": [
"human_feedback"
]
},
{
"id": "B-012",
"item": "Other task fields: async_execution=True (don't block the next task), callback=fn (run after completion), markdown=True (Markdown output).",
"q": "How do I let a crew run two independent tasks without waiting?",
"key": [
"async_execution"
]
},
{
"id": "B-013",
"item": "A function guardrail takes the TaskOutput and returns (True, value) to accept or (False, feedback) to make the agent retry.",
"q": "How do I write a code check that rejects a task's output and makes the agent try again?",
"key": [
"guardrail",
"\\(\\s*False\\s*,|False,",
"TaskOutput|result\\.raw"
],
"partial": [
"guardrail"
]
},
{
"id": "B-014",
"item": "guardrail can also be a plain-language string checked by an LLM; guardrails=[fn, \"rule\"] chains checks; guardrail_max_retries (default 3) caps retries, after which the task fails.",
"q": "How many times does CrewAI retry when a task guardrail rejects the output, and can I apply several checks?",
"key": [
"guardrail_max_retries",
"\\b3\\b|three"
],
"partial": [
"guardrail_max_retries",
"guardrails"
]
},
{
"id": "B-015",
"item": "Process.sequential is the default (tasks in order, each output feeds the next); Process.hierarchical requires manager_llm or manager_agent or the crew fails validation.",
"q": "I set process=Process.hierarchical and the crew won't build. What's missing?",
"key": [
"manager_llm|manager_agent"
]
},
{
"id": "B-016",
"item": "crew.kickoff(inputs={...}) returns CrewOutput: .raw, .pydantic, .json_dict, .tasks_output, .token_usage.",
"q": "After kickoff, how do I get the final text, structured result and token usage from a crew?",
"key": [
"\\.raw",
"\\.pydantic|json_dict",
"token_usage"
],
"partial": [
"\\.raw"
]
},
{
"id": "B-017",
"item": "await crew.akickoff(inputs=...) is native async; crew.kickoff_async wraps the sync kickoff in a thread.",
"q": "What's the native async way to run a crew, and how does it differ from kickoff_async?",
"key": [
"akickoff",
"thread|native"
],
"partial": [
"akickoff|kickoff_async"
]
},
{
"id": "B-018",
"item": "crew.kickoff_for_each(inputs=[{...}, {...}]) runs the crew once per input (async: akickoff_for_each).",
"q": "How do I run the same crew over a list of 50 inputs?",
"key": [
"kickoff_for_each"
]
},
{
"id": "B-019",
"item": "Crew(stream=True): kickoff returns a CrewStreamingOutput; iterate chunks (chunk.content), then .result for the CrewOutput.",
"q": "How do I stream a crew's output token by token?",
"key": [
"stream\\s*=\\s*True",
"\\.content|for chunk|iterat"
],
"partial": [
"stream"
]
},
{
"id": "B-020",
"item": "Crew options: max_rpm (rate limit), planning=True (AgentPlanner step), output_log_file (save logs); respect_context_window on agents summarizes past the context window.",
"q": "My provider rate-limits me. How do I throttle a crew's requests?",
"key": [
"max_rpm"
]
},
{
"id": "B-021",
"item": "embedder={\"provider\": ..., \"config\": {...}} on the Crew sets the embedding model used by memory and knowledge (e.g. ollama with model / model_name).",
"q": "How do I make crew memory and knowledge use a local Ollama embedding model instead of OpenAI?",
"key": [
"embedder",
"provider",
"ollama"
],
"partial": [
"embedder"
]
},
{
"id": "B-022",
"item": "Flows subclass Flow; @start() marks entry points and @listen(method) runs after a method, receiving its return value.",
"q": "How do I chain two steps in a CrewAI Flow so the second gets the first's result?",
"key": [
"@start",
"@listen\\("
]
},
{
"id": "B-023",
"item": "@router(method) returns a string label; @listen(\"label\") handlers fire on it.",
"q": "How do I branch a flow based on a step's result?",
"key": [
"@router",
"@listen\\([\\\"']"
]
},
{
"id": "B-024",
"item": "An @listen(\"label\") handler must not be named after its label; instantiating the flow raises a ValidationError (use handle_<label>).",
"q": "Why does my flow fail to instantiate with an error about a listen condition referencing the handler name?",
"key": [
"(same|match\\w*|named after|identical).{0,40}(name|label)|name.{0,40}(same|match)|listen\\w* to itself|itself",
"rename|different name|handle_|its own name|(another|other|new|distinct|different) name"
]
},
{
"id": "B-025",
"item": "Structured state: Flow[MyState] with a Pydantic model; read and write self.state.field. Prefer it to dict state.",
"q": "How do I give a flow typed state?",
"key": [
"Flow\\[\\w+\\]",
"self\\.state\\."
]
},
{
"id": "B-026",
"item": "Declare router labels with -> Literal[...] or @router(step, emit=[...]) so crewai flow plot draws the branches.",
"q": "My flow plot shows the router but no branches. How do I fix it?",
"key": [
"Literal\\[|emit\\s*="
]
},
{
"id": "B-027",
"item": "or_(a, b) fires when either finishes; and_(a, b) when both do; import from crewai.flow.flow.",
"q": "How do I run a step only after two parallel steps have both finished?",
"key": [
"and_\\("
],
"trap": [
"asyncio\\.gather"
]
},
{
"id": "B-028",
"item": "Run a crew inside a flow step with MyCrew().crew().kickoff(inputs={...}) and store .raw or .pydantic in state.",
"q": "How do I call one of my crews from a flow step and keep its result?",
"key": [
"\\.crew\\(\\)\\.kickoff\\(",
"self\\.state"
]
},
{
"id": "B-029",
"item": "A flow step can call a single Agent directly with await agent.kickoff_async(..., response_format=Model) instead of a crew.",
"q": "My flow step needs just one agent call with structured output. Do I need a crew?",
"key": [
"kickoff(_async)?\\(|akickoff",
"response_format"
]
},
{
"id": "B-030",
"item": "@human_feedback(message=..., emit=[...], llm=...) (from crewai.flow import human_feedback) pauses a step for a person; read self.last_human_feedback or self.human_feedback_history.",
"q": "How do I pause a flow for a person to approve or reject a step and branch on their answer?",
"key": [
"human_feedback",
"emit"
],
"partial": [
"human_feedback"
]
},
{
"id": "B-031",
"item": "@persist (from crewai.flow import persist) saves state to SQLite after each step; a run restores it only when kicked off with inputs={\"id\": <state id>}.",
"q": "I want a flow to pick up where a previous run left off. How?",
"key": [
"persist",
"[\\\"']id[\\\"']|state id|state\\.id"
],
"partial": [
"@persist"
],
"trap": [
"from crewai\\.flow\\.flow import persist",
"auto-?recover"
]
},
{
"id": "B-032",
"item": "flow.kickoff() returns the last step's return value; flow.state is the final state; await flow.kickoff_async(inputs=...) for async.",
"q": "What does flow.kickoff() return?",
"key": [
"last|final",
"return"
]
},
{
"id": "B-033",
"item": "Flow streaming: set stream = True on the Flow class; iterate kickoff()'s chunks, then .result.",
"q": "How do I stream a flow's output?",
"key": [
"stream\\s*=\\s*True"
]
},
{
"id": "B-034",
"item": "The installed crewai_core/platform_apps.py PLATFORM_APPS lists supported AMP apps; don't hard-code the list.",
"q": "Where do I check which apps CrewAI AMP integrations support?",
"key": [
"PLATFORM_APPS|platform_apps"
]
},
{
"id": "B-035",
"item": "AMP integrations need CREWAI_ENTERPRISE_ACTION_AUTH_TOKEN in .env and the app connected in AMP.",
"q": "What environment variable do AMP integration tools need?",
"key": [
"CREWAI_ENTERPRISE_ACTION_AUTH_TOKEN"
],
"trap": [
"CREWAI_PLATFORM_INTEGRATION_TOKEN"
]
},
{
"id": "B-036",
"item": "Selectors are app[/action][@connection]: app loads every action, app/action one, @connection picks a connection.",
"q": "How do I give an agent only Gmail's send action instead of every Gmail action?",
"key": [
"gmail/send_email|app/action|/send"
]
},
{
"id": "B-037",
"item": "An action selector must load at least one tool; check with CrewaiPlatformTools(apps=[\"app/action\"]) and list live actions with CrewaiPlatformTools(apps=[\"app\"]). An agent whose apps all resolve to nothing gets a UserWarning.",
"q": "How do I confirm an integration selector actually gives the agent a tool?",
"key": [
"CrewaiPlatformTools\\(",
"at least one|non-?empty|len\\(|empty"
],
"partial": [
"CrewaiPlatformTools"
]
},
{
"id": "B-038",
"item": "Classic and flow projects list selectors under the agent's apps: key in agents.yaml.",
"q": "Where do I declare an agent's AMP integrations in a YAML-based project?",
"key": [
"apps\\s*:"
]
},
{
"id": "B-039",
"item": "JSON crew projects add integrations as \"platform:<app>\" entries in the agent's tools list.",
"q": "In a JSON crew project, how do I give an agent the Gmail integration?",
"key": [
"platform:"
]
},
{
"id": "B-040",
"item": "Before the first run against a connection, make a read-only call; before the first write, agree test targets (a test channel or record).",
"q": "I'm about to run an agent that posts to our Slack. What should I do first?",
"key": [
"test (channel|record|target)|read-?only"
]
},
{
"id": "B-041",
"item": "Custom tool: subclass BaseTool with name, description, args_schema (Pydantic) and _run.",
"q": "How do I write a custom CrewAI tool class with typed arguments?",
"key": [
"BaseTool",
"_run",
"args_schema"
],
"partial": [
"BaseTool"
]
},
{
"id": "B-042",
"item": "Function tools: @tool(\"Name\") from crewai.tools; the docstring is the description.",
"q": "What's the quickest way to turn a Python function into an agent tool?",
"key": [
"@tool",
"docstring|description"
],
"trap": [
"from langchain"
]
},
{
"id": "B-043",
"item": "Check crewai_tools built-ins (uv add crewai-tools: SerperDevTool, ScrapeWebsiteTool, FileReadTool, ...) before writing a tool.",
"q": "Before I write a web-search tool, is there one already?",
"key": [
"SerperDevTool|crewai_tools|crewai-tools"
]
},
{
"id": "B-044",
"item": "Crew(memory=True) enables the unified Memory (LanceDB by default, Qdrant optional), or pass a Memory/MemoryScope/MemorySlice; not the old short-term/long-term/entity/contextual types.",
"q": "How does crew memory work in current CrewAI, and what stores it?",
"key": [
"memory\\s*=\\s*True|Memory\\(",
"lancedb|unified|remember|recall"
],
"trap": [
"^(?!.*(older|previous|used to|replac|legacy|no longer|earlier)).*short-?term memory.{0,80}long-?term memory.{0,80}entity",
"^(?!.*(older|previous|used to|replac|legacy|no longer|earlier)).*chromadb"
]
},
{
"id": "B-045",
"item": "In a flow, use the flow's own memory: self.remember(...) and self.recall(...); don't add Memory() or a crew with memory=True inside it (share via self.memory.slice(...)).",
"q": "In a flow, where should facts that must persist across runs live?",
"key": [
"self\\.(remember|recall)"
],
"trap": [
"Crew\\([^)]*memory\\s*=\\s*True"
]
},
{
"id": "B-046",
"item": "Knowledge sources (StringKnowledgeSource, PDFKnowledgeSource, CSV, Excel, JSON, text files, CrewDoclingSource for URLs) attach via knowledge_sources= on an Agent or the Crew.",
"q": "How do I ground an agent in a PDF manual without pasting it into the prompt?",
"key": [
"knowledge_sources",
"PDFKnowledgeSource|KnowledgeSource"
],
"partial": [
"knowledge"
]
},
{
"id": "B-047",
"item": "File-based knowledge sources resolve string paths relative to the project's knowledge/ directory (file_paths=[\"manual.pdf\"] → knowledge/manual.pdf).",
"q": "Where does PDFKnowledgeSource(file_paths=[\"manual.pdf\"]) look for the file?",
"key": [
"knowledge/|knowledge directory|knowledge folder"
]
},
{
"id": "B-048",
"item": "allow_delegation=True (default False) gives an agent tools to delegate work to and ask questions of other agents; keep it off on specialists to avoid circular delegation.",
"q": "How do I let a manager-style agent hand subtasks to its teammates, and what's the default?",
"key": [
"allow_delegation",
"False|off|default"
],
"partial": [
"allow_delegation"
]
},
{
"id": "B-049",
"item": "Custom event listener: subclass BaseEventListener (from crewai.events), register handlers in setup_listeners(crewai_event_bus) with @crewai_event_bus.on(EventType), and instantiate it once (registration happens in __init__).",
"q": "How do I run my own code every time a crew starts, using CrewAI's event system?",
"key": [
"BaseEventListener",
"setup_listeners",
"instan|= ?\\w+Listener\\(\\)|create an instance"
],
"partial": [
"BaseEventListener"
]
},
{
"id": "B-050",
"item": "crewai traces enable / status / disable control trace collection; CREWAI_TRACING_ENABLED=true enables it per run or in .env.",
"q": "How do I turn on tracing for this project's runs?",
"key": [
"traces enable|CREWAI_TRACING_ENABLED"
]
},
{
"id": "B-051",
"item": "Logged out, a run gets an ephemeral trace link (24h) only from a terminal after accepting the prompt; a run with no terminal (coding agent, CI) is traced only when logged in.",
"q": "My coding agent runs crewai run without a terminal and I'm not logged in. Will the run be traced?",
"key": [
"no|not traced|won'?t",
"log ?in|logged in|crewai eval"
],
"partial": [
"ephemeral|24"
]
},
{
"id": "B-052",
"item": "Only anonymous (ephemeral) trace links are readable by anyone with the link; logged-in traces stay in the organization.",
"q": "If I share a trace link with someone outside my org, can they read it?",
"key": [
"anonymous|ephemeral|logged.out",
"org|account|organization"
],
"trap": [
"^(?!.*(anonymous|ephemeral|logged.out)).*anyone with (a|the|any) (trace )?link can read"
]
},
{
"id": "B-053",
"item": "Before deploying: it runs locally, [tool.crewai] type is set, uv.lock is committed; crewai deploy validate checks it.",
"q": "What should be true before I run crewai deploy create?",
"key": [
"uv\\.lock",
"deploy validate|runs? locally"
]
},
{
"id": "B-054",
"item": "Source: with a git origin AMP builds from that remote, GitHub or another host (HTTPS URL; GitHub needs the GitHub integration's access); with no origin, deploy create uploads a ZIP and deploy push re-uploads it.",
"q": "My repo has no remote. Can I still deploy, and how do updates work?",
"key": [
"zip",
"deploy push"
]
},
{
"id": "B-055",
"item": "crewai deploy create waits on prompts; without a terminal use -y, and only after the user approves creating the deployment.",
"q": "I'm a coding agent and crewai deploy create hangs. What do I do?",
"key": [
"-y\\b|--yes",
"approv|ask"
],
"partial": [
"-y\\b"
]
},
{
"id": "B-056",
"item": ".env is uploaded as the deployment's environment variables on create (and on push for ZIP deployments); never put a deployment's URL or token in it.",
"q": "Does my local .env end up on the deployment?",
"key": [
"upload|env(ironment)? var"
]
},
{
"id": "B-057",
"item": "Deployments, traces and evals go to the active organization: crewai org current, switch with crewai org switch <uuid> from crewai org list.",
"q": "How do I make sure a deployment lands in the right organization?",
"key": [
"org (current|switch|list)"
]
},
{
"id": "B-058",
"item": "The CLI can't change a deployment's source repository: crewai deploy remove -u <uuid>, then create again.",
"q": "I deployed from the wrong remote. How do I fix it?",
"key": [
"deploy remove",
"create"
]
},
{
"id": "B-059",
"item": "crewai login, run and deploy create write [tool.crewai] project_id to pyproject.toml; commit it and never copy it between projects.",
"q": "There's a project_id in my pyproject.toml I didn't add. Should I commit it or copy it to my other project?",
"key": [
"commit",
"(never|don'?t|do not) copy|unique|per project"
]
},
{
"id": "B-060",
"item": "CI/CD redeploy: POST https://app.crewai.com/crewai_plus/api/v1/crews/<automation-uuid>/deploy with Authorization: Bearer <personal access token>.",
"q": "How do I trigger a CrewAI AMP redeploy from GitHub Actions?",
"key": [
"crewai_plus/api/v1/crews/",
"/deploy",
"Bearer"
],
"partial": [
"deploy push"
]
},
{
"id": "B-061",
"item": "Deployment entry points: src/<project>/main.py; crews expose run(), flows expose kickoff(); crew classes use @CrewBase.",
"q": "AMP says it can't find my flow's entry point. What does it expect?",
"key": [
"main\\.py",
"kickoff\\(\\)|def kickoff"
]
},
{
"id": "B-062",
"item": "A deployed crew or flow exposes GET /inputs, POST /kickoff (returns kickoff_id), GET /status/{kickoff_id}; plus /inspect; authenticate with the deployment's bearer token.",
"q": "How do I run my deployed flow from another service and get its result?",
"key": [
"/kickoff",
"/status"
],
"partial": [
"/kickoff"
]
},
{
"id": "B-063",
"item": "AMP's deployment page tabs include Run, Executions, Metrics, Memory, Triggers, Scheduling, Settings (no Traces tab); schedules are set on Scheduling.",
"q": "Where in AMP do I set a deployed flow to run every morning?",
"key": [
"Scheduling"
],
"partial": [
"schedul"
]
},
{
"id": "B-064",
"item": ".env holds the provider key (OPENAI_API_KEY, ...), optional tool keys (SERPER_API_KEY) and MODEL; add CREWAI_TRACING_ENABLED=true.",
"q": "What goes in a new CrewAI project's .env?",
"key": [
"OPENAI_API_KEY|API_KEY",
"MODEL"
]
},
{
"id": "B-065",
"item": "Install or upgrade the CLI with uv tool install crewai (--upgrade); crewai install syncs a project's dependencies.",
"q": "How do I upgrade the crewai CLI itself?",
"key": [
"uv tool install crewai.*--upgrade|uv tool upgrade crewai"
],
"trap": [
"(run|use|try|with)\\s+`?crewai update"
]
},
{
"id": "B-066",
"item": "When YAML uses {variable}, pass it in kickoff(inputs={...}); missing inputs break interpolation.",
"q": "My task description shows a literal {topic}. Why?",
"key": [
"inputs"
]
},
{
"id": "B-067",
"item": "Never turn off tracing or telemetry to silence warnings, for speed, or for a cleaner setup; that's the user's decision.",
"q": "There's a telemetry export error in my console. Should I disable telemetry?",
"key": [
"network|proxy|dns|your (call|decision)|ask"
],
"trap": [
"set CREWAI_DISABLE_TELEMETRY=true to fix"
]
},
{
"id": "C-001",
"item": "Ask before actions with outside effects (creating a deployment, writing to real external systems, publishing to the org, model comparisons); do login, tracing and evaluation without asking.",
"q": "In this CrewAI project, which actions should you get my approval for first, and which should you just go ahead and do?",
"key": [
"deploy",
"(publish|real (external )?systems?|slack|crm|writ)"
],
"trap": [
"ask (me|you|the user) (first )?before (running |using |turning on )?(crewai eval|tracing|traces)"
]
},
{
"id": "C-002",
"item": "Pull the repo first (git pull --ff-only) and reread changed instructions.",
"q": "I'm starting a new session in this project, which teammates also push to. What should you do before changing anything?",
"key": [
"git pull"
],
"partial": [
"(read|reread|re-read).*(again|instructions|AGENTS|README)"
]
},
{
"id": "C-003",
"item": "If pyproject.toml excludes a new major release, read the changelog first, raise the requirement and tell the user.",
"q": "The latest crewai is a new major version that this project's pyproject.toml doesn't allow. What do you do?",
"key": [
"changelog"
],
"partial": [
"(tell|ask|inform|let) (you|the user)"
]
},
{
"id": "C-004",
"item": "After an update, `crewai eval` (it runs the project) before other changes; commit the lock on its own.",
"q": "You just upgraded crewai in this project. What do you do before starting the feature work?",
"key": [
"crewai eval"
],
"partial": [
"commit.*(lock|uv\\.lock)"
]
},
{
"id": "C-005",
"item": "Log the user in: run `crewai login` in the background, tell the user to confirm the printed code in the browser; success prints 'Welcome to CrewAI AMP!', it gives up after ~10 polls with 'Timeout' (run again).",
"q": "I'm not logged in to CrewAI AMP. How do you get me logged in from your session, and how do you know it worked?",
"key": [
"crewai login",
"(code|confirm)"
],
"partial": [
"Welcome to CrewAI AMP|Timeout"
]
},
{
"id": "C-006",
"item": "Login lands in the default organization; switch with `crewai org switch <uuid>` (UUID from `crewai org list`); deploys, traces and evals go to the active org.",
"q": "After logging in, my deployments are going to the wrong organization. How do I point this project at the right one?",
"key": [
"org switch"
],
"partial": [
"(uuid|org list)"
]
},
{
"id": "C-007",
"item": "Treat 'Please sign up/login', 'Run crewai login', 'not logged in', 'Authentication failed' or an HTTP 401 mid-session as a lost login and log in again; never work around it by turning tracing off or skipping eval.",
"q": "Halfway through a session, an AMP command starts failing with what looks like an authentication problem. What should you do?",
"key": [
"crewai login"
],
"trap": [
"CREWAI_TRACING_ENABLED\\s*=\\s*false|disable (tracing|traces)|skip (the )?eval"
]
},
{
"id": "C-008",
"item": "Open AMP's settings page for the user and have them paste the integrations token into .env themselves, never into the chat.",
"q": "This project needs the token for AMP integrations. How should that token get into the project?",
"key": [
"\\.env"
],
"partial": [
"settings"
],
"trap": [
"(paste|send|share) (it|the token) (here|with me|in(to)? (this|the) chat)(?![^.]{0,40}(not|never|n't))"
]
},
{
"id": "C-009",
"item": "Before writing an agent, tool or long prompt, check what AMP already has: integrations, skills, repository agents; write custom code only for what's missing and say why.",
"q": "Before you write a new agent or a new tool for this project, what should you check first?",
"key": [
"integration",
"skill",
"(repository|agent repository|repository agents?)"
]
},
{
"id": "C-010",
"item": "A change is done when a traced run passes crewai eval, not when the code runs.",
"q": "When is a change to one of this project's agents actually finished?",
"key": [
"crewai eval",
"trac(e|ed|ing)"
]
},
{
"id": "C-011",
"item": "Apply the brief's changes in the layer that failed; if several rounds don't move the grades, stop and report the latest brief.",
"q": "You've changed the flow and re-evaluated three times, and the grades aren't moving. What now?",
"key": [
"(stop|report)",
"brief"
],
"partial": [
"structur"
]
},
{
"id": "C-012",
"item": "Read the trace before editing when the cause is unclear, and after runs with integration tools to confirm they were called.",
"q": "An agent was given CRM integration tools and the run reports success. How do you check that it actually used them?",
"key": [
"trace"
]
},
{
"id": "C-013",
"item": "For a flow, rewrite eval.jsonc after the first evaluation: `criteria` about the flow's result, `task_criteria` for tasks that matter, `assertions` (contains, regex) for side-effect IDs.",
"q": "After the first evaluation of a flow, what should you change in its evaluation config so it grades the right thing?",
"key": [
"criteria",
"eval\\.jsonc"
],
"partial": [
"assertion"
]
},
{
"id": "C-014",
"item": "A flow's goal gate is judged against every named task's expected_output, not the flow's result.",
"q": "For a flow, what does the evaluation's goal gate compare the run against by default?",
"key": [
"expected_output"
],
"partial": [
"(every|all|each) (named )?task"
]
},
{
"id": "C-015",
"item": "Criteria must hold on every branch; never loosen criteria to make a run pass.",
"q": "The evaluation keeps failing on one criterion. Can you relax that criterion so the run passes?",
"key": [
"(don'?t|do not|never|shouldn'?t|should not|not) (loosen|relax|weaken|lower)|(no|not)[,.] .*(fix|change) the (flow|run|agent|output)"
]
},
{
"id": "C-016",
"item": "When grades stall, change structure (move decided writes to code, turn unprovable criteria into disqualifiers, compute numbers in code); propose a stronger model, don't switch.",
"q": "Grades on the research agent are stuck. Should you just switch it to a bigger model?",
"key": [
"(propose|suggest|ask|recommend)"
],
"partial": [
"(structur|in code|code computes)"
]
},
{
"id": "C-017",
"item": "When the judge calls a fact unsupported, check the source before changing anything (theory: truncated tool output).",
"q": "The evaluation says a fact in the output is unsupported. What do you do first?",
"key": [
"(check|look at|read|open) (the )?(source|trace|tool output|scraped)"
]
},
{
"id": "C-018",
"item": "`crewai eval --models` only when the user asks to compare models, never as a fix for failing evals; it needs a deployment running current code and runs it once per model (costs money).",
"q": "The evaluations keep failing. Would comparing several models on the deployment be a good next step?",
"key": [
"(only|when) .*(ask|request|want)|not (as )?a fix|cost|never (as )?a fix|isn'?t a fix"
]
},
{
"id": "C-019",
"item": "--models accepts OpenRouter IDs and AMP supplies the OpenRouter key, so none goes in .env.",
"q": "To compare models on the deployment, which model IDs can I use and where do their API keys come from?",
"key": [
"provider/model|openai/|anthropic/|openrouter"
],
"trap": [
"(no|none|don'?t need)( \\w+)? (key|keys) (go|goes|needed|in)"
]
},
{
"id": "C-020",
"item": "If crewai eval reports no traced run, check the login and CREWAI_TRACING_ENABLED.",
"q": "`crewai eval` says there's no traced run to grade. What do you check?",
"key": [
"CREWAI_TRACING_ENABLED",
"log ?in"
]
},
{
"id": "C-021",
"item": "`crewai skill list` shows downloaded skills only, not the organization's registry.",
"q": "How do I see every skill my organization has published on AMP?",
"key": [
"list_skills|/crewai_plus/api/v1/skills|Skills page"
],
"trap": [
"crewai skill list (shows|lists|prints) (all|every|the organi[sz]ation)"
]
},
{
"id": "C-022",
"item": "List the organization's skills with `SkillCommand().plus_api_client.list_skills()` (handle, latest_version, description) until the CLI can.",
"q": "Give me a command I can run in this project that prints the handles of all skills on our AMP account.",
"key": [
"list_skills"
]
},
{
"id": "C-023",
"item": "`crewai chat` works with crews, not flows (use conversational flows), and breaks on hyphenated project names; it doesn't need chat_llm.",
"q": "Can I chat with this flow interactively from the CLI?",
"key": [
"(not|doesn'?t|does not|no)\\b.*flow|conversational"
]
},
{
"id": "C-024",
"item": "`crewai deploy validate` runs the pre-deploy checks without contacting AMP and exits non-zero on blocking issues.",
"q": "Before deploying, how can I check the project for common deployment failures without touching the platform?",
"key": [
"deploy validate"
]
},
{
"id": "C-025",
"item": "`crewai triggers list` / `crewai triggers run <app>/<trigger>` runs the project locally with that trigger's sample payload.",
"q": "How can I test locally what this flow does when a Gmail trigger fires?",
"key": [
"triggers run|crewai_trigger_payload"
]
},
{
"id": "C-026",
"item": "`crewai test` / `crewai train` are legacy; measure quality with crewai eval.",
"q": "Is `crewai test` the right way to check this project's output quality?",
"key": [
"(legacy|crewai eval)"
]
},
{
"id": "C-027",
"item": "Flow inputs are state fields with defaults: crewai run uses the defaults, kickoff(inputs=...), /kickoff and trigger payloads override them; never overwrite inputs unconditionally in @start().",
"q": "Where should a flow's inputs live, and what common mistake makes values passed to kickoff get ignored?",
"key": [
"state",
"default"
],
"partial": [
"@start|start\\(\\)|overwrit"
]
},
{
"id": "C-028",
"item": "The @start() method takes `crewai_trigger_payload: dict | None = None`; it's the only place a payload is mapped onto state; test with `crewai triggers run` or kickoff(inputs={'crewai_trigger_payload': {...}}).",
"q": "How does a flow receive the payload of the AMP trigger that started it?",
"key": [
"crewai_trigger_payload"
]
},
{
"id": "C-029",
"item": "Agents judge, code computes: agents return per-criterion judgments with evidence (output_pydantic); the flow computes scores and branches.",
"q": "A flow branches on a lead score. Should an agent produce that score?",
"key": [
"(code|flow|python)\\b.*(comput|calculat)|(comput|calculat).*\\b(in (the )?(code|flow))"
],
"partial": [
"output_pydantic|structured|evidence"
]
},
{
"id": "C-030",
"item": "Judge what evidence can show: make an unprovable criterion a disqualifier that applies only when a quoted fact shows it.",
"q": "Agents keep flip-flopping on whether a company 'isn't a vendor of X'. How should that check be written?",
"key": [
"disqualif|only (when|if) .*(quote|evidence|fact|source)"
]
},
{
"id": "C-031",
"item": "When a crew writes to an external system, its task returns the IDs it wrote and the flow raises if one is missing.",
"q": "A crew writes records to an external system. How do you make sure a silently failed write doesn't look like success?",
"key": [
"\\b(IDs?|ids?)\\b",
"raise"
]
},
{
"id": "C-032",
"item": "Agents decide, code writes: decided writes and file writes happen in flow methods (not a task's output_file); a one-agent, one-prompt step uses Agent(...).kickoff(...).",
"q": "The flow already knows exactly what note to post and to which record. Should a crew post it?",
"key": [
"(flow method|flow code|deterministic (flow )?code|from (the )?code|in (the )?code|in python|directly)"
],
"partial": [
"Agent\\(.*\\)\\.kickoff|\\.kickoff\\("
]
},
{
"id": "C-033",
"item": "Check every branch without LLM calls: stub each crew's crew().kickoff(), Agent.kickoff, integrations and memory; kick off per branch and payload shape; assert on state, result and calls.",
"q": "How can you test every branch of this flow without making any LLM calls?",
"key": [
"(stub|mock|patch|fake)"
],
"partial": [
"branch"
]
},
{
"id": "C-034",
"item": "Running the check from a temporary directory doesn't stop .env from loading; isolate with explicit environment overrides.",
"q": "In a test that must not use the project's real API keys, is running it from a temporary directory enough?",
"key": [
"\\b(no|not enough|isn'?t enough|doesn'?t|does not|won'?t)\\b"
],
"partial": [
"environment|env var|monkeypatch|setenv|override"
]
},
{
"id": "C-035",
"item": "A deployed flow paused on @human_feedback shows state PAUSED and a flow_id on /status; answer it with AMP's POST /crewai_plus/api/v1/human_feedback_requests/:id/respond, not the deployment's raw /resume_feedback.",
"q": "A deployed flow is waiting on human feedback. How do I answer it through the API?",
"key": [
"human_feedback_requests"
],
"trap": [
"POST\\s+/resume_feedback"
]
},
{
"id": "C-036",
"item": "@persist restores nothing automatically: continue from a saved state with kickoff(restore_from_state_id=...); on AMP inputs.id is deprecated for restoreFromStateId.",
"q": "My flow uses @persist. After a crash, how do I continue from the saved state?",
"key": [
"restore_from_state_id|restoreFromStateId|state'?s? id"
],
"trap": [
"auto(matically)?[- ]?(recover|restor)"
]
},
{
"id": "C-037",
"item": "List live actions with `CrewaiPlatformTools(apps=['hubspot'])` and print their names; copy selectors from that, not PLATFORM_APPS (catalog names can differ).",
"q": "Where should you get the exact action names for a HubSpot integration selector?",
"key": [
"CrewaiPlatformTools",
"(print|list|names?)"
]
},
{
"id": "C-038",
"item": "No tools for an app means it isn't connected or the token is wrong; the user connects it on AMP's Integrations page (OAuth).",
"q": "CrewaiPlatformTools returns nothing for Salesforce. What does that mean, and who has to fix it?",
"key": [
"connect",
"(token|Integrations)"
]
},
{
"id": "C-039",
"item": "CrewAI warns only when every selector in an agent's apps resolves to nothing; a partial miss is silent, so check the trace.",
"q": "If one of an agent's integration selectors doesn't resolve, will CrewAI tell me?",
"key": [
"(only|all|none|every).*warn|(no|not) (a )?warn|silent|won'?t"
]
},
{
"id": "C-040",
"item": "With OpenAI models tool schemas are strict: free-form object arguments (HubSpot associations, Slack blocks) can only be sent empty, and every argument becomes required; call such actions from code or name the arguments in the task.",
"q": "An agent using an OpenAI model can't fill HubSpot's `associations` argument. Why, and what's the workaround?",
"key": [
"strict"
],
"partial": [
"(from code|in code|\\.run\\()"
]
},
{
"id": "C-041",
"item": "Call a decided action from code: `CrewaiPlatformTools(apps=['hubspot/create_note'])[0].run(**arguments)` and check the result is a success string (failures don't raise).",
"q": "The flow knows the exact note to create on a HubSpot record. How do you call that integration action directly from Python?",
"key": [
"CrewaiPlatformTools\\(apps=\\[",
"\\.run\\("
]
},
{
"id": "C-042",
"item": "Confirm side effects by reading them back with the app's read actions (e.g. slack/fetch_conversation_history), not from the run's report.",
"q": "How do you confirm that a Slack message the agent says it posted was really posted?",
"key": [
"(read|fetch|check)\\b.*(back|history|conversation|channel)|fetch_conversation_history"
]
},
{
"id": "C-043",
"item": "Pin an AMP skill as `@<org>/<handle>@<version>` (org UUID); bump on purpose, then evaluate again.",
"q": "When an agent uses a skill from our AMP account, how do you stop a newly published version from changing its behavior unexpectedly?",
"key": [
"@[\\w<>-]+/[\\w<>-]+@|pin"
]
},
{
"id": "C-044",
"item": "Skills are on-demand by default (name + description, loaded via the load_skill tool); load one up front with load_skills / resolve_registry_ref when every run needs it.",
"q": "A skill holds rules the writer must follow on every run. How do you make sure its full instructions are always in the prompt?",
"key": [
"load_skills?\\(|resolve_registry_ref"
]
},
{
"id": "C-045",
"item": "Skill resolution is local-first: ./skills/<handle>/, then ~/.crewai/skills/, then a download; `crewai skill install` copies into ./skills (only with pyproject.toml in cwd); a committed copy is what a deployment uses.",
"q": "Where does CrewAI look for a skill an agent references, and how do I make a deployment use a copy committed in the repo?",
"key": [
"\\./skills|skills/",
"(commit|vendor|install|copy)"
]
},
{
"id": "C-046",
"item": "A missing skill or wrong version fails when the agent is built.",
"q": "What happens if an agent references a skill version that doesn't exist?",
"key": [
"(fail|error|rais|exception)"
],
"partial": [
"(build|construct|creat|start|instantiat|load)"
]
},
{
"id": "C-047",
"item": "List the organization's repository agents on AMP's Agent Repository page or via GET /crewai_plus/api/v1/agents.",
"q": "How do I see which agents my organization keeps in AMP's agent repository?",
"key": [
"Agent Repository|/api/v1/agents"
]
},
{
"id": "C-048",
"item": "Load a repository agent with `Agent(from_repository='<handle>')` in the crew class, with no agents.yaml entry; it brings role, goal, backstory, apps, tools and skills.",
"q": "How do I use an agent my team already defined in AMP's agent repository inside this crew?",
"key": [
"from_repository"
]
},
{
"id": "C-049",
"item": "Override a repository agent's fields with keyword arguments (goal=, llm=); a YAML config can't override them and from_repository inside YAML fails (until A13).",
"q": "I want to reuse a repository agent but change its goal. Where do I put the override?",
"key": [
"(keyword|kwarg|goal=|Agent\\(.*goal)"
]
},
{
"id": "C-050",
"item": "Repository agents aren't pinned: an AMP edit changes every project on its next run, so evaluate again (their skills are pinned).",
"q": "If someone edits a repository agent in AMP, do projects that already load it change?",
"key": [
"(yes|change|not pinned|unpinned|next run|latest)"
]
},
{
"id": "C-051",
"item": "Deployments load repository agents too, through the client AMP installs in the runtime.",
"q": "Will a repository agent still load when this project runs as an AMP deployment?",
"key": [
"(yes|does|will|loads?)"
]
},
{
"id": "C-052",
"item": "Suggest publishing reusable skills (`crewai skill publish`) or agents; it writes to the shared org, so ask first.",
"q": "This project produced a reusable brand-voice skill. What should you do about it?",
"key": [
"skill publish",
"(ask|approv|confirm|permission|go.?ahead)"
]
},
{
"id": "C-053",
"item": "Unified memory: crewai.Memory with remember/recall, scopes and slices, stored locally (LanceDB); a crew takes memory=True or a Memory/scope/slice object and its agents get a recall tool (plus save unless read-only).",
"q": "Outside of flows, what's the current API for giving a crew long-term memory and reading it back?",
"key": [
"remember|recall|Memory\\("
],
"trap": [
"ChromaDB"
]
},
{
"id": "C-054",
"item": "Inside a flow don't create a second store: no separate Memory() and no Crew(memory=True) (that roots at /crew/<name>).",
"q": "Inside a flow, one crew needs memory. Should you set memory=True on that crew?",
"key": [
"\\b(no|don'?t|do not|shouldn'?t|instead)\\b"
],
"partial": [
"self\\.memory|flow'?s (own )?memory"
]
},
{
"id": "C-055",
"item": "Give a crew the flow's memory, read-only if wanted: `Crew(memory=self.memory.slice(scopes=['/lessons'], read_only=True))`.",
"q": "Inside a flow, how do I let one crew's agents read the flow's memories without letting them write new ones?",
"key": [
"slice\\(",
"read_only"
]
},
{
"id": "C-056",
"item": "Keep the flow class name stable: renaming it moves its memory to a new root.",
"q": "If I rename this flow's class, does anything happen to what it already remembered?",
"key": [
"(new|different|move|lose|lost|root|scope)"
]
},
{
"id": "C-057",
"item": "Git-sourced deploy failures (SSH URL, no GitHub access) show up later as 'Provisioning Failed' in deploy status, with the git error in deploy logs.",
"q": "My deployment from GitHub went to 'Provisioning Failed'. Where do I find out why?",
"key": [
"deploy (logs|status)"
]
},
{
"id": "C-058",
"item": "There's no way to force a ZIP deploy when an origin exists; create from a copy without one (until A5).",
"q": "My repo has a GitHub origin, but I want AMP to deploy an uploaded copy of the code instead. Can I?",
"key": [
"(copy|without (an? )?(git )?origin|no (such )?(flag|option)|can'?t|cannot|isn'?t)"
]
},
{
"id": "C-059",
"item": "`crewai deploy create` and `push` can exit 0 after a failed request; confirm with deploy status or deploy list.",
"q": "Can a script trust the exit code of `crewai deploy push` to know the push worked?",
"key": [
"\\b(no|not)\\b",
"deploy (status|list)"
]
},
{
"id": "C-060",
"item": "Prove the deployment runs your code: compare GET /inspect's flow_definition with `YourFlow.flow_definition().model_dump(mode='json')`, normalizing missing/false to null.",
"q": "How can you prove the deployed flow has the same structure as the flow in your local code?",
"key": [
"/inspect",
"flow_definition"
]
},
{
"id": "C-061",
"item": "A flow deployment's GET /inputs lists every state field, not just inputs, so send the state defaults with your overrides.",
"q": "What does a deployed flow's /inputs endpoint return?",
"key": [
"state"
]
},
{
"id": "C-062",
"item": "Run a deployment through its API: POST /kickoff {inputs} returns kickoff_id; poll GET /status/{kickoff_id} until SUCCESS/FAILED/REVOKED/PAUSED (an unknown id returns 200 'NOT FOUND').",
"q": "How do you run a deployed crew through its HTTP API and wait for the result?",
"key": [
"/kickoff",
"/status"
],
"partial": [
"kickoff_id"
]
},
{
"id": "C-063",
"item": "Exit 0 isn't enough: read the result, read side effects back, and run once per branch with side effects against agreed test targets.",
"q": "The deployed run came back SUCCESS. Is the deployment verified?",
"key": [
"(side effect|read .* back|check the (result|output)|result)"
]
},
{
"id": "C-064",
"item": "Schedules are set on the deployment page's Scheduling tab in AMP; there's no CLI or API for them.",
"q": "Once this is deployed, where do I set it to run every morning at 8?",
"key": [
"Scheduling"
]
},
{
"id": "C-065",
"item": "The deployment's bearer token (Status tab) belongs to that deployment and the API accepts any origin; keep it server-side, never in a browser, link or committed code.",
"q": "I want a small web page that calls the deployed crew straight from the browser using its bearer token. Is that OK?",
"key": [
"\\b(no|don'?t|do not|server|backend|proxy)\\b"
]
},
{
"id": "C-066",
"item": ".env is uploaded as the deployment's environment variables, so never put a deployment's URL or token in it.",
"q": "Can I store the deployment's URL and bearer token in this project's .env?",
"key": [
"(no|don'?t|do not|upload)"
]
},
{
"id": "C-067",
"item": "A flow's last step must return the result: a deployment's API returns what kickoff() returns, so a flow that only writes a file returns nothing.",
"q": "After deploying this flow, the API's result is empty even though the run succeeded. Why?",
"key": [
"return"
],
"partial": [
"(last|final) (step|method)|save_content"
]
},
{
"id": "C-068",
"item": "Running crewai login, crewai run or crewai deploy inside a project template writes a project_id every project made from it inherits.",
"q": "I'm building a reusable project template. Is it safe to run `crewai run` inside it while developing?",
"key": [
"project_id"
]
},
{
"id": "C-069",
"item": "List every new environment variable the project needs in .env.example.",
"q": "You added a new API key that the project needs. What else should you update besides .env?",
"key": [
"\\.env\\.example"
]
},
{
"id": "C-070",
"item": "Done: crewai eval passes with project-specific criteria; every flow branch passes the stubbed check; deployed with approval and provably running current code; an end-to-end API run per side-effect branch read back; uv.lock and project_id committed.",
"q": "What has to be true before you tell me this project is done?",
"key": [
"crewai eval",
"uv\\.lock"
],
"partial": [
"deploy"
]
},
{
"id": "C-071",
"item": "Your own measurements are welcome on top; report the crewai eval result next to them.",
"q": "You built your own scoring script to compare the posts. Is that enough evidence on its own?",
"key": [
"crewai eval"
]
},
{
"id": "C-072",
"item": "A sandboxed coding agent needs app.crewai.com, login.crewai.com, oss-wharf.crewai.com (traces), crewai-production.s3.us-west-2.amazonaws.com (skill downloads) and docs-platform.crewai.com reachable.",
"q": "I'm running you inside a network sandbox. Which hosts do CrewAI login, trace uploads and AMP skill downloads need?",
"key": [
"oss-wharf",
"login\\.crewai\\.com"
],
"partial": [
"app\\.crewai\\.com"
]
},
{
"id": "C-073",
"item": "Anyone with an anonymous (logged-out) trace link can read it; a logged-in trace is visible only within the organization.",
"q": "If I share a trace link from a logged-in run with someone outside my organization, can they open it?",
"key": [
"\\b(no|not|only)\\b|organi[sz]ation"
]
},
{
"id": "D-001",
"item": "Task guardrails: guardrail= / guardrails=, fn returns (ok, value_or_feedback).",
"q": "I want a task's output checked by my own code before it's accepted, and retried with feedback when the check fails. How do I do that in CrewAI?",
"key": [
"guardrail"
]
},
{
"id": "D-002",
"item": "Structured task output: output_pydantic / output_json, read result.pydantic.",
"q": "How do I make a crew task return a validated Pydantic object instead of text, and where do I read it after the run?",
"key": [
"output_pydantic",
"\\.pydantic"
],
"partial": [
"output_pydantic|output_json"
]
},
{
"id": "D-003",
"item": "Knowledge: knowledge_sources with StringKnowledgeSource / PDFKnowledgeSource.",
"q": "I want my agents to answer from a few PDFs and a text snippet I provide, without writing a retrieval tool. What does CrewAI offer for that?",
"key": [
"knowledge_sources"
],
"partial": [
"(PDF|String|TextFile)KnowledgeSource"
]
},
{
"id": "D-004",
"item": "Hierarchical process: Process.hierarchical with manager_llm or manager_agent.",
"q": "I want a manager agent to assign tasks to my other agents and check their work, instead of running the tasks in order. How do I set up that crew?",
"key": [
"Process\\.hierarchical|process\\s*[=:]\\s*['\\\"]?hierarchical",
"manager_(llm|agent)"
],
"partial": [
"hierarchical"
]
},
{
"id": "D-005",
"item": "Delegation: Agent(allow_delegation=True).",
"q": "How do I let one agent hand a subtask to a coworker agent in the same crew?",
"key": [
"allow_delegation\\s*[=:]\\s*True"
],
"partial": [
"allow_delegation"
]
},
{
"id": "D-006",
"item": "Planning: Crew(planning=True).",
"q": "Can a crew work out a plan for its tasks before it starts running them? What do I set?",
"key": [
"planning\\s*[=:]\\s*True"
],
"partial": [
"planning_config|planning_llm"
],
"trap": [
"reasoning\\s*=\\s*True"
]
},
{
"id": "D-007",
"item": "Batch and async kickoff: kickoff_for_each, akickoff, akickoff_for_each.",
"q": "I need to run the same crew for 50 different input dicts. What's the built-in way, and is there an async version?",
"key": [
"kickoff_for_each",
"akickoff_for_each|kickoff_for_each_async"
],
"partial": [
"kickoff_for_each"
]
},
{
"id": "D-008",
"item": "Streaming: stream=True on a crew or flow; iterate kickoff(), then .result.",
"q": "I want to show the crew's output in my UI as it's produced, chunk by chunk. How do I turn that on and get the final result at the end?",
"key": [
"stream\\s*[=:]\\s*True",
"\\.result"
],
"partial": [
"stream\\s*[=:]\\s*True"
]
},
{
"id": "D-009",
"item": "Events: BaseEventListener + crewai_event_bus.on in setup_listeners.",
"q": "I want to send every task completion from my crew to our own monitoring system, without changing the agents or tasks. What's the CrewAI mechanism?",
"key": [
"BaseEventListener"
],
"partial": [
"crewai_event_bus|event_bus\\.on"
]
},
{
"id": "D-010",
"item": "Kickoff hooks: @before_kickoff / @after_kickoff in @CrewBase.",
"q": "In a classic @CrewBase crew, how do I run code that cleans up the inputs right before the crew starts, and post-processes the result after it finishes?",
"key": [
"before_kickoff",
"after_kickoff"
],
"partial": [
"before_kickoff|after_kickoff"
]
},
{
"id": "D-011",
"item": "MCP: Agent(mcps=[url, slug, MCPServerStdio(...)]).",
"q": "My agent needs the tools from an MCP server I start locally with `npx my-mcp-server`. How do I give those tools to the agent?",
"key": [
"mcps\\s*[=:]",
"MCPServerStdio"
],
"partial": [
"mcps\\s*[=:]|MCPServer(Stdio|HTTP|SSE)|MCPServerAdapter"
]
},
{
"id": "D-012",
"item": "A2A: Agent(a2a=A2AClientConfig(endpoint=...)); A2AServerConfig exposes one.",
"q": "I want my CrewAI agent to delegate work to a remote agent that speaks the A2A protocol. What do I configure on the agent?",
"key": [
"A2AClientConfig|a2a\\s*=\\s*A2A"
],
"partial": [
"A2AConfig|crewai\\.a2a"
]
},
{
"id": "D-013",
"item": "Human feedback in flows: @human_feedback(message, emit=[...], llm=...).",
"q": "In my flow, a person should approve or reject a draft, and the flow should branch on their answer. What's the CrewAI way to do that?",
"key": [
"human_feedback"
]
},
{
"id": "D-014",
"item": "Conversational flows: conversational = True; test with handle_turn / stream_turn (crewai run needs a terminal).",
"q": "I'm building a chat assistant as a CrewAI flow that carries a conversation across turns. What does CrewAI give me for that, and how would you send it test messages from a script?",
"key": [
"conversational",
"handle_turn|stream_turn"
],
"partial": [
"conversational\\s*=\\s*True"
]
},
{
"id": "D-015",
"item": "Declarative flows: crewai create flow <name> --declarative, flow.yaml.",
"q": "Can I define a CrewAI flow in YAML instead of Python? How do I start a project like that?",
"key": [
"--declarative"
],
"partial": [
"flow\\.ya?ml"
]
},
{
"id": "D-016",
"item": "Checkpoints: Crew(checkpoint=True); kickoff(from_checkpoint=CheckpointConfig(restore_from=...)).",
"q": "A long crew run died halfway through. How can I make runs resumable, so the next attempt continues from where it stopped?",
"key": [
"checkpoint",
"from_checkpoint|restore_from"
],
"partial": [
"checkpoint"
]
},
{
"id": "D-017",
"item": "Flow conditions: or_ / and_ in @listen.",
"q": "In a flow, how do I make one step run when either of two earlier steps finishes, and another step run only once both have finished?",
"key": [
"or_\\(",
"and_\\("
],
"partial": [
"or_|and_"
]
},
{
"id": "D-018",
"item": "crewai_tools catalog: 100+ tools (SerperDevTool, ScrapeWebsiteTool); check before writing one.",
"q": "My agent needs to search the web and scrape pages. Should I write those tools myself?",
"key": [
"SerperDevTool|ScrapeWebsiteTool|WebsiteSearchTool|FirecrawlScrapeWebsiteTool|EXASearchTool|BraveSearchTool|TavilySearchTool"
],
"partial": [
"crewai_tools|crewai-tools"
]
},
{
"id": "D-019",
"item": "Files: kickoff(input_files={...: ImageFile(source=...)}) from crewai_files.",
"q": "I want to pass an image file to my crew so the agent can look at it. How do I hand it the file at kickoff?",
"key": [
"input_files"
],
"partial": [
"ImageFile"
],
"trap": [
"multimodal\\s*=\\s*True"
]
},
{
"id": "D-020",
"item": "Tool-call hooks: @on(InterceptionPoint.PRE_TOOL_CALL) from crewai.hooks runs before every tool call; raise HookAborted to block it.",
"q": "I want to block any tool call whose input contains a password, for every agent, without editing each tool. What does CrewAI give me for that?",
"key": [
"PRE_TOOL_CALL|before_tool_call"
],
"partial": [
"crewai\\.hooks|HookAborted|InterceptionPoint"
]
},
{
"id": "D-021",
"item": "LLM-call hooks: PRE_MODEL_CALL / POST_MODEL_CALL (or before_llm_call / after_llm_call) run on every LLM call.",
"q": "How can I log every LLM call my agents make, with the agent and how many messages it sent, without changing the agents or tasks?",
"key": [
"PRE_MODEL_CALL|POST_MODEL_CALL|before_llm_call|after_llm_call"
],
"partial": [
"BaseEventListener|LLMCall\\w*Event|crewai\\.hooks"
]
},
{
"id": "D-022",
"item": "Agent planning: Agent(planning_config=PlanningConfig(...)) makes the agent plan before acting; it replaces reasoning=True.",
"q": "How do I make one agent plan its steps before it starts working on a task?",
"key": [
"planning_config|PlanningConfig"
],
"trap": [
"reasoning\\s*=\\s*True"
]
},
{
"id": "E-001",
"item": "Logged out and without a terminal, `crewai eval` still gives a verdict: it runs the crew traced when the project changed, then AMP grades it; no account needed.",
"q": "I'm not logged in to CrewAI and my coding agent has no terminal. Can it still get a `crewai eval` verdict on a change it made?",
"key": [
"\\byes\\b|\\bit can\\b|\\bcan still\\b|works|no (account|login) (is )?(needed|required)|without (an account|logging in|a login)"
],
"trap": [
"(needs?|requires?|must)( you)?( to)? (be )?(log(ged)? ?in|an account|crewai login)",
"accept the trace prompt"
]
},
{
"id": "E-002",
"item": "After a change, `crewai eval` alone reruns the crew (traced) and grades it; no `crewai run` first.",
"q": "I changed a task's prompt. Do I have to `crewai run` the crew before `crewai eval` can grade the new version?",
"key": [
"\\bno\\b|not needed|don'?t (need|have)|(runs|reruns) (the crew|it)|on its own|by itself"
],
"trap": [
"\\byes\\b,? (you|first)"
]
}
]