Add single agent action to Flow definitions (#6226)

* Add single agent action to Flow definitions

Lets a flow method build and run a single CrewAI agent directly, without
wrapping it in a crew. Same idea as the existing `crew` action, but for
one agent.

  methods:
    answer:
      do:
        call: agent
        with:
          role: Analyst
          goal: Answer questions
          backstory: Knows things.
          input: "${state.question}"
      start: true

* `input` is required and interpolated from flow state, like
  `${state.question}` or `${item}` inside an `each` loop
* optional `response_format` points at a Pydantic model (`{"python":
  "models.AnswerModel"}`) to get structured output
* `input` must be a string and its CEL is validated at load time, so bad
  expressions like `${state.}` fail early

* Simplify test code

docs/docs.json

@@ -515,6 +515,7 @@
                       "edge/en/enterprise/guides/update-crew",
                       "edge/en/enterprise/guides/enable-crew-studio",
                       "edge/en/enterprise/guides/capture_telemetry_logs",
+                      "edge/en/enterprise/guides/datadog",
                       "edge/en/enterprise/guides/azure-openai-setup",
                       "edge/en/enterprise/guides/vertex-ai-workload-identity-setup",
                       "edge/en/enterprise/guides/tool-repository",
@@ -8647,6 +8648,7 @@
                       "edge/pt-BR/enterprise/guides/update-crew",
                       "edge/pt-BR/enterprise/guides/enable-crew-studio",
                       "edge/pt-BR/enterprise/guides/capture_telemetry_logs",
+                      "edge/pt-BR/enterprise/guides/datadog",
                       "edge/pt-BR/enterprise/guides/azure-openai-setup",
                       "edge/pt-BR/enterprise/guides/tool-repository",
                       "edge/pt-BR/enterprise/guides/custom-mcp-server",
@@ -16510,6 +16512,7 @@
                       "edge/ko/enterprise/guides/update-crew",
                       "edge/ko/enterprise/guides/enable-crew-studio",
                       "edge/ko/enterprise/guides/capture_telemetry_logs",
+                      "edge/ko/enterprise/guides/datadog",
                       "edge/ko/enterprise/guides/azure-openai-setup",
                       "edge/ko/enterprise/guides/tool-repository",
                       "edge/ko/enterprise/guides/custom-mcp-server",
@@ -24565,6 +24568,7 @@
                       "edge/ar/enterprise/guides/update-crew",
                       "edge/ar/enterprise/guides/enable-crew-studio",
                       "edge/ar/enterprise/guides/capture_telemetry_logs",
+                      "edge/ar/enterprise/guides/datadog",
                       "edge/ar/enterprise/guides/azure-openai-setup",
                       "edge/ar/enterprise/guides/tool-repository",
                       "edge/ar/enterprise/guides/custom-mcp-server",

docs/edge/ar/changelog.mdx

@@ -4,6 +4,28 @@ description: "تحديثات المنتج والتحسينات وإصلاحات
 icon: "clock"
 mode: "wide"
 ---
+<Update label="18 يونيو 2026">
+  ## v1.14.8a1
+
+  [عرض الإصدار على GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.14.8a1)
+
+  ## ما الذي تغير
+
+  ### الميزات
+  - إضافة تعبير if اختياري إلى خطوات each.do
+
+  ### إصلاحات الأخطاء
+  - إصلاح مشكلات JSON crew
+
+  ### الوثائق
+  - تحديث snapshot و changelog للإصدار v1.14.8a
+
+  ## المساهمون
+
+  @joaomdmoura, @vinibrsl
+
+</Update>
+
 <Update label="17 يونيو 2026">
   ## v1.14.8a
 

docs/edge/ar/enterprise/guides/capture_telemetry_logs.mdx

@@ -9,6 +9,10 @@ mode: "wide"
 
 تتبع بيانات القياس [اتفاقيات OpenTelemetry GenAI الدلالية](https://opentelemetry.io/docs/specs/semconv/gen-ai/) بالإضافة إلى سمات خاصة بـ CrewAI.
 
+<Tip>
+تُعدّ OpenTelemetry **مسار المراقبة الموصى به** — محايدة تجاه الموردين، وتعمل مع أي خلفية متوافقة مع OTLP (Grafana, Honeycomb, NewRelic، أو مجمّعك الخاص). إذا كنت تستخدم Datadog تحديدًا، فراجع دليل [تكامل Datadog](./datadog) المخصص، الذي يغطي كلًا من مسار وكيل Datadog واستيعاب OTLP من Datadog.
+</Tip>
+
 ## المتطلبات المسبقة
 
 <CardGroup cols={2}>
@@ -41,17 +45,7 @@ mode: "wide"
     <Frame>![تهيئة مجمّع OpenTelemetry](/images/crewai-otel-collector-opentelemetry.png)</Frame>
   </Tab>
   <Tab title="Datadog">
-    - **Datadog Site Domain** — مضيف OTLP لموقع Datadog الخاص بك فقط، دون بروتوكول أو مسار. يقوم CrewAI ببناء نقطة نهاية HTTPS OTLP الكاملة نيابةً عنك. استخدم المضيف المطابق لـ [موقع Datadog](https://docs.datadoghq.com/getting_started/site/) الخاص بك:
-      - `otlp.datadoghq.com` (US1)
-      - `otlp.us3.datadoghq.com` (US3)
-      - `otlp.us5.datadoghq.com` (US5)
-      - `otlp.datadoghq.eu` (EU1)
-      - `otlp.ap1.datadoghq.com` (AP1)
-    - **API Key** — مفتاح واجهة برمجة تطبيقات Datadog الخاص بك. راجع [كيفية إنشاء واحد](https://docs.datadoghq.com/account_management/api-app-keys/#api-keys).
-
-    يصدّر تكامل Datadog **التتبعات**.
-
-    <Frame>![تهيئة مجمّع Datadog](/images/crewai-otel-collector-datadog.png)</Frame>
+    لإعداد Datadog، راجع دليل [تكامل Datadog](./datadog) المخصص — فهو يغطي كلًا من مسار وكيل Datadog (الموصى به، أرخص لحجم السجلات الكبير) واستيعاب OTLP من Datadog، مع خطوات تهيئة كاملة للمجمّع.
   </Tab>
 </Tabs>
 

docs/edge/ar/enterprise/guides/datadog.mdx

@@ -0,0 +1,295 @@
+---
+title: "تكامل Datadog"
+description: "راقب عمليات نشر CrewAI AMP المُستضافة ذاتيًا في Datadog عبر وكيل Datadog أو استيعاب OTLP من Datadog — يوفر كلا المسارين نفس الواجهات المهيكلة لاستيراد لوحة معلومات العمليات الجاهزة."
+icon: "dog"
+mode: "wide"
+---
+
+<Note>
+**الترجمة قيد التقدم** — يتم عرض المحتوى باللغة الإنجليزية.
+</Note>
+
+CrewAI ships first-class support for Datadog: two log-ingestion paths, a JSON log schema designed for cheap indexing, and a ready-made operations dashboard you can import in under five minutes.
+
+<Note>
+For vendor-neutral observability via any OTLP backend (Grafana, Honeycomb, your own collector), see [OpenTelemetry Export](./capture_telemetry_logs).
+</Note>
+
+## Choose a path
+
+CrewAI supports two log-ingestion paths to Datadog — both are first-class and produce the same structured facets that power the dashboard. Pick the one that fits your infrastructure.
+
+<Tabs>
+  <Tab title="Datadog Agent">
+    The Datadog Agent runs alongside your CrewAI containers (typically as a DaemonSet on Kubernetes) and tails their stdout. With `CREWAI_LOG_FORMAT=json` set, each log event ships as a single billable line with structured attributes.
+
+    **Setup:**
+    1. Run the Datadog Agent next to your CrewAI containers — see [Datadog's deployment docs](https://docs.datadoghq.com/agent/) for Kubernetes, ECS, or VM setup. Enable log collection (`logs_enabled: true`) and container log collection (`logs_config.container_collect_all: true`).
+    2. Set `CREWAI_LOG_FORMAT=json` as an **automation environment variable** in CrewAI AMP (open your automation → **Settings → Environment Variables**) so each log event is a single line instead of a multi-line traceback. AMP propagates the value to every container in the deployment (API + workers) — don't set it on the container or host directly. See [Enabling JSON output](#enabling-json-output) below for the AMP UI walkthrough and the [log schema reference](#log-schema-reference) for the full field contract.
+    3. Confirm logs arrive in Datadog Logs with the JSON fields parsed — see [Verify ingestion](#verify-ingestion).
+
+    **Pick this path if** you already operate Datadog Agents (e.g. for infrastructure metrics), or your log volume makes per-event ingestion cost a real concern — collapsing tracebacks into single events keeps Agent ingestion cheap at scale.
+  </Tab>
+  <Tab title="Datadog OTLP intake">
+    CrewAI AMP exports OpenTelemetry traffic directly to Datadog's OTLP endpoint with no Agent required. Logs and traces ride a single export pipeline configured in AMP's UI, using the same protocol you'd use for any other OTLP backend.
+
+    **Setup:**
+    1. In CrewAI AMP, go to **Settings → OpenTelemetry Collectors → Add Collector** and pick **Datadog**.
+    2. Configure the connection:
+       - **Datadog Site Domain** — your Datadog site's OTLP host only, no protocol or path. CrewAI builds the full HTTPS OTLP endpoint for you. Use the host that matches your [Datadog site](https://docs.datadoghq.com/getting_started/site/):
+         - `otlp.datadoghq.com` (US1)
+         - `otlp.us3.datadoghq.com` (US3)
+         - `otlp.us5.datadoghq.com` (US5)
+         - `otlp.datadoghq.eu` (EU1)
+         - `otlp.ap1.datadoghq.com` (AP1)
+       - **API Key** — your Datadog API key. See [how to create one](https://docs.datadoghq.com/account_management/api-app-keys/#api-keys).
+    3. The Datadog template provisions **both signals at once** — when you save, AMP creates a traces collector at `/v1/traces` and a logs collector at `/v1/logs`, both sharing the same Datadog OTLP host and API key. You'll see them as two separate rows in your OTel collectors list.
+    4. *(optional)* Click **Test Connection** to verify CrewAI can reach the endpoint with the credentials you provided. Then click **Save** — both collectors are created in one step.
+
+    <Frame>![Datadog collector configuration](/images/crewai-otel-collector-datadog.png)</Frame>
+
+    **Pick this path if** you'd rather not operate a Datadog Agent, you already use OTLP for traces and want one export pipeline, or you may later want to fan out the same telemetry to other backends (Grafana, Honeycomb, etc.) without changing your application setup.
+  </Tab>
+</Tabs>
+
+Either path lands the same structured facets in Datadog (`@automation_id`, `@kickoff_id`, `@execution_id`, `@automation_name`, `@crewai_version`, `@exception.type`, `@gen_ai.*`), so the dashboard works identically with either choice.
+
+## Log schema reference
+
+<Info>
+This schema applies to the **Datadog Agent path** — stdout JSON logs produced when `CREWAI_LOG_FORMAT=json` is set. Logs delivered via the **Datadog OTLP intake** use OpenTelemetry attribute names and may differ; see [OpenTelemetry Export](./capture_telemetry_logs).
+</Info>
+
+When `CREWAI_LOG_FORMAT=json` is set, every log event is emitted as a **single JSON object per line** to stdout, with internal newlines escaped. The format is plain JSON — Datadog parses it natively, and the same payload is also consumable by Splunk, Loki, Elasticsearch, and CloudWatch without custom log pipelines.
+
+### Why JSON output
+
+<CardGroup cols={2}>
+  <Card title="Lower ingestion cost" icon="dollar-sign">
+    Most managed log backends bill per event. A Python traceback in text format is counted as one event per line — 30+ events for a single error. JSON output collapses each traceback into a single event with the stack trace as an escaped string field.
+  </Card>
+  <Card title="Structured search" icon="magnifying-glass">
+    Search by `@automation_id`, `@exception.type`, `@kickoff_id` instead of grepping free-text. Build dashboards on typed facets without parser configuration.
+  </Card>
+  <Card title="APM ↔ logs correlation" icon="link">
+    Every event carries `trace_id` and `span_id` when fired inside a recording span, so backends auto-link logs to traces.
+  </Card>
+  <Card title="Stable contract" icon="file-shield">
+    The `schema` field gates compatibility — within `v1`, fields are added but never renamed or removed.
+  </Card>
+</CardGroup>
+
+### Enabling JSON output
+
+`CREWAI_LOG_FORMAT=json` must be set as an **automation environment variable** in CrewAI AMP — it is **not** a container, host, or Docker setting. Open your automation in AMP, click the **Settings** icon, and add the variable under the **Environment Variables** section. AMP applies the value to every container in the deployment (API + workers) on the next restart. See [Update Your Crew](./update-crew) for the full UI walkthrough with screenshots.
+
+```shell
+CREWAI_LOG_FORMAT=json
+```
+
+Restart the deployment to pick up the change. Every log line on stdout from that point on is a single JSON object.
+
+<Note>
+  The default value is `text`, which preserves the legacy human-readable line format byte-for-byte. Setting any value other than `json` falls back to text mode. There is no migration step — the variable is read at process start and the format switches immediately.
+</Note>
+
+### Example events
+
+A single info-level log inside an active automation kickoff:
+
+```json
+{
+  "schema": "v1",
+  "ts": "2026-06-17T16:14:23.482914Z",
+  "level": "INFO",
+  "logger": "crewai_enterprise.utilities.pii_redaction",
+  "crewai_version": "1.14.7",
+  "msg": "PII tracking state reset (engines preserved)",
+  "automation_id": "12",
+  "task_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "kickoff_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "execution_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "automation_name": "research_flow"
+}
+```
+
+An error with a Python exception is collapsed into a single event with the traceback as a string:
+
+```json
+{
+  "schema": "v1",
+  "ts": "2026-06-17T16:14:31.218450Z",
+  "level": "ERROR",
+  "logger": "api.tasks.flow_run_task",
+  "crewai_version": "1.14.7",
+  "msg": "Flow execution failed",
+  "automation_id": "12",
+  "kickoff_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "execution_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "automation_name": "research_flow",
+  "exception": {
+    "type": "ValueError",
+    "message": "Topic cannot be empty",
+    "stacktrace": "Traceback (most recent call last):\n  File \"/app/flow.py\", line 42, in summarize\n    ...\nValueError: Topic cannot be empty\n"
+  }
+}
+```
+
+The same error in legacy text mode would have produced ~25 separate log events (one per traceback line) — all of which the backend would bill and index individually.
+
+### Schema v1 fields
+
+Within the `v1` schema, fields are only added, never renamed or removed. New fields will appear as soon as a deployment is upgraded.
+
+| Field | Type | Always present | Source |
+|-------|------|----------------|--------|
+| `schema` | string | Yes | Constant `"v1"`. Increment indicates a breaking schema change. |
+| `ts` | string (ISO-8601 UTC, microseconds) | Yes | Record creation time, e.g. `2026-06-17T16:14:23.482914Z`. |
+| `level` | string | Yes | Python log level name: `DEBUG` / `INFO` / `WARNING` / `ERROR` / `CRITICAL`. |
+| `logger` | string | Yes | Dotted logger name, e.g. `api.tasks.flow_run_task`. |
+| `crewai_version` | string | Yes (when `crewai` package metadata is resolvable) | Installed `crewai` package version, e.g. `"1.14.7"`. |
+| `msg` | string | Yes | Rendered log message (after `%`-formatting / `{}`-formatting). |
+| `automation_id` | string | When `CREWAI_PLUS_ID` env var is set | Numeric deployment ID (AMP provisions this on every container). |
+| `task_id` | string | On Celery worker logs | Celery task UUID, or `"no-task"` for non-task contexts. |
+| `kickoff_id` | string | Inside an automation kickoff | UUID of the current kickoff. |
+| `execution_id` | string | Inside an automation kickoff | UUID of the current sub-execution. Equal to `kickoff_id` at the top level; differs for nested flow methods that spawn sub-executions. |
+| `automation_name` | string | Inside an automation kickoff | Human-readable automation/flow name, e.g. `"research_flow"`. |
+| `trace_id` | string (32-hex) | Inside a recording OpenTelemetry span | Hex trace ID. Omitted when no span is active. |
+| `span_id` | string (16-hex) | Inside a recording OpenTelemetry span | Hex span ID. Omitted when no span is active. |
+| `exception` | object | When the log record has `exc_info` | `{type, message, stacktrace}` — full traceback as a single escaped string. |
+
+<Tip>
+  Any additional `extra={...}` kwargs passed to a logger call appear as top-level JSON fields verbatim. Reserved field names above always win to keep the schema stable.
+</Tip>
+
+### Stability promise
+
+The `schema` field declares the contract. Within `v1`, CrewAI commits to:
+
+- **Never removing a field** that customers may have built queries or dashboards against.
+- **Never renaming a field** in place — renames happen via a schema bump (e.g. `v2`), with the old name kept as a deprecated alias for at least one release cycle.
+- **Adding new fields** at any time. Consumers should ignore unknown top-level keys.
+
+When a `v2` is introduced, both the `schema` field and the migration guide will be published in advance, and `v1` will continue to be emitted for one release cycle so dashboards and queries have time to migrate.
+
+## Prerequisite: promote facets
+
+Datadog auto-discovers fields the first time it sees them but doesn't make them queryable in widgets until they're promoted to **facets**. This is a one-time setup in your Datadog account.
+
+<Steps>
+  <Step title="Search for a CrewAI log">
+    Open [Logs Explorer](https://app.datadoghq.com/logs) and search `service:crewai*`. You should see at least one log event.
+  </Step>
+  <Step title="Promote each field">
+    Click any log entry to open the right-hand details panel. For each field below, hover the field name → click the gear icon → **Create facet**.
+
+    - `automation_id`, `automation_name`, `execution_id`, `kickoff_id`, `task_id`
+    - `crewai_version`, `model_id`
+    - `exception.type`, `exception.message`
+
+    Skip any field that already shows a star icon next to its name — that means it's already a facet. The `gen_ai.usage.input_tokens`, `gen_ai.usage.output_tokens`, and `gen_ai.request.model` facets are typically promoted automatically by Datadog's LLM Observability auto-discovery, but verify they exist before importing the dashboard.
+  </Step>
+</Steps>
+
+## Import the dashboard
+
+<Steps>
+  <Step title="Download the dashboard JSON">
+    Save [`datadog_dashboard.json`](https://raw.githubusercontent.com/crewAIInc/crewAI/main/docs/edge/en/enterprise/guides/datadog_dashboard.json) to your machine.
+  </Step>
+  <Step title="Open the import dialog in Datadog">
+    Navigate to **Dashboards → New Dashboard**. Click the **gear icon** in the top right of the empty dashboard and select **Import Dashboard JSON**.
+  </Step>
+  <Step title="Paste or upload the JSON">
+    Paste the contents of `datadog_dashboard.json` into the import dialog (or drag the file in). Click **Import**.
+
+    Datadog creates the dashboard immediately and lands you on it. The first load may show empty widgets for a few seconds while queries execute against the time range.
+  </Step>
+</Steps>
+
+<Tip>
+  Datadog's [Dashboard API](https://docs.datadoghq.com/api/latest/dashboards/#create-a-new-dashboard) accepts the same JSON via `POST /api/v1/dashboard`. Use it if you manage dashboards through Terraform, Pulumi, or CI.
+</Tip>
+
+## What you get
+
+The dashboard is organized into four sections plus a placeholder for a custom drill-down widget:
+
+| Section | Widgets | Useful for |
+|---------|---------|------------|
+| **Header** | Total Executions · Error Rate (%) · Active Automations · CrewAI Versions in Use | At-a-glance health for the last hour. Error Rate is conditionally formatted (green ≤ 5%, yellow ≤ 10%, red > 10%). |
+| **Throughput** | Executions per Hour by Automation (top 10, stacked bars) | Spotting traffic shifts, surfacing busy automations, validating that a rollout didn't change baseline volume. |
+| **Errors** | Errors by Exception Type (top 5, stacked bars) · Top Exception Types by Count (toplist) | Triaging failures — which exception types are spiking, which automations they're hitting. |
+| **Cost** | Total Tokens per Hour by Model (input + output, stacked area) | Tracking LLM token spend by model. Useful for catching cost regressions when an automation switches model or starts looping. |
+| **Drill-Down** | _(empty placeholder)_ | See [Customization](#customize) for adding a recent-errors log stream here. |
+
+Three template variables at the top of the dashboard re-scope every widget at once:
+
+- **`$automation`** — filter to a single automation by name.
+- **`$version`** — filter to a single `crewai` SDK version (useful for comparing pre- and post-upgrade behavior).
+- **`$service`** — filter to a specific Datadog `service` tag (useful when multiple CrewAI deployments share one Datadog account).
+
+## Verify ingestion
+
+Open [Logs Explorer](https://app.datadoghq.com/logs) and run a query that matches your ingestion path:
+
+<Tabs>
+  <Tab title="Datadog Agent">
+    Search `service:crewai* @schema:v1`. You should see structured logs with the JSON fields parsed into Datadog facets. Pick a recent event and verify it has `@automation_id`, `@kickoff_id`, `@execution_id`, `@crewai_version`, and (when running inside a span) `@trace_id` / `@span_id` populated.
+
+    If nothing appears, confirm `CREWAI_LOG_FORMAT=json` is set under your automation's **Environment Variables** in AMP, the deployment was restarted after the change, and the Datadog Agent is tailing container stdout.
+  </Tab>
+  <Tab title="Datadog OTLP intake">
+    Search `source:otlp service:crewai*`. OTLP attributes land with their OpenTelemetry names (`automation_id`, `crewai.kickoff.id`, etc.) rather than the stdout JSON keys, but they map to the same dashboard facets after [facet promotion](#prerequisite-promote-facets).
+
+    If nothing appears, verify the collector endpoint is correct (`/v1/logs` for logs, `/v1/traces` for traces) and **Test Connection** succeeded when the collector was saved.
+  </Tab>
+</Tabs>
+
+## Customize
+
+The dashboard ships with deliberate gaps so you can extend it without uninstalling and re-importing.
+
+### Add a Recent Errors log stream
+
+The **Drill-Down** section is intentionally empty. Add a Log Stream widget to it for an inline view of recent failures:
+
+1. Edit the dashboard and click **+ Add Widgets** inside the Drill-Down group.
+2. Drag in a **Log Stream** widget.
+3. Set the filter query to `status:error $automation $version $service`.
+4. Choose columns: `@timestamp`, `@automation_name`, `@exception.type`, `@exception.message`, `@execution_id`.
+5. Sort by most recent, limit to 25 entries.
+
+Clicking any row jumps to Logs Explorer with the same filter pre-applied.
+
+### Add p95 latency
+
+Logs don't include execution duration by default. Two ways to add a latency widget:
+
+- **From APM traces** — if you also export OTLP traces to Datadog, add a Timeseries widget with data source **Traces**, query `service:crewai*`, aggregation `p95 of @duration`. Datadog APM auto-tracks span duration.
+- **From metric extraction** — extract a `flow.duration_ms` metric from logs via [Datadog's log-to-metric pipeline](https://docs.datadoghq.com/logs/log_configuration/logs_to_metrics/), then chart it like any other metric. Useful if you don't run APM.
+
+### Re-scope to multiple deployments
+
+The `$service` template variable defaults to `*` and will catch every CrewAI deployment in your Datadog account. Change the default to a specific service name in **Configure → Template Variables** if you want the dashboard to focus on one deployment by default.
+
+## Troubleshooting
+
+| Symptom | Likely cause | Fix |
+|---------|--------------|-----|
+| All widgets show "No data" | Facets aren't promoted | Re-do the [Promote facets](#prerequisite-promote-facets) step. Datadog won't query against an un-promoted field. |
+| Error Rate widget shows `NaN` | No executions in the time window | Either no traffic, or `@execution_id` isn't faceted. Expand the time range and re-check facets. |
+| Throughput chart is flat at the same value | Logs aren't reaching Datadog | Search `service:crewai*` in Logs Explorer. If nothing shows, verify the Datadog Agent is running (Agent path) or the OTel collector endpoint is correct (OTLP path). |
+| `crewai_version` shows fewer values than expected | Some containers predate the structured-logs work | The `crewai_version` field was added alongside JSON output. Older deployments running text mode (or older AMP builds) won't emit it. Upgrade those deployments to pick up the field. See the [log schema reference](#log-schema-reference) for the full field contract. |
+| Template variables don't filter widgets | The widget's filter line doesn't reference the template variable | Edit the widget and confirm the search includes `$automation $version $service`. |
+
+## Next steps
+
+<CardGroup cols={2}>
+  <Card title="OpenTelemetry Export" icon="magnifying-glass-chart" href="./capture_telemetry_logs">
+    Vendor-neutral observability for non-Datadog stacks (Grafana, Honeycomb, your own collector) — or as a Datadog complement when you want to fan out telemetry to multiple backends.
+  </Card>
+  <Card title="Datadog Log Search Syntax" icon="magnifying-glass" href="https://docs.datadoghq.com/logs/explorer/search_syntax/">
+    Reference for customizing widget queries against the structured facets above.
+  </Card>
+</CardGroup>

docs/edge/en/changelog.mdx

@@ -4,6 +4,28 @@ description: "Product updates, improvements, and bug fixes for CrewAI"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="Jun 18, 2026">
+  ## v1.14.8a1
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.14.8a1)
+
+  ## What's Changed
+
+  ### Features
+  - Add optional if expression to each.do steps
+
+  ### Bug Fixes
+  - Fix JSON crew issues
+
+  ### Documentation
+  - Update snapshot and changelog for v1.14.8a
+
+  ## Contributors
+
+  @joaomdmoura, @vinibrsl
+
+</Update>
+
 <Update label="Jun 17, 2026">
   ## v1.14.8a
 

docs/edge/en/enterprise/guides/capture_telemetry_logs.mdx

@@ -9,6 +9,10 @@ CrewAI AMP can export OpenTelemetry **traces** and **logs** from your deployment
 
 Telemetry data follows the [OpenTelemetry GenAI semantic conventions](https://opentelemetry.io/docs/specs/semconv/gen-ai/) plus additional CrewAI-specific attributes.
 
+<Tip>
+OpenTelemetry is the **recommended observability path** — vendor-neutral, works with any OTLP-compatible backend (Grafana, Honeycomb, NewRelic, your own collector). If you specifically use Datadog, see the dedicated [Datadog Integration](./datadog) guide which covers both the Datadog Agent path and Datadog's OTLP intake.
+</Tip>
+
 ## Prerequisites
 
 <CardGroup cols={2}>
@@ -41,17 +45,7 @@ Telemetry data follows the [OpenTelemetry GenAI semantic conventions](https://op
     <Frame>![OpenTelemetry collector configuration](/images/crewai-otel-collector-opentelemetry.png)</Frame>
   </Tab>
   <Tab title="Datadog">
-    - **Datadog Site Domain** — Your Datadog site's OTLP host only, with no protocol or path. CrewAI builds the full HTTPS OTLP endpoint for you. Use the host that matches your [Datadog site](https://docs.datadoghq.com/getting_started/site/):
-      - `otlp.datadoghq.com` (US1)
-      - `otlp.us3.datadoghq.com` (US3)
-      - `otlp.us5.datadoghq.com` (US5)
-      - `otlp.datadoghq.eu` (EU1)
-      - `otlp.ap1.datadoghq.com` (AP1)
-    - **API Key** — Your Datadog API key. See [how to create one](https://docs.datadoghq.com/account_management/api-app-keys/#api-keys).
-
-    The Datadog integration exports **traces**.
-
-    <Frame>![Datadog collector configuration](/images/crewai-otel-collector-datadog.png)</Frame>
+    For Datadog setup, see the dedicated [Datadog Integration](./datadog) guide — it covers both the Datadog Agent path (recommended, cheaper for log volume) and Datadog's OTLP intake with full collector configuration steps.
   </Tab>
 </Tabs>
 

docs/edge/en/enterprise/guides/datadog.mdx

@@ -0,0 +1,291 @@
+---
+title: "Datadog Integration"
+description: "Monitor self-hosted CrewAI AMP deployments in Datadog via the Datadog Agent or Datadog's OTLP intake — either path lands the same structured facets so you can import the ready-made operations dashboard."
+icon: "dog"
+mode: "wide"
+---
+
+CrewAI ships first-class support for Datadog: two log-ingestion paths, a JSON log schema designed for cheap indexing, and a ready-made operations dashboard you can import in under five minutes.
+
+<Note>
+For vendor-neutral observability via any OTLP backend (Grafana, Honeycomb, your own collector), see [OpenTelemetry Export](./capture_telemetry_logs).
+</Note>
+
+## Choose a path
+
+CrewAI supports two log-ingestion paths to Datadog — both are first-class and produce the same structured facets that power the dashboard. Pick the one that fits your infrastructure.
+
+<Tabs>
+  <Tab title="Datadog Agent">
+    The Datadog Agent runs alongside your CrewAI containers (typically as a DaemonSet on Kubernetes) and tails their stdout. With `CREWAI_LOG_FORMAT=json` set, each log event ships as a single billable line with structured attributes.
+
+    **Setup:**
+    1. Run the Datadog Agent next to your CrewAI containers — see [Datadog's deployment docs](https://docs.datadoghq.com/agent/) for Kubernetes, ECS, or VM setup. Enable log collection (`logs_enabled: true`) and container log collection (`logs_config.container_collect_all: true`).
+    2. Set `CREWAI_LOG_FORMAT=json` as an **automation environment variable** in CrewAI AMP (open your automation → **Settings → Environment Variables**) so each log event is a single line instead of a multi-line traceback. AMP propagates the value to every container in the deployment (API + workers) — don't set it on the container or host directly. See [Enabling JSON output](#enabling-json-output) below for the AMP UI walkthrough and the [log schema reference](#log-schema-reference) for the full field contract.
+    3. Confirm logs arrive in Datadog Logs with the JSON fields parsed — see [Verify ingestion](#verify-ingestion).
+
+    **Pick this path if** you already operate Datadog Agents (e.g. for infrastructure metrics), or your log volume makes per-event ingestion cost a real concern — collapsing tracebacks into single events keeps Agent ingestion cheap at scale.
+  </Tab>
+  <Tab title="Datadog OTLP intake">
+    CrewAI AMP exports OpenTelemetry traffic directly to Datadog's OTLP endpoint with no Agent required. Logs and traces ride a single export pipeline configured in AMP's UI, using the same protocol you'd use for any other OTLP backend.
+
+    **Setup:**
+    1. In CrewAI AMP, go to **Settings → OpenTelemetry Collectors → Add Collector** and pick **Datadog**.
+    2. Configure the connection:
+       - **Datadog Site Domain** — your Datadog site's OTLP host only, no protocol or path. CrewAI builds the full HTTPS OTLP endpoint for you. Use the host that matches your [Datadog site](https://docs.datadoghq.com/getting_started/site/):
+         - `otlp.datadoghq.com` (US1)
+         - `otlp.us3.datadoghq.com` (US3)
+         - `otlp.us5.datadoghq.com` (US5)
+         - `otlp.datadoghq.eu` (EU1)
+         - `otlp.ap1.datadoghq.com` (AP1)
+       - **API Key** — your Datadog API key. See [how to create one](https://docs.datadoghq.com/account_management/api-app-keys/#api-keys).
+    3. The Datadog template provisions **both signals at once** — when you save, AMP creates a traces collector at `/v1/traces` and a logs collector at `/v1/logs`, both sharing the same Datadog OTLP host and API key. You'll see them as two separate rows in your OTel collectors list.
+    4. *(optional)* Click **Test Connection** to verify CrewAI can reach the endpoint with the credentials you provided. Then click **Save** — both collectors are created in one step.
+
+    <Frame>![Datadog collector configuration](/images/crewai-otel-collector-datadog.png)</Frame>
+
+    **Pick this path if** you'd rather not operate a Datadog Agent, you already use OTLP for traces and want one export pipeline, or you may later want to fan out the same telemetry to other backends (Grafana, Honeycomb, etc.) without changing your application setup.
+  </Tab>
+</Tabs>
+
+Either path lands the same structured facets in Datadog (`@automation_id`, `@kickoff_id`, `@execution_id`, `@automation_name`, `@crewai_version`, `@exception.type`, `@gen_ai.*`), so the dashboard works identically with either choice.
+
+## Log schema reference
+
+<Info>
+This schema applies to the **Datadog Agent path** — stdout JSON logs produced when `CREWAI_LOG_FORMAT=json` is set. Logs delivered via the **Datadog OTLP intake** use OpenTelemetry attribute names and may differ; see [OpenTelemetry Export](./capture_telemetry_logs).
+</Info>
+
+When `CREWAI_LOG_FORMAT=json` is set, every log event is emitted as a **single JSON object per line** to stdout, with internal newlines escaped. The format is plain JSON — Datadog parses it natively, and the same payload is also consumable by Splunk, Loki, Elasticsearch, and CloudWatch without custom log pipelines.
+
+### Why JSON output
+
+<CardGroup cols={2}>
+  <Card title="Lower ingestion cost" icon="dollar-sign">
+    Most managed log backends bill per event. A Python traceback in text format is counted as one event per line — 30+ events for a single error. JSON output collapses each traceback into a single event with the stack trace as an escaped string field.
+  </Card>
+  <Card title="Structured search" icon="magnifying-glass">
+    Search by `@automation_id`, `@exception.type`, `@kickoff_id` instead of grepping free-text. Build dashboards on typed facets without parser configuration.
+  </Card>
+  <Card title="APM ↔ logs correlation" icon="link">
+    Every event carries `trace_id` and `span_id` when fired inside a recording span, so backends auto-link logs to traces.
+  </Card>
+  <Card title="Stable contract" icon="file-shield">
+    The `schema` field gates compatibility — within `v1`, fields are added but never renamed or removed.
+  </Card>
+</CardGroup>
+
+### Enabling JSON output
+
+`CREWAI_LOG_FORMAT=json` must be set as an **automation environment variable** in CrewAI AMP — it is **not** a container, host, or Docker setting. Open your automation in AMP, click the **Settings** icon, and add the variable under the **Environment Variables** section. AMP applies the value to every container in the deployment (API + workers) on the next restart. See [Update Your Crew](./update-crew) for the full UI walkthrough with screenshots.
+
+```shell
+CREWAI_LOG_FORMAT=json
+```
+
+Restart the deployment to pick up the change. Every log line on stdout from that point on is a single JSON object.
+
+<Note>
+  The default value is `text`, which preserves the legacy human-readable line format byte-for-byte. Setting any value other than `json` falls back to text mode. There is no migration step — the variable is read at process start and the format switches immediately.
+</Note>
+
+### Example events
+
+A single info-level log inside an active automation kickoff:
+
+```json
+{
+  "schema": "v1",
+  "ts": "2026-06-17T16:14:23.482914Z",
+  "level": "INFO",
+  "logger": "crewai_enterprise.utilities.pii_redaction",
+  "crewai_version": "1.14.7",
+  "msg": "PII tracking state reset (engines preserved)",
+  "automation_id": "12",
+  "task_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "kickoff_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "execution_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "automation_name": "research_flow"
+}
+```
+
+An error with a Python exception is collapsed into a single event with the traceback as a string:
+
+```json
+{
+  "schema": "v1",
+  "ts": "2026-06-17T16:14:31.218450Z",
+  "level": "ERROR",
+  "logger": "api.tasks.flow_run_task",
+  "crewai_version": "1.14.7",
+  "msg": "Flow execution failed",
+  "automation_id": "12",
+  "kickoff_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "execution_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "automation_name": "research_flow",
+  "exception": {
+    "type": "ValueError",
+    "message": "Topic cannot be empty",
+    "stacktrace": "Traceback (most recent call last):\n  File \"/app/flow.py\", line 42, in summarize\n    ...\nValueError: Topic cannot be empty\n"
+  }
+}
+```
+
+The same error in legacy text mode would have produced ~25 separate log events (one per traceback line) — all of which the backend would bill and index individually.
+
+### Schema v1 fields
+
+Within the `v1` schema, fields are only added, never renamed or removed. New fields will appear as soon as a deployment is upgraded.
+
+| Field | Type | Always present | Source |
+|-------|------|----------------|--------|
+| `schema` | string | Yes | Constant `"v1"`. Increment indicates a breaking schema change. |
+| `ts` | string (ISO-8601 UTC, microseconds) | Yes | Record creation time, e.g. `2026-06-17T16:14:23.482914Z`. |
+| `level` | string | Yes | Python log level name: `DEBUG` / `INFO` / `WARNING` / `ERROR` / `CRITICAL`. |
+| `logger` | string | Yes | Dotted logger name, e.g. `api.tasks.flow_run_task`. |
+| `crewai_version` | string | Yes (when `crewai` package metadata is resolvable) | Installed `crewai` package version, e.g. `"1.14.7"`. |
+| `msg` | string | Yes | Rendered log message (after `%`-formatting / `{}`-formatting). |
+| `automation_id` | string | When `CREWAI_PLUS_ID` env var is set | Numeric deployment ID (AMP provisions this on every container). |
+| `task_id` | string | On Celery worker logs | Celery task UUID, or `"no-task"` for non-task contexts. |
+| `kickoff_id` | string | Inside an automation kickoff | UUID of the current kickoff. |
+| `execution_id` | string | Inside an automation kickoff | UUID of the current sub-execution. Equal to `kickoff_id` at the top level; differs for nested flow methods that spawn sub-executions. |
+| `automation_name` | string | Inside an automation kickoff | Human-readable automation/flow name, e.g. `"research_flow"`. |
+| `trace_id` | string (32-hex) | Inside a recording OpenTelemetry span | Hex trace ID. Omitted when no span is active. |
+| `span_id` | string (16-hex) | Inside a recording OpenTelemetry span | Hex span ID. Omitted when no span is active. |
+| `exception` | object | When the log record has `exc_info` | `{type, message, stacktrace}` — full traceback as a single escaped string. |
+
+<Tip>
+  Any additional `extra={...}` kwargs passed to a logger call appear as top-level JSON fields verbatim. Reserved field names above always win to keep the schema stable.
+</Tip>
+
+### Stability promise
+
+The `schema` field declares the contract. Within `v1`, CrewAI commits to:
+
+- **Never removing a field** that customers may have built queries or dashboards against.
+- **Never renaming a field** in place — renames happen via a schema bump (e.g. `v2`), with the old name kept as a deprecated alias for at least one release cycle.
+- **Adding new fields** at any time. Consumers should ignore unknown top-level keys.
+
+When a `v2` is introduced, both the `schema` field and the migration guide will be published in advance, and `v1` will continue to be emitted for one release cycle so dashboards and queries have time to migrate.
+
+## Prerequisite: promote facets
+
+Datadog auto-discovers fields the first time it sees them but doesn't make them queryable in widgets until they're promoted to **facets**. This is a one-time setup in your Datadog account.
+
+<Steps>
+  <Step title="Search for a CrewAI log">
+    Open [Logs Explorer](https://app.datadoghq.com/logs) and search `service:crewai*`. You should see at least one log event.
+  </Step>
+  <Step title="Promote each field">
+    Click any log entry to open the right-hand details panel. For each field below, hover the field name → click the gear icon → **Create facet**.
+
+    - `automation_id`, `automation_name`, `execution_id`, `kickoff_id`, `task_id`
+    - `crewai_version`, `model_id`
+    - `exception.type`, `exception.message`
+
+    Skip any field that already shows a star icon next to its name — that means it's already a facet. The `gen_ai.usage.input_tokens`, `gen_ai.usage.output_tokens`, and `gen_ai.request.model` facets are typically promoted automatically by Datadog's LLM Observability auto-discovery, but verify they exist before importing the dashboard.
+  </Step>
+</Steps>
+
+## Import the dashboard
+
+<Steps>
+  <Step title="Download the dashboard JSON">
+    Save [`datadog_dashboard.json`](https://raw.githubusercontent.com/crewAIInc/crewAI/main/docs/edge/en/enterprise/guides/datadog_dashboard.json) to your machine.
+  </Step>
+  <Step title="Open the import dialog in Datadog">
+    Navigate to **Dashboards → New Dashboard**. Click the **gear icon** in the top right of the empty dashboard and select **Import Dashboard JSON**.
+  </Step>
+  <Step title="Paste or upload the JSON">
+    Paste the contents of `datadog_dashboard.json` into the import dialog (or drag the file in). Click **Import**.
+
+    Datadog creates the dashboard immediately and lands you on it. The first load may show empty widgets for a few seconds while queries execute against the time range.
+  </Step>
+</Steps>
+
+<Tip>
+  Datadog's [Dashboard API](https://docs.datadoghq.com/api/latest/dashboards/#create-a-new-dashboard) accepts the same JSON via `POST /api/v1/dashboard`. Use it if you manage dashboards through Terraform, Pulumi, or CI.
+</Tip>
+
+## What you get
+
+The dashboard is organized into four sections plus a placeholder for a custom drill-down widget:
+
+| Section | Widgets | Useful for |
+|---------|---------|------------|
+| **Header** | Total Executions · Error Rate (%) · Active Automations · CrewAI Versions in Use | At-a-glance health for the last hour. Error Rate is conditionally formatted (green ≤ 5%, yellow ≤ 10%, red > 10%). |
+| **Throughput** | Executions per Hour by Automation (top 10, stacked bars) | Spotting traffic shifts, surfacing busy automations, validating that a rollout didn't change baseline volume. |
+| **Errors** | Errors by Exception Type (top 5, stacked bars) · Top Exception Types by Count (toplist) | Triaging failures — which exception types are spiking, which automations they're hitting. |
+| **Cost** | Total Tokens per Hour by Model (input + output, stacked area) | Tracking LLM token spend by model. Useful for catching cost regressions when an automation switches model or starts looping. |
+| **Drill-Down** | _(empty placeholder)_ | See [Customization](#customize) for adding a recent-errors log stream here. |
+
+Three template variables at the top of the dashboard re-scope every widget at once:
+
+- **`$automation`** — filter to a single automation by name.
+- **`$version`** — filter to a single `crewai` SDK version (useful for comparing pre- and post-upgrade behavior).
+- **`$service`** — filter to a specific Datadog `service` tag (useful when multiple CrewAI deployments share one Datadog account).
+
+## Verify ingestion
+
+Open [Logs Explorer](https://app.datadoghq.com/logs) and run a query that matches your ingestion path:
+
+<Tabs>
+  <Tab title="Datadog Agent">
+    Search `service:crewai* @schema:v1`. You should see structured logs with the JSON fields parsed into Datadog facets. Pick a recent event and verify it has `@automation_id`, `@kickoff_id`, `@execution_id`, `@crewai_version`, and (when running inside a span) `@trace_id` / `@span_id` populated.
+
+    If nothing appears, confirm `CREWAI_LOG_FORMAT=json` is set under your automation's **Environment Variables** in AMP, the deployment was restarted after the change, and the Datadog Agent is tailing container stdout.
+  </Tab>
+  <Tab title="Datadog OTLP intake">
+    Search `source:otlp service:crewai*`. OTLP attributes land with their OpenTelemetry names (`automation_id`, `crewai.kickoff.id`, etc.) rather than the stdout JSON keys, but they map to the same dashboard facets after [facet promotion](#prerequisite-promote-facets).
+
+    If nothing appears, verify the collector endpoint is correct (`/v1/logs` for logs, `/v1/traces` for traces) and **Test Connection** succeeded when the collector was saved.
+  </Tab>
+</Tabs>
+
+## Customize
+
+The dashboard ships with deliberate gaps so you can extend it without uninstalling and re-importing.
+
+### Add a Recent Errors log stream
+
+The **Drill-Down** section is intentionally empty. Add a Log Stream widget to it for an inline view of recent failures:
+
+1. Edit the dashboard and click **+ Add Widgets** inside the Drill-Down group.
+2. Drag in a **Log Stream** widget.
+3. Set the filter query to `status:error $automation $version $service`.
+4. Choose columns: `@timestamp`, `@automation_name`, `@exception.type`, `@exception.message`, `@execution_id`.
+5. Sort by most recent, limit to 25 entries.
+
+Clicking any row jumps to Logs Explorer with the same filter pre-applied.
+
+### Add p95 latency
+
+Logs don't include execution duration by default. Two ways to add a latency widget:
+
+- **From APM traces** — if you also export OTLP traces to Datadog, add a Timeseries widget with data source **Traces**, query `service:crewai*`, aggregation `p95 of @duration`. Datadog APM auto-tracks span duration.
+- **From metric extraction** — extract a `flow.duration_ms` metric from logs via [Datadog's log-to-metric pipeline](https://docs.datadoghq.com/logs/log_configuration/logs_to_metrics/), then chart it like any other metric. Useful if you don't run APM.
+
+### Re-scope to multiple deployments
+
+The `$service` template variable defaults to `*` and will catch every CrewAI deployment in your Datadog account. Change the default to a specific service name in **Configure → Template Variables** if you want the dashboard to focus on one deployment by default.
+
+## Troubleshooting
+
+| Symptom | Likely cause | Fix |
+|---------|--------------|-----|
+| All widgets show "No data" | Facets aren't promoted | Re-do the [Promote facets](#prerequisite-promote-facets) step. Datadog won't query against an un-promoted field. |
+| Error Rate widget shows `NaN` | No executions in the time window | Either no traffic, or `@execution_id` isn't faceted. Expand the time range and re-check facets. |
+| Throughput chart is flat at the same value | Logs aren't reaching Datadog | Search `service:crewai*` in Logs Explorer. If nothing shows, verify the Datadog Agent is running (Agent path) or the OTel collector endpoint is correct (OTLP path). |
+| `crewai_version` shows fewer values than expected | Some containers predate the structured-logs work | The `crewai_version` field was added alongside JSON output. Older deployments running text mode (or older AMP builds) won't emit it. Upgrade those deployments to pick up the field. See the [log schema reference](#log-schema-reference) for the full field contract. |
+| Template variables don't filter widgets | The widget's filter line doesn't reference the template variable | Edit the widget and confirm the search includes `$automation $version $service`. |
+
+## Next steps
+
+<CardGroup cols={2}>
+  <Card title="OpenTelemetry Export" icon="magnifying-glass-chart" href="./capture_telemetry_logs">
+    Vendor-neutral observability for non-Datadog stacks (Grafana, Honeycomb, your own collector) — or as a Datadog complement when you want to fan out telemetry to multiple backends.
+  </Card>
+  <Card title="Datadog Log Search Syntax" icon="magnifying-glass" href="https://docs.datadoghq.com/logs/explorer/search_syntax/">
+    Reference for customizing widget queries against the structured facets above.
+  </Card>
+</CardGroup>

docs/edge/en/enterprise/guides/datadog_dashboard.json

@@ -0,0 +1,582 @@
+{
+  "title": "crewAI -- Operations",
+  "description": "Monitoring dashboard for self-hosted crewAI deployments running structured JSON logs. Tracks executions, errors, token usage, and automation health.",
+  "widgets": [
+    {
+      "id": 8810001,
+      "definition": {
+        "title": "Header",
+        "background_color": "vivid_blue",
+        "show_title": true,
+        "type": "group",
+        "layout_type": "ordered",
+        "widgets": [
+          {
+            "id": 9910001,
+            "definition": {
+              "title": "Total Executions",
+              "time": {
+                "live_span": "1h"
+              },
+              "type": "query_value",
+              "requests": [
+                {
+                  "response_format": "scalar",
+                  "queries": [
+                    {
+                      "data_source": "logs",
+                      "name": "query1",
+                      "search": {
+                        "query": "$automation $version $service"
+                      },
+                      "compute": {
+                        "aggregation": "cardinality",
+                        "metric": "@execution_id"
+                      },
+                      "indexes": [
+                        "*"
+                      ]
+                    }
+                  ],
+                  "formulas": [
+                    {
+                      "formula": "query1"
+                    }
+                  ]
+                }
+              ],
+              "autoscale": true,
+              "precision": 0
+            },
+            "layout": {
+              "x": 0,
+              "y": 0,
+              "width": 3,
+              "height": 2
+            }
+          },
+          {
+            "id": 9910002,
+            "definition": {
+              "title": "Error Rate (%)",
+              "time": {
+                "live_span": "1h"
+              },
+              "type": "query_value",
+              "requests": [
+                {
+                  "response_format": "scalar",
+                  "queries": [
+                    {
+                      "data_source": "logs",
+                      "name": "query1",
+                      "search": {
+                        "query": "status:error $automation $version $service"
+                      },
+                      "compute": {
+                        "aggregation": "count"
+                      },
+                      "indexes": [
+                        "*"
+                      ]
+                    },
+                    {
+                      "data_source": "logs",
+                      "name": "query2",
+                      "search": {
+                        "query": "$automation $version $service"
+                      },
+                      "compute": {
+                        "aggregation": "cardinality",
+                        "metric": "@execution_id"
+                      },
+                      "indexes": [
+                        "*"
+                      ]
+                    }
+                  ],
+                  "formulas": [
+                    {
+                      "formula": "query1 / query2 * 100"
+                    }
+                  ],
+                  "conditional_formats": [
+                    {
+                      "comparator": ">",
+                      "value": 10,
+                      "palette": "white_on_red"
+                    },
+                    {
+                      "comparator": ">",
+                      "value": 5,
+                      "palette": "white_on_yellow"
+                    },
+                    {
+                      "comparator": ">=",
+                      "value": 0,
+                      "palette": "white_on_green"
+                    }
+                  ]
+                }
+              ],
+              "autoscale": false,
+              "custom_unit": "%",
+              "precision": 2
+            },
+            "layout": {
+              "x": 3,
+              "y": 0,
+              "width": 3,
+              "height": 2
+            }
+          },
+          {
+            "id": 9910003,
+            "definition": {
+              "title": "Active Automations",
+              "time": {
+                "live_span": "1h"
+              },
+              "type": "query_value",
+              "requests": [
+                {
+                  "response_format": "scalar",
+                  "queries": [
+                    {
+                      "data_source": "logs",
+                      "name": "query1",
+                      "search": {
+                        "query": "$automation $version $service"
+                      },
+                      "compute": {
+                        "aggregation": "cardinality",
+                        "metric": "@automation_id"
+                      },
+                      "indexes": [
+                        "*"
+                      ]
+                    }
+                  ],
+                  "formulas": [
+                    {
+                      "formula": "query1"
+                    }
+                  ]
+                }
+              ],
+              "autoscale": true,
+              "precision": 0
+            },
+            "layout": {
+              "x": 6,
+              "y": 0,
+              "width": 3,
+              "height": 2
+            }
+          },
+          {
+            "id": 9910004,
+            "definition": {
+              "title": "CrewAI Versions in Use",
+              "time": {
+                "live_span": "1h"
+              },
+              "type": "query_value",
+              "requests": [
+                {
+                  "response_format": "scalar",
+                  "queries": [
+                    {
+                      "data_source": "logs",
+                      "name": "query1",
+                      "search": {
+                        "query": "$automation $version $service"
+                      },
+                      "compute": {
+                        "aggregation": "cardinality",
+                        "metric": "@crewai_version"
+                      },
+                      "indexes": [
+                        "*"
+                      ]
+                    }
+                  ],
+                  "formulas": [
+                    {
+                      "formula": "query1"
+                    }
+                  ]
+                }
+              ],
+              "autoscale": true,
+              "precision": 0
+            },
+            "layout": {
+              "x": 9,
+              "y": 0,
+              "width": 3,
+              "height": 2
+            }
+          }
+        ]
+      },
+      "layout": {
+        "x": 0,
+        "y": 0,
+        "width": 12,
+        "height": 3
+      }
+    },
+    {
+      "id": 8820001,
+      "definition": {
+        "title": "Throughput",
+        "background_color": "vivid_green",
+        "show_title": true,
+        "type": "group",
+        "layout_type": "ordered",
+        "widgets": [
+          {
+            "id": 9920001,
+            "definition": {
+              "title": "Executions per Hour by Automation (top 10)",
+              "show_legend": false,
+              "type": "timeseries",
+              "requests": [
+                {
+                  "response_format": "timeseries",
+                  "queries": [
+                    {
+                      "data_source": "logs",
+                      "name": "query1",
+                      "search": {
+                        "query": "$automation $version $service"
+                      },
+                      "compute": {
+                        "aggregation": "cardinality",
+                        "metric": "@execution_id",
+                        "interval": 3600000
+                      },
+                      "group_by": [
+                        {
+                          "facet": "@automation_name",
+                          "limit": 10,
+                          "sort": {
+                            "aggregation": "cardinality",
+                            "metric": "@execution_id",
+                            "order": "desc"
+                          }
+                        }
+                      ],
+                      "indexes": [
+                        "*"
+                      ]
+                    }
+                  ],
+                  "formulas": [
+                    {
+                      "formula": "query1"
+                    }
+                  ],
+                  "style": {
+                    "palette": "semantic"
+                  },
+                  "display_type": "bars"
+                }
+              ]
+            },
+            "layout": {
+              "x": 0,
+              "y": 0,
+              "width": 12,
+              "height": 3
+            }
+          }
+        ]
+      },
+      "layout": {
+        "x": 0,
+        "y": 3,
+        "width": 12,
+        "height": 4
+      }
+    },
+    {
+      "id": 8830001,
+      "definition": {
+        "title": "Errors",
+        "background_color": "vivid_orange",
+        "show_title": true,
+        "type": "group",
+        "layout_type": "ordered",
+        "widgets": [
+          {
+            "id": 9930001,
+            "definition": {
+              "title": "Errors by Exception Type (top 5)",
+              "show_legend": false,
+              "type": "timeseries",
+              "requests": [
+                {
+                  "response_format": "timeseries",
+                  "queries": [
+                    {
+                      "data_source": "logs",
+                      "name": "query1",
+                      "search": {
+                        "query": "status:error $automation $version $service"
+                      },
+                      "compute": {
+                        "aggregation": "count"
+                      },
+                      "group_by": [
+                        {
+                          "facet": "@exception.type",
+                          "limit": 5,
+                          "sort": {
+                            "aggregation": "count",
+                            "order": "desc"
+                          }
+                        }
+                      ],
+                      "indexes": [
+                        "*"
+                      ]
+                    }
+                  ],
+                  "formulas": [
+                    {
+                      "formula": "query1"
+                    }
+                  ],
+                  "style": {
+                    "palette": "warm"
+                  },
+                  "display_type": "bars"
+                }
+              ]
+            },
+            "layout": {
+              "x": 0,
+              "y": 0,
+              "width": 6,
+              "height": 3
+            }
+          },
+          {
+            "id": 9930002,
+            "definition": {
+              "title": "Top Exception Types by Count",
+              "type": "toplist",
+              "requests": [
+                {
+                  "response_format": "scalar",
+                  "queries": [
+                    {
+                      "data_source": "logs",
+                      "name": "query1",
+                      "search": {
+                        "query": "status:error $automation $version $service"
+                      },
+                      "compute": {
+                        "aggregation": "count"
+                      },
+                      "group_by": [
+                        {
+                          "facet": "@exception.type",
+                          "limit": 10,
+                          "sort": {
+                            "aggregation": "count",
+                            "order": "desc"
+                          }
+                        }
+                      ],
+                      "indexes": [
+                        "*"
+                      ]
+                    }
+                  ],
+                  "formulas": [
+                    {
+                      "formula": "query1"
+                    }
+                  ],
+                  "sort": {
+                    "count": 10,
+                    "order_by": [
+                      {
+                        "type": "formula",
+                        "index": 0,
+                        "order": "desc"
+                      }
+                    ]
+                  }
+                }
+              ],
+              "style": {
+                "palette": "datadog16"
+              }
+            },
+            "layout": {
+              "x": 6,
+              "y": 0,
+              "width": 6,
+              "height": 3
+            }
+          }
+        ]
+      },
+      "layout": {
+        "x": 0,
+        "y": 7,
+        "width": 12,
+        "height": 4
+      }
+    },
+    {
+      "id": 8840001,
+      "definition": {
+        "title": "Cost",
+        "background_color": "vivid_purple",
+        "show_title": true,
+        "type": "group",
+        "layout_type": "ordered",
+        "widgets": [
+          {
+            "id": 9940001,
+            "definition": {
+              "title": "Total Tokens per Hour by Model (input + output)",
+              "show_legend": false,
+              "type": "timeseries",
+              "requests": [
+                {
+                  "response_format": "timeseries",
+                  "queries": [
+                    {
+                      "data_source": "logs",
+                      "name": "query1",
+                      "search": {
+                        "query": "$automation $version $service"
+                      },
+                      "compute": {
+                        "aggregation": "sum",
+                        "metric": "@gen_ai.usage.input_tokens",
+                        "interval": 3600000
+                      },
+                      "group_by": [
+                        {
+                          "facet": "@gen_ai.request.model",
+                          "limit": 10,
+                          "sort": {
+                            "aggregation": "sum",
+                            "metric": "@gen_ai.usage.input_tokens",
+                            "order": "desc"
+                          }
+                        }
+                      ],
+                      "indexes": [
+                        "*"
+                      ]
+                    },
+                    {
+                      "data_source": "logs",
+                      "name": "query2",
+                      "search": {
+                        "query": "$automation $version $service"
+                      },
+                      "compute": {
+                        "aggregation": "sum",
+                        "metric": "@gen_ai.usage.output_tokens",
+                        "interval": 3600000
+                      },
+                      "group_by": [
+                        {
+                          "facet": "@gen_ai.request.model",
+                          "limit": 10,
+                          "sort": {
+                            "aggregation": "sum",
+                            "metric": "@gen_ai.usage.output_tokens",
+                            "order": "desc"
+                          }
+                        }
+                      ],
+                      "indexes": [
+                        "*"
+                      ]
+                    }
+                  ],
+                  "formulas": [
+                    {
+                      "formula": "query1 + query2",
+                      "alias": "Total Tokens"
+                    }
+                  ],
+                  "style": {
+                    "palette": "cool"
+                  },
+                  "display_type": "area"
+                }
+              ]
+            },
+            "layout": {
+              "x": 0,
+              "y": 0,
+              "width": 12,
+              "height": 3
+            }
+          }
+        ]
+      },
+      "layout": {
+        "x": 0,
+        "y": 11,
+        "width": 12,
+        "height": 4
+      }
+    },
+    {
+      "id": 8850002,
+      "definition": {
+        "title": "Drill-Down",
+        "background_color": "gray",
+        "show_title": true,
+        "type": "group",
+        "layout_type": "ordered",
+        "widgets": []
+      },
+      "layout": {
+        "x": 0,
+        "y": 15,
+        "width": 12,
+        "height": 1
+      }
+    }
+  ],
+  "template_variables": [
+    {
+      "name": "automation",
+      "prefix": "@automation_name",
+      "available_values": [],
+      "default": "*"
+    },
+    {
+      "name": "version",
+      "prefix": "@crewai_version",
+      "available_values": [],
+      "default": "*"
+    },
+    {
+      "name": "service",
+      "prefix": "service",
+      "available_values": [],
+      "default": "*"
+    }
+  ],
+  "layout_type": "ordered",
+  "notify_list": [],
+  "pause_auto_refresh": false,
+  "reflow_type": "fixed",
+  "tags": [
+    "ai:created_with_ai"
+  ]
+}

docs/edge/en/index.mdx

@@ -28,6 +28,60 @@ mode: "wide"
 
   <div style={{ display: 'flex', flexWrap: 'wrap', gap: 12, justifyContent: 'center' }}>
     <a className="button button-primary" href="/en/quickstart">Get started</a>
+    <button
+      type="button"
+      className="button"
+      onClick={async (event) => {
+        const prompt = `Set up this environment so I can build with CrewAI.
+
+First install the official CrewAI coding-agent skills if this environment supports npx:
+
+npx skills add crewaiinc/skills
+
+If npx is missing or the current agent cannot load skills, do not fail the whole setup. Report the exact issue and continue using the CrewAI docs directly.
+
+Use these CrewAI docs as source of truth before making assumptions:
+- https://skills.crewai.com
+- https://docs.crewai.com/llms.txt
+- https://docs.crewai.com/en/installation
+- https://docs.crewai.com/en/guides/coding-tools/build-with-ai
+
+Setup steps:
+1. Check python3 --version. CrewAI requires Python >=3.10 and <3.14.
+2. Install uv if missing:
+   curl -LsSf https://astral.sh/uv/install.sh | sh
+3. Source the uv environment if needed:
+   source "$HOME/.local/bin/env"
+4. Install the CrewAI CLI:
+   uv tool install crewai
+5. Verify the CLI:
+   crewai version
+   crewai create --help
+6. Create a project:
+   CREWAI_DMN=true crewai create
+7. After project creation, inspect the generated files before editing.
+8. Run:
+   crewai install
+   crewai run
+
+Do not hardcode API keys. Use .env.
+Do not invent CLI flags. Validate with crewai --help or crewai create --help.
+If a command fails, show the exact command and error, explain the likely cause, fix what you can safely fix, and retry once.`;
+        const button = event.currentTarget;
+        try {
+          await navigator.clipboard.writeText(prompt);
+          button.textContent = "Copied";
+        } catch {
+          button.textContent = "Copy failed";
+        } finally {
+          window.setTimeout(() => {
+            button.textContent = "Copy instructions for coding agents";
+          }, 1600);
+        }
+      }}
+    >
+      Copy instructions for coding agents
+    </button>
     <a className="button" href="/en/changelog">View changelog</a>
     <a className="button" href="/en/api-reference/introduction">API Reference</a>
   </div>

docs/edge/en/installation.mdx

@@ -9,7 +9,60 @@ mode: "wide"
 
 Install our coding agent skills (Claude Code, Codex, ...) to quickly get your coding agents up and running with CrewAI.
 
-You can install it with `npx skills add crewaiinc/skills`
+<button
+  type="button"
+  className="button button-primary"
+  onClick={async (event) => {
+    const prompt = `Set up this environment so I can build with CrewAI.
+
+First install the official CrewAI coding-agent skills if this environment supports npx:
+
+npx skills add crewaiinc/skills
+
+If npx is missing or the current agent cannot load skills, do not fail the whole setup. Report the exact issue and continue using the CrewAI docs directly.
+
+Use these CrewAI docs as source of truth before making assumptions:
+- https://skills.crewai.com
+- https://docs.crewai.com/llms.txt
+- https://docs.crewai.com/en/installation
+- https://docs.crewai.com/en/guides/coding-tools/build-with-ai
+
+Setup steps:
+1. Check python3 --version. CrewAI requires Python >=3.10 and <3.14.
+2. Install uv if missing:
+   curl -LsSf https://astral.sh/uv/install.sh | sh
+3. Source the uv environment if needed:
+   source "$HOME/.local/bin/env"
+4. Install the CrewAI CLI:
+   uv tool install crewai
+5. Verify the CLI:
+   crewai version
+   crewai create --help
+6. Create a project:
+   CREWAI_DMN=true crewai create
+7. After project creation, inspect the generated files before editing.
+8. Run:
+   crewai install
+   crewai run
+
+Do not hardcode API keys. Use .env.
+Do not invent CLI flags. Validate with crewai --help or crewai create --help.
+If a command fails, show the exact command and error, explain the likely cause, fix what you can safely fix, and retry once.`;
+    const button = event.currentTarget;
+    try {
+      await navigator.clipboard.writeText(prompt);
+      button.textContent = "Copied";
+    } catch {
+      button.textContent = "Copy failed";
+    } finally {
+      window.setTimeout(() => {
+        button.textContent = "Copy instructions for coding agents";
+      }, 1600);
+    }
+  }}
+>
+  Copy instructions for coding agents
+</button>
 
 <iframe src="https://www.loom.com/embed/befb9f68b81f42ad8112bfdd95a780af" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style={{width: "100%", height: "400px"}}></iframe>
 

docs/edge/ko/changelog.mdx

@@ -4,6 +4,28 @@ description: "CrewAI의 제품 업데이트, 개선 사항 및 버그 수정"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="2026년 6월 18일">
+  ## v1.14.8a1
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.14.8a1)
+
+  ## 변경 사항
+
+  ### 기능
+  - 각 do 단계에 선택적 if 표현식을 추가
+
+  ### 버그 수정
+  - JSON 크루 문제 수정
+
+  ### 문서
+  - v1.14.8a의 스냅샷 및 변경 로그 업데이트
+
+  ## 기여자
+
+  @joaomdmoura, @vinibrsl
+
+</Update>
+
 <Update label="2026년 6월 17일">
   ## v1.14.8a
 

docs/edge/ko/enterprise/guides/capture_telemetry_logs.mdx

@@ -9,6 +9,10 @@ CrewAI AMP는 배포에서 OpenTelemetry **트레이스**와 **로그**를 자
 
 텔레메트리 데이터는 [OpenTelemetry GenAI 시맨틱 규칙](https://opentelemetry.io/docs/specs/semconv/gen-ai/)과 추가적인 CrewAI 전용 속성을 따릅니다.
 
+<Tip>
+OpenTelemetry는 **권장되는 관측 가능성 경로**입니다 — 벤더 중립적이며, OTLP 호환 백엔드(Grafana, Honeycomb, NewRelic, 자체 수집기)에서 작동합니다. Datadog을 사용하는 경우, Datadog Agent 경로와 Datadog의 OTLP 수집을 모두 다루는 전용 [Datadog 통합](./datadog) 가이드를 참조하세요.
+</Tip>
+
 ## 사전 요구 사항
 
 <CardGroup cols={2}>
@@ -41,17 +45,7 @@ CrewAI AMP는 배포에서 OpenTelemetry **트레이스**와 **로그**를 자
     <Frame>![OpenTelemetry 수집기 구성](/images/crewai-otel-collector-opentelemetry.png)</Frame>
   </Tab>
   <Tab title="Datadog">
-    - **Datadog Site Domain** — Datadog 사이트의 OTLP 호스트만 입력합니다 (프로토콜이나 경로 제외). CrewAI가 전체 HTTPS OTLP 엔드포인트를 자동으로 구성합니다. [Datadog 사이트](https://docs.datadoghq.com/getting_started/site/)에 맞는 호스트를 사용하세요:
-      - `otlp.datadoghq.com` (US1)
-      - `otlp.us3.datadoghq.com` (US3)
-      - `otlp.us5.datadoghq.com` (US5)
-      - `otlp.datadoghq.eu` (EU1)
-      - `otlp.ap1.datadoghq.com` (AP1)
-    - **API Key** — Datadog API 키입니다. [키 생성 방법](https://docs.datadoghq.com/account_management/api-app-keys/#api-keys)을 참고하세요.
-
-    Datadog 통합은 **트레이스**를 내보냅니다.
-
-    <Frame>![Datadog 수집기 구성](/images/crewai-otel-collector-datadog.png)</Frame>
+    Datadog 설정은 전용 [Datadog 통합](./datadog) 가이드를 참조하세요 — Datadog Agent 경로(권장, 로그 볼륨에 더 저렴)와 Datadog의 OTLP 수집을 모두 다루며, 수집기 구성 단계를 완전히 설명합니다.
   </Tab>
 </Tabs>
 

docs/edge/ko/enterprise/guides/datadog.mdx

@@ -0,0 +1,295 @@
+---
+title: "Datadog 통합"
+description: "Datadog Agent 또는 Datadog의 OTLP 수집을 통해 자체 호스팅 CrewAI AMP 배포를 Datadog에서 모니터링하세요 — 두 경로 모두 동일한 구조화된 패싯을 생성하므로 기성 운영 대시보드를 가져올 수 있습니다."
+icon: "dog"
+mode: "wide"
+---
+
+<Note>
+**번역 진행 중** — 콘텐츠가 영어로 표시됩니다.
+</Note>
+
+CrewAI ships first-class support for Datadog: two log-ingestion paths, a JSON log schema designed for cheap indexing, and a ready-made operations dashboard you can import in under five minutes.
+
+<Note>
+For vendor-neutral observability via any OTLP backend (Grafana, Honeycomb, your own collector), see [OpenTelemetry Export](./capture_telemetry_logs).
+</Note>
+
+## Choose a path
+
+CrewAI supports two log-ingestion paths to Datadog — both are first-class and produce the same structured facets that power the dashboard. Pick the one that fits your infrastructure.
+
+<Tabs>
+  <Tab title="Datadog Agent">
+    The Datadog Agent runs alongside your CrewAI containers (typically as a DaemonSet on Kubernetes) and tails their stdout. With `CREWAI_LOG_FORMAT=json` set, each log event ships as a single billable line with structured attributes.
+
+    **Setup:**
+    1. Run the Datadog Agent next to your CrewAI containers — see [Datadog's deployment docs](https://docs.datadoghq.com/agent/) for Kubernetes, ECS, or VM setup. Enable log collection (`logs_enabled: true`) and container log collection (`logs_config.container_collect_all: true`).
+    2. Set `CREWAI_LOG_FORMAT=json` as an **automation environment variable** in CrewAI AMP (open your automation → **Settings → Environment Variables**) so each log event is a single line instead of a multi-line traceback. AMP propagates the value to every container in the deployment (API + workers) — don't set it on the container or host directly. See [Enabling JSON output](#enabling-json-output) below for the AMP UI walkthrough and the [log schema reference](#log-schema-reference) for the full field contract.
+    3. Confirm logs arrive in Datadog Logs with the JSON fields parsed — see [Verify ingestion](#verify-ingestion).
+
+    **Pick this path if** you already operate Datadog Agents (e.g. for infrastructure metrics), or your log volume makes per-event ingestion cost a real concern — collapsing tracebacks into single events keeps Agent ingestion cheap at scale.
+  </Tab>
+  <Tab title="Datadog OTLP intake">
+    CrewAI AMP exports OpenTelemetry traffic directly to Datadog's OTLP endpoint with no Agent required. Logs and traces ride a single export pipeline configured in AMP's UI, using the same protocol you'd use for any other OTLP backend.
+
+    **Setup:**
+    1. In CrewAI AMP, go to **Settings → OpenTelemetry Collectors → Add Collector** and pick **Datadog**.
+    2. Configure the connection:
+       - **Datadog Site Domain** — your Datadog site's OTLP host only, no protocol or path. CrewAI builds the full HTTPS OTLP endpoint for you. Use the host that matches your [Datadog site](https://docs.datadoghq.com/getting_started/site/):
+         - `otlp.datadoghq.com` (US1)
+         - `otlp.us3.datadoghq.com` (US3)
+         - `otlp.us5.datadoghq.com` (US5)
+         - `otlp.datadoghq.eu` (EU1)
+         - `otlp.ap1.datadoghq.com` (AP1)
+       - **API Key** — your Datadog API key. See [how to create one](https://docs.datadoghq.com/account_management/api-app-keys/#api-keys).
+    3. The Datadog template provisions **both signals at once** — when you save, AMP creates a traces collector at `/v1/traces` and a logs collector at `/v1/logs`, both sharing the same Datadog OTLP host and API key. You'll see them as two separate rows in your OTel collectors list.
+    4. *(optional)* Click **Test Connection** to verify CrewAI can reach the endpoint with the credentials you provided. Then click **Save** — both collectors are created in one step.
+
+    <Frame>![Datadog collector configuration](/images/crewai-otel-collector-datadog.png)</Frame>
+
+    **Pick this path if** you'd rather not operate a Datadog Agent, you already use OTLP for traces and want one export pipeline, or you may later want to fan out the same telemetry to other backends (Grafana, Honeycomb, etc.) without changing your application setup.
+  </Tab>
+</Tabs>
+
+Either path lands the same structured facets in Datadog (`@automation_id`, `@kickoff_id`, `@execution_id`, `@automation_name`, `@crewai_version`, `@exception.type`, `@gen_ai.*`), so the dashboard works identically with either choice.
+
+## Log schema reference
+
+<Info>
+This schema applies to the **Datadog Agent path** — stdout JSON logs produced when `CREWAI_LOG_FORMAT=json` is set. Logs delivered via the **Datadog OTLP intake** use OpenTelemetry attribute names and may differ; see [OpenTelemetry Export](./capture_telemetry_logs).
+</Info>
+
+When `CREWAI_LOG_FORMAT=json` is set, every log event is emitted as a **single JSON object per line** to stdout, with internal newlines escaped. The format is plain JSON — Datadog parses it natively, and the same payload is also consumable by Splunk, Loki, Elasticsearch, and CloudWatch without custom log pipelines.
+
+### Why JSON output
+
+<CardGroup cols={2}>
+  <Card title="Lower ingestion cost" icon="dollar-sign">
+    Most managed log backends bill per event. A Python traceback in text format is counted as one event per line — 30+ events for a single error. JSON output collapses each traceback into a single event with the stack trace as an escaped string field.
+  </Card>
+  <Card title="Structured search" icon="magnifying-glass">
+    Search by `@automation_id`, `@exception.type`, `@kickoff_id` instead of grepping free-text. Build dashboards on typed facets without parser configuration.
+  </Card>
+  <Card title="APM ↔ logs correlation" icon="link">
+    Every event carries `trace_id` and `span_id` when fired inside a recording span, so backends auto-link logs to traces.
+  </Card>
+  <Card title="Stable contract" icon="file-shield">
+    The `schema` field gates compatibility — within `v1`, fields are added but never renamed or removed.
+  </Card>
+</CardGroup>
+
+### Enabling JSON output
+
+`CREWAI_LOG_FORMAT=json` must be set as an **automation environment variable** in CrewAI AMP — it is **not** a container, host, or Docker setting. Open your automation in AMP, click the **Settings** icon, and add the variable under the **Environment Variables** section. AMP applies the value to every container in the deployment (API + workers) on the next restart. See [Update Your Crew](./update-crew) for the full UI walkthrough with screenshots.
+
+```shell
+CREWAI_LOG_FORMAT=json
+```
+
+Restart the deployment to pick up the change. Every log line on stdout from that point on is a single JSON object.
+
+<Note>
+  The default value is `text`, which preserves the legacy human-readable line format byte-for-byte. Setting any value other than `json` falls back to text mode. There is no migration step — the variable is read at process start and the format switches immediately.
+</Note>
+
+### Example events
+
+A single info-level log inside an active automation kickoff:
+
+```json
+{
+  "schema": "v1",
+  "ts": "2026-06-17T16:14:23.482914Z",
+  "level": "INFO",
+  "logger": "crewai_enterprise.utilities.pii_redaction",
+  "crewai_version": "1.14.7",
+  "msg": "PII tracking state reset (engines preserved)",
+  "automation_id": "12",
+  "task_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "kickoff_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "execution_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "automation_name": "research_flow"
+}
+```
+
+An error with a Python exception is collapsed into a single event with the traceback as a string:
+
+```json
+{
+  "schema": "v1",
+  "ts": "2026-06-17T16:14:31.218450Z",
+  "level": "ERROR",
+  "logger": "api.tasks.flow_run_task",
+  "crewai_version": "1.14.7",
+  "msg": "Flow execution failed",
+  "automation_id": "12",
+  "kickoff_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "execution_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "automation_name": "research_flow",
+  "exception": {
+    "type": "ValueError",
+    "message": "Topic cannot be empty",
+    "stacktrace": "Traceback (most recent call last):\n  File \"/app/flow.py\", line 42, in summarize\n    ...\nValueError: Topic cannot be empty\n"
+  }
+}
+```
+
+The same error in legacy text mode would have produced ~25 separate log events (one per traceback line) — all of which the backend would bill and index individually.
+
+### Schema v1 fields
+
+Within the `v1` schema, fields are only added, never renamed or removed. New fields will appear as soon as a deployment is upgraded.
+
+| Field | Type | Always present | Source |
+|-------|------|----------------|--------|
+| `schema` | string | Yes | Constant `"v1"`. Increment indicates a breaking schema change. |
+| `ts` | string (ISO-8601 UTC, microseconds) | Yes | Record creation time, e.g. `2026-06-17T16:14:23.482914Z`. |
+| `level` | string | Yes | Python log level name: `DEBUG` / `INFO` / `WARNING` / `ERROR` / `CRITICAL`. |
+| `logger` | string | Yes | Dotted logger name, e.g. `api.tasks.flow_run_task`. |
+| `crewai_version` | string | Yes (when `crewai` package metadata is resolvable) | Installed `crewai` package version, e.g. `"1.14.7"`. |
+| `msg` | string | Yes | Rendered log message (after `%`-formatting / `{}`-formatting). |
+| `automation_id` | string | When `CREWAI_PLUS_ID` env var is set | Numeric deployment ID (AMP provisions this on every container). |
+| `task_id` | string | On Celery worker logs | Celery task UUID, or `"no-task"` for non-task contexts. |
+| `kickoff_id` | string | Inside an automation kickoff | UUID of the current kickoff. |
+| `execution_id` | string | Inside an automation kickoff | UUID of the current sub-execution. Equal to `kickoff_id` at the top level; differs for nested flow methods that spawn sub-executions. |
+| `automation_name` | string | Inside an automation kickoff | Human-readable automation/flow name, e.g. `"research_flow"`. |
+| `trace_id` | string (32-hex) | Inside a recording OpenTelemetry span | Hex trace ID. Omitted when no span is active. |
+| `span_id` | string (16-hex) | Inside a recording OpenTelemetry span | Hex span ID. Omitted when no span is active. |
+| `exception` | object | When the log record has `exc_info` | `{type, message, stacktrace}` — full traceback as a single escaped string. |
+
+<Tip>
+  Any additional `extra={...}` kwargs passed to a logger call appear as top-level JSON fields verbatim. Reserved field names above always win to keep the schema stable.
+</Tip>
+
+### Stability promise
+
+The `schema` field declares the contract. Within `v1`, CrewAI commits to:
+
+- **Never removing a field** that customers may have built queries or dashboards against.
+- **Never renaming a field** in place — renames happen via a schema bump (e.g. `v2`), with the old name kept as a deprecated alias for at least one release cycle.
+- **Adding new fields** at any time. Consumers should ignore unknown top-level keys.
+
+When a `v2` is introduced, both the `schema` field and the migration guide will be published in advance, and `v1` will continue to be emitted for one release cycle so dashboards and queries have time to migrate.
+
+## Prerequisite: promote facets
+
+Datadog auto-discovers fields the first time it sees them but doesn't make them queryable in widgets until they're promoted to **facets**. This is a one-time setup in your Datadog account.
+
+<Steps>
+  <Step title="Search for a CrewAI log">
+    Open [Logs Explorer](https://app.datadoghq.com/logs) and search `service:crewai*`. You should see at least one log event.
+  </Step>
+  <Step title="Promote each field">
+    Click any log entry to open the right-hand details panel. For each field below, hover the field name → click the gear icon → **Create facet**.
+
+    - `automation_id`, `automation_name`, `execution_id`, `kickoff_id`, `task_id`
+    - `crewai_version`, `model_id`
+    - `exception.type`, `exception.message`
+
+    Skip any field that already shows a star icon next to its name — that means it's already a facet. The `gen_ai.usage.input_tokens`, `gen_ai.usage.output_tokens`, and `gen_ai.request.model` facets are typically promoted automatically by Datadog's LLM Observability auto-discovery, but verify they exist before importing the dashboard.
+  </Step>
+</Steps>
+
+## Import the dashboard
+
+<Steps>
+  <Step title="Download the dashboard JSON">
+    Save [`datadog_dashboard.json`](https://raw.githubusercontent.com/crewAIInc/crewAI/main/docs/edge/en/enterprise/guides/datadog_dashboard.json) to your machine.
+  </Step>
+  <Step title="Open the import dialog in Datadog">
+    Navigate to **Dashboards → New Dashboard**. Click the **gear icon** in the top right of the empty dashboard and select **Import Dashboard JSON**.
+  </Step>
+  <Step title="Paste or upload the JSON">
+    Paste the contents of `datadog_dashboard.json` into the import dialog (or drag the file in). Click **Import**.
+
+    Datadog creates the dashboard immediately and lands you on it. The first load may show empty widgets for a few seconds while queries execute against the time range.
+  </Step>
+</Steps>
+
+<Tip>
+  Datadog's [Dashboard API](https://docs.datadoghq.com/api/latest/dashboards/#create-a-new-dashboard) accepts the same JSON via `POST /api/v1/dashboard`. Use it if you manage dashboards through Terraform, Pulumi, or CI.
+</Tip>
+
+## What you get
+
+The dashboard is organized into four sections plus a placeholder for a custom drill-down widget:
+
+| Section | Widgets | Useful for |
+|---------|---------|------------|
+| **Header** | Total Executions · Error Rate (%) · Active Automations · CrewAI Versions in Use | At-a-glance health for the last hour. Error Rate is conditionally formatted (green ≤ 5%, yellow ≤ 10%, red > 10%). |
+| **Throughput** | Executions per Hour by Automation (top 10, stacked bars) | Spotting traffic shifts, surfacing busy automations, validating that a rollout didn't change baseline volume. |
+| **Errors** | Errors by Exception Type (top 5, stacked bars) · Top Exception Types by Count (toplist) | Triaging failures — which exception types are spiking, which automations they're hitting. |
+| **Cost** | Total Tokens per Hour by Model (input + output, stacked area) | Tracking LLM token spend by model. Useful for catching cost regressions when an automation switches model or starts looping. |
+| **Drill-Down** | _(empty placeholder)_ | See [Customization](#customize) for adding a recent-errors log stream here. |
+
+Three template variables at the top of the dashboard re-scope every widget at once:
+
+- **`$automation`** — filter to a single automation by name.
+- **`$version`** — filter to a single `crewai` SDK version (useful for comparing pre- and post-upgrade behavior).
+- **`$service`** — filter to a specific Datadog `service` tag (useful when multiple CrewAI deployments share one Datadog account).
+
+## Verify ingestion
+
+Open [Logs Explorer](https://app.datadoghq.com/logs) and run a query that matches your ingestion path:
+
+<Tabs>
+  <Tab title="Datadog Agent">
+    Search `service:crewai* @schema:v1`. You should see structured logs with the JSON fields parsed into Datadog facets. Pick a recent event and verify it has `@automation_id`, `@kickoff_id`, `@execution_id`, `@crewai_version`, and (when running inside a span) `@trace_id` / `@span_id` populated.
+
+    If nothing appears, confirm `CREWAI_LOG_FORMAT=json` is set under your automation's **Environment Variables** in AMP, the deployment was restarted after the change, and the Datadog Agent is tailing container stdout.
+  </Tab>
+  <Tab title="Datadog OTLP intake">
+    Search `source:otlp service:crewai*`. OTLP attributes land with their OpenTelemetry names (`automation_id`, `crewai.kickoff.id`, etc.) rather than the stdout JSON keys, but they map to the same dashboard facets after [facet promotion](#prerequisite-promote-facets).
+
+    If nothing appears, verify the collector endpoint is correct (`/v1/logs` for logs, `/v1/traces` for traces) and **Test Connection** succeeded when the collector was saved.
+  </Tab>
+</Tabs>
+
+## Customize
+
+The dashboard ships with deliberate gaps so you can extend it without uninstalling and re-importing.
+
+### Add a Recent Errors log stream
+
+The **Drill-Down** section is intentionally empty. Add a Log Stream widget to it for an inline view of recent failures:
+
+1. Edit the dashboard and click **+ Add Widgets** inside the Drill-Down group.
+2. Drag in a **Log Stream** widget.
+3. Set the filter query to `status:error $automation $version $service`.
+4. Choose columns: `@timestamp`, `@automation_name`, `@exception.type`, `@exception.message`, `@execution_id`.
+5. Sort by most recent, limit to 25 entries.
+
+Clicking any row jumps to Logs Explorer with the same filter pre-applied.
+
+### Add p95 latency
+
+Logs don't include execution duration by default. Two ways to add a latency widget:
+
+- **From APM traces** — if you also export OTLP traces to Datadog, add a Timeseries widget with data source **Traces**, query `service:crewai*`, aggregation `p95 of @duration`. Datadog APM auto-tracks span duration.
+- **From metric extraction** — extract a `flow.duration_ms` metric from logs via [Datadog's log-to-metric pipeline](https://docs.datadoghq.com/logs/log_configuration/logs_to_metrics/), then chart it like any other metric. Useful if you don't run APM.
+
+### Re-scope to multiple deployments
+
+The `$service` template variable defaults to `*` and will catch every CrewAI deployment in your Datadog account. Change the default to a specific service name in **Configure → Template Variables** if you want the dashboard to focus on one deployment by default.
+
+## Troubleshooting
+
+| Symptom | Likely cause | Fix |
+|---------|--------------|-----|
+| All widgets show "No data" | Facets aren't promoted | Re-do the [Promote facets](#prerequisite-promote-facets) step. Datadog won't query against an un-promoted field. |
+| Error Rate widget shows `NaN` | No executions in the time window | Either no traffic, or `@execution_id` isn't faceted. Expand the time range and re-check facets. |
+| Throughput chart is flat at the same value | Logs aren't reaching Datadog | Search `service:crewai*` in Logs Explorer. If nothing shows, verify the Datadog Agent is running (Agent path) or the OTel collector endpoint is correct (OTLP path). |
+| `crewai_version` shows fewer values than expected | Some containers predate the structured-logs work | The `crewai_version` field was added alongside JSON output. Older deployments running text mode (or older AMP builds) won't emit it. Upgrade those deployments to pick up the field. See the [log schema reference](#log-schema-reference) for the full field contract. |
+| Template variables don't filter widgets | The widget's filter line doesn't reference the template variable | Edit the widget and confirm the search includes `$automation $version $service`. |
+
+## Next steps
+
+<CardGroup cols={2}>
+  <Card title="OpenTelemetry Export" icon="magnifying-glass-chart" href="./capture_telemetry_logs">
+    Vendor-neutral observability for non-Datadog stacks (Grafana, Honeycomb, your own collector) — or as a Datadog complement when you want to fan out telemetry to multiple backends.
+  </Card>
+  <Card title="Datadog Log Search Syntax" icon="magnifying-glass" href="https://docs.datadoghq.com/logs/explorer/search_syntax/">
+    Reference for customizing widget queries against the structured facets above.
+  </Card>
+</CardGroup>

docs/edge/pt-BR/changelog.mdx

@@ -4,6 +4,28 @@ description: "Atualizações de produto, melhorias e correções do CrewAI"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="18 jun 2026">
+  ## v1.14.8a1
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.14.8a1)
+
+  ## O que Mudou
+
+  ### Recursos
+  - Adicionar expressão if opcional aos passos each.do
+
+  ### Correções de Bugs
+  - Corrigir problemas de JSON da equipe
+
+  ### Documentação
+  - Atualizar snapshot e changelog para v1.14.8a
+
+  ## Contribuidores
+
+  @joaomdmoura, @vinibrsl
+
+</Update>
+
 <Update label="17 jun 2026">
   ## v1.14.8a
 

docs/edge/pt-BR/enterprise/guides/capture_telemetry_logs.mdx

@@ -9,6 +9,10 @@ O CrewAI AMP pode exportar **traces** e **logs** do OpenTelemetry das suas impla
 
 Os dados de telemetria seguem as [convenções semânticas GenAI do OpenTelemetry](https://opentelemetry.io/docs/specs/semconv/gen-ai/) além de atributos adicionais específicos do CrewAI.
 
+<Tip>
+OpenTelemetry é o **caminho de observabilidade recomendado** — neutro em relação a fornecedores, funciona com qualquer backend compatível com OTLP (Grafana, Honeycomb, NewRelic, seu próprio coletor). Se você usa especificamente o Datadog, veja o guia dedicado [Integração com Datadog](./datadog), que cobre tanto o caminho do Datadog Agent quanto o ingest OTLP do Datadog.
+</Tip>
+
 ## Pré-requisitos
 
 <CardGroup cols={2}>
@@ -41,17 +45,7 @@ Os dados de telemetria seguem as [convenções semânticas GenAI do OpenTelemetr
     <Frame>![Configuração do coletor OpenTelemetry](/images/crewai-otel-collector-opentelemetry.png)</Frame>
   </Tab>
   <Tab title="Datadog">
-    - **Datadog Site Domain** — Apenas o host OTLP do seu site Datadog, sem protocolo ou caminho. O CrewAI monta o endpoint HTTPS OTLP completo para você. Use o host correspondente ao seu [site Datadog](https://docs.datadoghq.com/getting_started/site/):
-      - `otlp.datadoghq.com` (US1)
-      - `otlp.us3.datadoghq.com` (US3)
-      - `otlp.us5.datadoghq.com` (US5)
-      - `otlp.datadoghq.eu` (EU1)
-      - `otlp.ap1.datadoghq.com` (AP1)
-    - **API Key** — Sua chave de API do Datadog. Veja [como criar uma](https://docs.datadoghq.com/account_management/api-app-keys/#api-keys).
-
-    A integração com o Datadog exporta **traces**.
-
-    <Frame>![Configuração do coletor Datadog](/images/crewai-otel-collector-datadog.png)</Frame>
+    Para configurar o Datadog, veja o guia dedicado [Integração com Datadog](./datadog) — ele cobre tanto o caminho do Datadog Agent (recomendado, mais barato para volumes altos de log) quanto o ingest OTLP do Datadog, com os passos completos de configuração do coletor.
   </Tab>
 </Tabs>
 

docs/edge/pt-BR/enterprise/guides/datadog.mdx

@@ -0,0 +1,295 @@
+---
+title: "Integração com Datadog"
+description: "Monitore implantações CrewAI AMP auto-hospedadas no Datadog via Datadog Agent ou ingest OTLP do Datadog — ambos os caminhos entregam as mesmas facetas estruturadas para importar o dashboard de operações pronto."
+icon: "dog"
+mode: "wide"
+---
+
+<Note>
+**Tradução em andamento** — conteúdo exibido em inglês.
+</Note>
+
+CrewAI ships first-class support for Datadog: two log-ingestion paths, a JSON log schema designed for cheap indexing, and a ready-made operations dashboard you can import in under five minutes.
+
+<Note>
+For vendor-neutral observability via any OTLP backend (Grafana, Honeycomb, your own collector), see [OpenTelemetry Export](./capture_telemetry_logs).
+</Note>
+
+## Choose a path
+
+CrewAI supports two log-ingestion paths to Datadog — both are first-class and produce the same structured facets that power the dashboard. Pick the one that fits your infrastructure.
+
+<Tabs>
+  <Tab title="Datadog Agent">
+    The Datadog Agent runs alongside your CrewAI containers (typically as a DaemonSet on Kubernetes) and tails their stdout. With `CREWAI_LOG_FORMAT=json` set, each log event ships as a single billable line with structured attributes.
+
+    **Setup:**
+    1. Run the Datadog Agent next to your CrewAI containers — see [Datadog's deployment docs](https://docs.datadoghq.com/agent/) for Kubernetes, ECS, or VM setup. Enable log collection (`logs_enabled: true`) and container log collection (`logs_config.container_collect_all: true`).
+    2. Set `CREWAI_LOG_FORMAT=json` as an **automation environment variable** in CrewAI AMP (open your automation → **Settings → Environment Variables**) so each log event is a single line instead of a multi-line traceback. AMP propagates the value to every container in the deployment (API + workers) — don't set it on the container or host directly. See [Enabling JSON output](#enabling-json-output) below for the AMP UI walkthrough and the [log schema reference](#log-schema-reference) for the full field contract.
+    3. Confirm logs arrive in Datadog Logs with the JSON fields parsed — see [Verify ingestion](#verify-ingestion).
+
+    **Pick this path if** you already operate Datadog Agents (e.g. for infrastructure metrics), or your log volume makes per-event ingestion cost a real concern — collapsing tracebacks into single events keeps Agent ingestion cheap at scale.
+  </Tab>
+  <Tab title="Datadog OTLP intake">
+    CrewAI AMP exports OpenTelemetry traffic directly to Datadog's OTLP endpoint with no Agent required. Logs and traces ride a single export pipeline configured in AMP's UI, using the same protocol you'd use for any other OTLP backend.
+
+    **Setup:**
+    1. In CrewAI AMP, go to **Settings → OpenTelemetry Collectors → Add Collector** and pick **Datadog**.
+    2. Configure the connection:
+       - **Datadog Site Domain** — your Datadog site's OTLP host only, no protocol or path. CrewAI builds the full HTTPS OTLP endpoint for you. Use the host that matches your [Datadog site](https://docs.datadoghq.com/getting_started/site/):
+         - `otlp.datadoghq.com` (US1)
+         - `otlp.us3.datadoghq.com` (US3)
+         - `otlp.us5.datadoghq.com` (US5)
+         - `otlp.datadoghq.eu` (EU1)
+         - `otlp.ap1.datadoghq.com` (AP1)
+       - **API Key** — your Datadog API key. See [how to create one](https://docs.datadoghq.com/account_management/api-app-keys/#api-keys).
+    3. The Datadog template provisions **both signals at once** — when you save, AMP creates a traces collector at `/v1/traces` and a logs collector at `/v1/logs`, both sharing the same Datadog OTLP host and API key. You'll see them as two separate rows in your OTel collectors list.
+    4. *(optional)* Click **Test Connection** to verify CrewAI can reach the endpoint with the credentials you provided. Then click **Save** — both collectors are created in one step.
+
+    <Frame>![Datadog collector configuration](/images/crewai-otel-collector-datadog.png)</Frame>
+
+    **Pick this path if** you'd rather not operate a Datadog Agent, you already use OTLP for traces and want one export pipeline, or you may later want to fan out the same telemetry to other backends (Grafana, Honeycomb, etc.) without changing your application setup.
+  </Tab>
+</Tabs>
+
+Either path lands the same structured facets in Datadog (`@automation_id`, `@kickoff_id`, `@execution_id`, `@automation_name`, `@crewai_version`, `@exception.type`, `@gen_ai.*`), so the dashboard works identically with either choice.
+
+## Log schema reference
+
+<Info>
+This schema applies to the **Datadog Agent path** — stdout JSON logs produced when `CREWAI_LOG_FORMAT=json` is set. Logs delivered via the **Datadog OTLP intake** use OpenTelemetry attribute names and may differ; see [OpenTelemetry Export](./capture_telemetry_logs).
+</Info>
+
+When `CREWAI_LOG_FORMAT=json` is set, every log event is emitted as a **single JSON object per line** to stdout, with internal newlines escaped. The format is plain JSON — Datadog parses it natively, and the same payload is also consumable by Splunk, Loki, Elasticsearch, and CloudWatch without custom log pipelines.
+
+### Why JSON output
+
+<CardGroup cols={2}>
+  <Card title="Lower ingestion cost" icon="dollar-sign">
+    Most managed log backends bill per event. A Python traceback in text format is counted as one event per line — 30+ events for a single error. JSON output collapses each traceback into a single event with the stack trace as an escaped string field.
+  </Card>
+  <Card title="Structured search" icon="magnifying-glass">
+    Search by `@automation_id`, `@exception.type`, `@kickoff_id` instead of grepping free-text. Build dashboards on typed facets without parser configuration.
+  </Card>
+  <Card title="APM ↔ logs correlation" icon="link">
+    Every event carries `trace_id` and `span_id` when fired inside a recording span, so backends auto-link logs to traces.
+  </Card>
+  <Card title="Stable contract" icon="file-shield">
+    The `schema` field gates compatibility — within `v1`, fields are added but never renamed or removed.
+  </Card>
+</CardGroup>
+
+### Enabling JSON output
+
+`CREWAI_LOG_FORMAT=json` must be set as an **automation environment variable** in CrewAI AMP — it is **not** a container, host, or Docker setting. Open your automation in AMP, click the **Settings** icon, and add the variable under the **Environment Variables** section. AMP applies the value to every container in the deployment (API + workers) on the next restart. See [Update Your Crew](./update-crew) for the full UI walkthrough with screenshots.
+
+```shell
+CREWAI_LOG_FORMAT=json
+```
+
+Restart the deployment to pick up the change. Every log line on stdout from that point on is a single JSON object.
+
+<Note>
+  The default value is `text`, which preserves the legacy human-readable line format byte-for-byte. Setting any value other than `json` falls back to text mode. There is no migration step — the variable is read at process start and the format switches immediately.
+</Note>
+
+### Example events
+
+A single info-level log inside an active automation kickoff:
+
+```json
+{
+  "schema": "v1",
+  "ts": "2026-06-17T16:14:23.482914Z",
+  "level": "INFO",
+  "logger": "crewai_enterprise.utilities.pii_redaction",
+  "crewai_version": "1.14.7",
+  "msg": "PII tracking state reset (engines preserved)",
+  "automation_id": "12",
+  "task_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "kickoff_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "execution_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "automation_name": "research_flow"
+}
+```
+
+An error with a Python exception is collapsed into a single event with the traceback as a string:
+
+```json
+{
+  "schema": "v1",
+  "ts": "2026-06-17T16:14:31.218450Z",
+  "level": "ERROR",
+  "logger": "api.tasks.flow_run_task",
+  "crewai_version": "1.14.7",
+  "msg": "Flow execution failed",
+  "automation_id": "12",
+  "kickoff_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "execution_id": "0843a930-b306-464b-89c8-bfafa78cc711",
+  "automation_name": "research_flow",
+  "exception": {
+    "type": "ValueError",
+    "message": "Topic cannot be empty",
+    "stacktrace": "Traceback (most recent call last):\n  File \"/app/flow.py\", line 42, in summarize\n    ...\nValueError: Topic cannot be empty\n"
+  }
+}
+```
+
+The same error in legacy text mode would have produced ~25 separate log events (one per traceback line) — all of which the backend would bill and index individually.
+
+### Schema v1 fields
+
+Within the `v1` schema, fields are only added, never renamed or removed. New fields will appear as soon as a deployment is upgraded.
+
+| Field | Type | Always present | Source |
+|-------|------|----------------|--------|
+| `schema` | string | Yes | Constant `"v1"`. Increment indicates a breaking schema change. |
+| `ts` | string (ISO-8601 UTC, microseconds) | Yes | Record creation time, e.g. `2026-06-17T16:14:23.482914Z`. |
+| `level` | string | Yes | Python log level name: `DEBUG` / `INFO` / `WARNING` / `ERROR` / `CRITICAL`. |
+| `logger` | string | Yes | Dotted logger name, e.g. `api.tasks.flow_run_task`. |
+| `crewai_version` | string | Yes (when `crewai` package metadata is resolvable) | Installed `crewai` package version, e.g. `"1.14.7"`. |
+| `msg` | string | Yes | Rendered log message (after `%`-formatting / `{}`-formatting). |
+| `automation_id` | string | When `CREWAI_PLUS_ID` env var is set | Numeric deployment ID (AMP provisions this on every container). |
+| `task_id` | string | On Celery worker logs | Celery task UUID, or `"no-task"` for non-task contexts. |
+| `kickoff_id` | string | Inside an automation kickoff | UUID of the current kickoff. |
+| `execution_id` | string | Inside an automation kickoff | UUID of the current sub-execution. Equal to `kickoff_id` at the top level; differs for nested flow methods that spawn sub-executions. |
+| `automation_name` | string | Inside an automation kickoff | Human-readable automation/flow name, e.g. `"research_flow"`. |
+| `trace_id` | string (32-hex) | Inside a recording OpenTelemetry span | Hex trace ID. Omitted when no span is active. |
+| `span_id` | string (16-hex) | Inside a recording OpenTelemetry span | Hex span ID. Omitted when no span is active. |
+| `exception` | object | When the log record has `exc_info` | `{type, message, stacktrace}` — full traceback as a single escaped string. |
+
+<Tip>
+  Any additional `extra={...}` kwargs passed to a logger call appear as top-level JSON fields verbatim. Reserved field names above always win to keep the schema stable.
+</Tip>
+
+### Stability promise
+
+The `schema` field declares the contract. Within `v1`, CrewAI commits to:
+
+- **Never removing a field** that customers may have built queries or dashboards against.
+- **Never renaming a field** in place — renames happen via a schema bump (e.g. `v2`), with the old name kept as a deprecated alias for at least one release cycle.
+- **Adding new fields** at any time. Consumers should ignore unknown top-level keys.
+
+When a `v2` is introduced, both the `schema` field and the migration guide will be published in advance, and `v1` will continue to be emitted for one release cycle so dashboards and queries have time to migrate.
+
+## Prerequisite: promote facets
+
+Datadog auto-discovers fields the first time it sees them but doesn't make them queryable in widgets until they're promoted to **facets**. This is a one-time setup in your Datadog account.
+
+<Steps>
+  <Step title="Search for a CrewAI log">
+    Open [Logs Explorer](https://app.datadoghq.com/logs) and search `service:crewai*`. You should see at least one log event.
+  </Step>
+  <Step title="Promote each field">
+    Click any log entry to open the right-hand details panel. For each field below, hover the field name → click the gear icon → **Create facet**.
+
+    - `automation_id`, `automation_name`, `execution_id`, `kickoff_id`, `task_id`
+    - `crewai_version`, `model_id`
+    - `exception.type`, `exception.message`
+
+    Skip any field that already shows a star icon next to its name — that means it's already a facet. The `gen_ai.usage.input_tokens`, `gen_ai.usage.output_tokens`, and `gen_ai.request.model` facets are typically promoted automatically by Datadog's LLM Observability auto-discovery, but verify they exist before importing the dashboard.
+  </Step>
+</Steps>
+
+## Import the dashboard
+
+<Steps>
+  <Step title="Download the dashboard JSON">
+    Save [`datadog_dashboard.json`](https://raw.githubusercontent.com/crewAIInc/crewAI/main/docs/edge/en/enterprise/guides/datadog_dashboard.json) to your machine.
+  </Step>
+  <Step title="Open the import dialog in Datadog">
+    Navigate to **Dashboards → New Dashboard**. Click the **gear icon** in the top right of the empty dashboard and select **Import Dashboard JSON**.
+  </Step>
+  <Step title="Paste or upload the JSON">
+    Paste the contents of `datadog_dashboard.json` into the import dialog (or drag the file in). Click **Import**.
+
+    Datadog creates the dashboard immediately and lands you on it. The first load may show empty widgets for a few seconds while queries execute against the time range.
+  </Step>
+</Steps>
+
+<Tip>
+  Datadog's [Dashboard API](https://docs.datadoghq.com/api/latest/dashboards/#create-a-new-dashboard) accepts the same JSON via `POST /api/v1/dashboard`. Use it if you manage dashboards through Terraform, Pulumi, or CI.
+</Tip>
+
+## What you get
+
+The dashboard is organized into four sections plus a placeholder for a custom drill-down widget:
+
+| Section | Widgets | Useful for |
+|---------|---------|------------|
+| **Header** | Total Executions · Error Rate (%) · Active Automations · CrewAI Versions in Use | At-a-glance health for the last hour. Error Rate is conditionally formatted (green ≤ 5%, yellow ≤ 10%, red > 10%). |
+| **Throughput** | Executions per Hour by Automation (top 10, stacked bars) | Spotting traffic shifts, surfacing busy automations, validating that a rollout didn't change baseline volume. |
+| **Errors** | Errors by Exception Type (top 5, stacked bars) · Top Exception Types by Count (toplist) | Triaging failures — which exception types are spiking, which automations they're hitting. |
+| **Cost** | Total Tokens per Hour by Model (input + output, stacked area) | Tracking LLM token spend by model. Useful for catching cost regressions when an automation switches model or starts looping. |
+| **Drill-Down** | _(empty placeholder)_ | See [Customization](#customize) for adding a recent-errors log stream here. |
+
+Three template variables at the top of the dashboard re-scope every widget at once:
+
+- **`$automation`** — filter to a single automation by name.
+- **`$version`** — filter to a single `crewai` SDK version (useful for comparing pre- and post-upgrade behavior).
+- **`$service`** — filter to a specific Datadog `service` tag (useful when multiple CrewAI deployments share one Datadog account).
+
+## Verify ingestion
+
+Open [Logs Explorer](https://app.datadoghq.com/logs) and run a query that matches your ingestion path:
+
+<Tabs>
+  <Tab title="Datadog Agent">
+    Search `service:crewai* @schema:v1`. You should see structured logs with the JSON fields parsed into Datadog facets. Pick a recent event and verify it has `@automation_id`, `@kickoff_id`, `@execution_id`, `@crewai_version`, and (when running inside a span) `@trace_id` / `@span_id` populated.
+
+    If nothing appears, confirm `CREWAI_LOG_FORMAT=json` is set under your automation's **Environment Variables** in AMP, the deployment was restarted after the change, and the Datadog Agent is tailing container stdout.
+  </Tab>
+  <Tab title="Datadog OTLP intake">
+    Search `source:otlp service:crewai*`. OTLP attributes land with their OpenTelemetry names (`automation_id`, `crewai.kickoff.id`, etc.) rather than the stdout JSON keys, but they map to the same dashboard facets after [facet promotion](#prerequisite-promote-facets).
+
+    If nothing appears, verify the collector endpoint is correct (`/v1/logs` for logs, `/v1/traces` for traces) and **Test Connection** succeeded when the collector was saved.
+  </Tab>
+</Tabs>
+
+## Customize
+
+The dashboard ships with deliberate gaps so you can extend it without uninstalling and re-importing.
+
+### Add a Recent Errors log stream
+
+The **Drill-Down** section is intentionally empty. Add a Log Stream widget to it for an inline view of recent failures:
+
+1. Edit the dashboard and click **+ Add Widgets** inside the Drill-Down group.
+2. Drag in a **Log Stream** widget.
+3. Set the filter query to `status:error $automation $version $service`.
+4. Choose columns: `@timestamp`, `@automation_name`, `@exception.type`, `@exception.message`, `@execution_id`.
+5. Sort by most recent, limit to 25 entries.
+
+Clicking any row jumps to Logs Explorer with the same filter pre-applied.
+
+### Add p95 latency
+
+Logs don't include execution duration by default. Two ways to add a latency widget:
+
+- **From APM traces** — if you also export OTLP traces to Datadog, add a Timeseries widget with data source **Traces**, query `service:crewai*`, aggregation `p95 of @duration`. Datadog APM auto-tracks span duration.
+- **From metric extraction** — extract a `flow.duration_ms` metric from logs via [Datadog's log-to-metric pipeline](https://docs.datadoghq.com/logs/log_configuration/logs_to_metrics/), then chart it like any other metric. Useful if you don't run APM.
+
+### Re-scope to multiple deployments
+
+The `$service` template variable defaults to `*` and will catch every CrewAI deployment in your Datadog account. Change the default to a specific service name in **Configure → Template Variables** if you want the dashboard to focus on one deployment by default.
+
+## Troubleshooting
+
+| Symptom | Likely cause | Fix |
+|---------|--------------|-----|
+| All widgets show "No data" | Facets aren't promoted | Re-do the [Promote facets](#prerequisite-promote-facets) step. Datadog won't query against an un-promoted field. |
+| Error Rate widget shows `NaN` | No executions in the time window | Either no traffic, or `@execution_id` isn't faceted. Expand the time range and re-check facets. |
+| Throughput chart is flat at the same value | Logs aren't reaching Datadog | Search `service:crewai*` in Logs Explorer. If nothing shows, verify the Datadog Agent is running (Agent path) or the OTel collector endpoint is correct (OTLP path). |
+| `crewai_version` shows fewer values than expected | Some containers predate the structured-logs work | The `crewai_version` field was added alongside JSON output. Older deployments running text mode (or older AMP builds) won't emit it. Upgrade those deployments to pick up the field. See the [log schema reference](#log-schema-reference) for the full field contract. |
+| Template variables don't filter widgets | The widget's filter line doesn't reference the template variable | Edit the widget and confirm the search includes `$automation $version $service`. |
+
+## Next steps
+
+<CardGroup cols={2}>
+  <Card title="OpenTelemetry Export" icon="magnifying-glass-chart" href="./capture_telemetry_logs">
+    Vendor-neutral observability for non-Datadog stacks (Grafana, Honeycomb, your own collector) — or as a Datadog complement when you want to fan out telemetry to multiple backends.
+  </Card>
+  <Card title="Datadog Log Search Syntax" icon="magnifying-glass" href="https://docs.datadoghq.com/logs/explorer/search_syntax/">
+    Reference for customizing widget queries against the structured facets above.
+  </Card>
+</CardGroup>

lib/cli/pyproject.toml

@@ -8,7 +8,7 @@ authors = [
 ]
 requires-python = ">=3.10, <3.14"
 dependencies = [
-    "crewai-core==1.14.8a",
+    "crewai-core==1.14.8a1",
     "click>=8.1.7,<9",
     "pydantic>=2.11.9,<2.13",
     "pydantic-settings~=2.10.1",

lib/cli/src/crewai_cli/__init__.py

@@ -1 +1 @@
-__version__ = "1.14.8a"
+__version__ = "1.14.8a1"

lib/cli/src/crewai_cli/create_json_crew.py

@@ -89,13 +89,16 @@ description = "{name} using crewAI"
 authors = [{{ name = "Your Name", email = "you@example.com" }}]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]>=1.14.7"
+    "crewai[tools]==1.14.8a1"
 ]
 
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[tool.hatch.build.targets.wheel]
+only-include = ["agents", "crew.jsonc", "tools", "knowledge", "skills"]
+
 [tool.crewai]
 type = "crew"
 """

lib/cli/src/crewai_cli/crew_run_tui.py

@@ -34,6 +34,25 @@ _C_MUTED = "#666666"  # dimmer than _C_DIM for past timeline
 _STEP_NUMBER_RE = re.compile(r"\bstep\s+(\d+)\b", re.IGNORECASE)
 _REFINEMENT_RE = re.compile(r"^\s*step\s+(\d+)\s*:\s*(.+)\s*$", re.IGNORECASE)
 _INTERNAL_TOOL_NAMES = {"create_reasoning_plan"}
+_LOG_ARGS_TEXT_LIMIT = 3_000
+_LOG_RESULT_TEXT_LIMIT = 5_000
+_LOG_TRUNCATION_SUFFIX = "... [truncated]"
+# Background memory saves can emit their start event just after kickoff returns.
+_MEMORY_SAVE_DRAIN_GRACE_SECONDS = 2.0
+
+
+def _is_save_to_memory_tool(tool_name: str | None) -> bool:
+    return (tool_name or "").replace(" ", "_").lower() == "save_to_memory"
+
+
+def _truncate_log_text(value: Any, limit: int) -> str | None:
+    if value is None:
+        return None
+    text = str(value)
+    if len(text) <= limit:
+        return text
+    suffix = _LOG_TRUNCATION_SUFFIX
+    return f"{text[: max(0, limit - len(suffix))]}{suffix}"
 
 
 def _enable_tracing_in_dotenv() -> None:
@@ -519,6 +538,8 @@ FooterKey .footer-key--key {
         self._log_expanded: set[int] = set()
         self._log_scroll_needed: bool = False
         self._log_line_map: list[tuple[int, int, int]] = []
+        self._suppressed_memory_save_event_ids: set[str] = set()
+        self._memory_save_drain_timer: Any = None
 
         self._event_handlers: list[tuple[type, Any]] = []
 
@@ -633,7 +654,6 @@ FooterKey .footer-key--key {
             self.call_from_thread(self._on_crew_failed, str(e))
 
     def _on_crew_done(self, output: str | None) -> None:
-        self._unsubscribe()
         with self._lock:
             self._status = "completed"
             self._final_output = output
@@ -649,6 +669,8 @@ FooterKey .footer-key--key {
             now = time.time()
             for entry in self._log_entries:
                 if entry["status"] == "running":
+                    if entry["tool_name"] == "memory_save":
+                        continue
                     entry["status"] = "timeout"
                     entry["error"] = "No result received before crew completed"
                     entry["duration"] = now - entry["start_time"]
@@ -680,9 +702,9 @@ FooterKey .footer-key--key {
         self.call_later(self._focus_activity_log)
         self._tick_timer.stop()
         self._tick_timer = self.set_interval(1 / 2, self._tick)
+        self._unsubscribe_if_no_running_memory_save(wait_for_queued=True)
 
     def _on_crew_failed(self, error: str) -> None:
-        self._unsubscribe()
         with self._lock:
             self._status = "failed"
             self._error = error
@@ -692,12 +714,16 @@ FooterKey .footer-key--key {
             now = time.time()
             for entry in self._log_entries:
                 if entry["status"] == "running":
+                    if entry["tool_name"] == "memory_save":
+                        continue
                     entry["status"] = "error"
+                    entry["error"] = "No result received before crew failed"
                     entry["duration"] = now - entry["start_time"]
         self._tick()
         self.call_later(self._focus_activity_log)
         self._tick_timer.stop()
         self._tick_timer = self.set_interval(1 / 2, self._tick)
+        self._unsubscribe_if_no_running_memory_save(wait_for_queued=True)
 
     # ── Actions ─────────────────────────────────────────────
 
@@ -1514,6 +1540,53 @@ FooterKey .footer-key--key {
             pass
         self._event_handlers.clear()
 
+    def _has_running_memory_save_locked(self) -> bool:
+        return any(
+            entry["tool_name"] == "memory_save" and entry["status"] == "running"
+            for entry in self._log_entries
+        )
+
+    def _on_memory_save_drain_elapsed(self) -> None:
+        self._memory_save_drain_timer = None
+        self._unsubscribe_if_no_running_memory_save()
+
+    def _schedule_memory_save_drain_unsubscribe(self) -> bool:
+        loop = getattr(self, "_loop", None)
+        if loop is None:
+            return False
+        if getattr(self, "_thread_id", None) != threading.get_ident():
+            try:
+                loop.call_soon_threadsafe(self._schedule_memory_save_drain_unsubscribe)
+            except RuntimeError:
+                return False
+            return True
+        if self._memory_save_drain_timer is not None:
+            self._memory_save_drain_timer.stop()
+        self._memory_save_drain_timer = self.set_timer(
+            _MEMORY_SAVE_DRAIN_GRACE_SECONDS,
+            self._on_memory_save_drain_elapsed,
+            name="memory-save-drain",
+        )
+        return True
+
+    def _unsubscribe_if_no_running_memory_save(
+        self, *, wait_for_queued: bool = False
+    ) -> None:
+        with self._lock:
+            should_unsubscribe = (
+                self._status
+                in {
+                    "completed",
+                    "failed",
+                }
+                and not self._has_running_memory_save_locked()
+            )
+
+        if should_unsubscribe:
+            if wait_for_queued and self._schedule_memory_save_drain_unsubscribe():
+                return
+            self._unsubscribe()
+
     def _subscribe(self) -> None:
         from crewai.events.event_bus import crewai_event_bus
         from crewai.events.types.crew_events import CrewKickoffStartedEvent
@@ -1802,6 +1875,8 @@ FooterKey .footer-key--key {
                         entry["status"] == "running"
                         and entry["tool_name"] != event.tool_name
                     ):
+                        if entry["tool_name"] == "memory_save":
+                            continue
                         entry["status"] = "timeout"
                         entry["error"] = (
                             "No result received before the next tool started"
@@ -1830,6 +1905,7 @@ FooterKey .footer-key--key {
                         "duration": None,
                         "task_idx": self._current_task_idx,
                         "plan_step_number": plan_step_number,
+                        "event_id": event.event_id,
                     }
                 )
             self._complete_step("teal", f"⚡ {event.tool_name}…")
@@ -1923,8 +1999,178 @@ FooterKey .footer-key--key {
             MemoryRetrievalCompletedEvent,
             MemoryRetrievalFailedEvent,
             MemoryRetrievalStartedEvent,
+            MemorySaveCompletedEvent,
+            MemorySaveFailedEvent,
+            MemorySaveStartedEvent,
         )
 
+        def is_nested_save_to_memory_event(event: Any) -> bool:
+            if event.parent_event_id is None:
+                return False
+            state = crewai_event_bus.runtime_state
+            if state is None:
+                return False
+            parent_node = state.event_record.nodes.get(event.parent_event_id)
+            parent_event = getattr(parent_node, "event", None)
+            return getattr(
+                parent_event, "type", None
+            ) == "tool_usage_started" and _is_save_to_memory_tool(
+                getattr(parent_event, "tool_name", None)
+            )
+
+        @crewai_event_bus.on(MemorySaveStartedEvent)
+        def on_memory_save_started(source: Any, event: MemorySaveStartedEvent) -> None:
+            with self._lock:
+                if is_nested_save_to_memory_event(event):
+                    self._suppressed_memory_save_event_ids.add(event.event_id)
+                    return
+                for entry in reversed(self._log_entries):
+                    if (
+                        _is_save_to_memory_tool(entry["tool_name"])
+                        and entry.get("event_id") == event.parent_event_id
+                    ):
+                        self._suppressed_memory_save_event_ids.add(event.event_id)
+                        return
+                for entry in reversed(self._log_entries):
+                    if (
+                        entry["tool_name"] == "memory_save"
+                        and entry.get("started_event_id") == event.event_id
+                    ):
+                        entry["args"] = _truncate_log_text(
+                            event.value, _LOG_ARGS_TEXT_LIMIT
+                        )
+                        return
+                self._log_entries.append(
+                    {
+                        "tool_name": "memory_save",
+                        "status": "running",
+                        "args": _truncate_log_text(event.value, _LOG_ARGS_TEXT_LIMIT),
+                        "result": None,
+                        "error": None,
+                        "start_time": time.time(),
+                        "duration": None,
+                        "task_idx": self._current_task_idx,
+                        "event_id": event.event_id,
+                    }
+                )
+
+        self._register_handler(MemorySaveStartedEvent, on_memory_save_started)
+
+        @crewai_event_bus.on(MemorySaveCompletedEvent)
+        def on_memory_save_completed(
+            source: Any, event: MemorySaveCompletedEvent
+        ) -> None:
+            with self._lock:
+                if (
+                    event.started_event_id in self._suppressed_memory_save_event_ids
+                    or is_nested_save_to_memory_event(event)
+                ):
+                    if event.started_event_id is not None:
+                        self._suppressed_memory_save_event_ids.discard(
+                            event.started_event_id
+                        )
+                else:
+                    for entry in reversed(self._log_entries):
+                        has_started_event_match = (
+                            event.started_event_id is not None
+                            and (
+                                entry.get("event_id") == event.started_event_id
+                                or entry.get("started_event_id")
+                                == event.started_event_id
+                            )
+                        )
+                        has_running_event_without_id = (
+                            event.started_event_id is None
+                            and entry["status"] == "running"
+                        )
+                        if entry["tool_name"] == "memory_save" and (
+                            has_running_event_without_id or has_started_event_match
+                        ):
+                            entry["status"] = "success"
+                            entry["duration"] = event.save_time_ms / 1000
+                            entry["result"] = _truncate_log_text(
+                                event.value, _LOG_RESULT_TEXT_LIMIT
+                            )
+                            entry["error"] = None
+                            entry["started_event_id"] = event.started_event_id
+                            break
+                    else:
+                        self._log_entries.append(
+                            {
+                                "tool_name": "memory_save",
+                                "status": "success",
+                                "args": None,
+                                "result": _truncate_log_text(
+                                    event.value, _LOG_RESULT_TEXT_LIMIT
+                                ),
+                                "error": None,
+                                "start_time": time.time(),
+                                "duration": event.save_time_ms / 1000,
+                                "task_idx": self._current_task_idx,
+                                "started_event_id": event.started_event_id,
+                            }
+                        )
+
+            self._unsubscribe_if_no_running_memory_save(wait_for_queued=True)
+
+        self._register_handler(MemorySaveCompletedEvent, on_memory_save_completed)
+
+        @crewai_event_bus.on(MemorySaveFailedEvent)
+        def on_memory_save_failed(source: Any, event: MemorySaveFailedEvent) -> None:
+            with self._lock:
+                if (
+                    event.started_event_id in self._suppressed_memory_save_event_ids
+                    or is_nested_save_to_memory_event(event)
+                ):
+                    if event.started_event_id is not None:
+                        self._suppressed_memory_save_event_ids.discard(
+                            event.started_event_id
+                        )
+                else:
+                    for idx, entry in reversed(list(enumerate(self._log_entries))):
+                        has_started_event_match = (
+                            event.started_event_id is not None
+                            and (
+                                entry.get("event_id") == event.started_event_id
+                                or entry.get("started_event_id")
+                                == event.started_event_id
+                            )
+                        )
+                        has_running_event_without_id = (
+                            event.started_event_id is None
+                            and entry["status"] == "running"
+                        )
+                        if entry["tool_name"] == "memory_save" and (
+                            has_running_event_without_id or has_started_event_match
+                        ):
+                            entry["status"] = "error"
+                            entry["error"] = event.error
+                            entry["duration"] = time.time() - entry["start_time"]
+                            entry["started_event_id"] = event.started_event_id
+                            self._log_expanded.add(idx)
+                            break
+                    else:
+                        self._log_entries.append(
+                            {
+                                "tool_name": "memory_save",
+                                "status": "error",
+                                "args": _truncate_log_text(
+                                    event.value, _LOG_ARGS_TEXT_LIMIT
+                                ),
+                                "result": None,
+                                "error": event.error,
+                                "start_time": time.time(),
+                                "duration": 0,
+                                "task_idx": self._current_task_idx,
+                                "started_event_id": event.started_event_id,
+                            }
+                        )
+                        self._log_expanded.add(len(self._log_entries) - 1)
+
+            self._unsubscribe_if_no_running_memory_save(wait_for_queued=True)
+
+        self._register_handler(MemorySaveFailedEvent, on_memory_save_failed)
+
         @crewai_event_bus.on(MemoryRetrievalStartedEvent)
         def on_memory_retrieval_started(
             source: Any, event: MemoryRetrievalStartedEvent

lib/cli/src/crewai_cli/run_crew.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from contextlib import AbstractContextManager, nullcontext
 from enum import Enum
 import os
@@ -7,10 +8,9 @@ from pathlib import Path
 import re
 import subprocess
 import sys
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 import click
-from crewai.project.json_loader import find_crew_json_file
 from crewai_core.constants import CREWAI_TRAINED_AGENTS_FILE_ENV
 from packaging import version
 
@@ -38,6 +38,15 @@ class CrewType(Enum):
 _INPUT_PLACEHOLDER_RE = re.compile(r"(?<!{){([A-Za-z_][A-Za-z0-9_\-]*)}(?!})")
 _CREWAI_CLI_RUNNER_PACKAGE_DIR_ENV = "CREWAI_CLI_RUNNER_PACKAGE_DIR"
 _CREWAI_RUNNER_SOURCE_DIR_ENV = "CREWAI_RUNNER_SOURCE_DIR"
+_FULL_CREWAI_INSTALL_MESSAGE = """\
+CrewAI CLI is installed without the `crewai` package required to run crews.
+
+Install the full CrewAI prerelease package:
+
+  uv tool install --force --prerelease=allow 'crewai[tools]==1.14.8a1'
+
+The quotes are required in zsh so `crewai[tools]` is not treated as a glob.
+"""
 _JSON_CREW_RUNNER_CODE = """
 import importlib.util
 import os
@@ -72,12 +81,39 @@ module_spec.loader.exec_module(module)
 
 from crewai_core.constants import CREWAI_TRAINED_AGENTS_FILE_ENV
 
-module._run_json_crew(
-    trained_agents_file=os.getenv(CREWAI_TRAINED_AGENTS_FILE_ENV)
-)
+try:
+    module._run_json_crew(
+        trained_agents_file=os.getenv(CREWAI_TRAINED_AGENTS_FILE_ENV)
+    )
+except module.click.ClickException as exc:
+    exc.show()
+    raise SystemExit(exc.exit_code)
 """.strip()
 
 
+def _import_find_crew_json_file() -> Callable[[], Path | None]:
+    from crewai.project.json_loader import find_crew_json_file as _find_crew_json_file
+
+    return cast("Callable[[], Path | None]", _find_crew_json_file)
+
+
+def _is_missing_crewai_package(exc: ModuleNotFoundError) -> bool:
+    return bool(exc.name and exc.name.startswith("crewai"))
+
+
+def _full_crewai_install_error() -> click.ClickException:
+    return click.ClickException(_FULL_CREWAI_INSTALL_MESSAGE)
+
+
+def find_crew_json_file() -> Path | None:
+    try:
+        return _import_find_crew_json_file()()
+    except ModuleNotFoundError as exc:
+        if _is_missing_crewai_package(exc):
+            raise _full_crewai_install_error() from exc
+        raise
+
+
 def _has_json_crew() -> bool:
     """Check if this is a JSON-defined crew project.
 

lib/cli/src/crewai_cli/templates/crew/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.14.8a"
+    "crewai[tools]==1.14.8a1"
 ]
 
 [project.scripts]

lib/cli/src/crewai_cli/templates/flow/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.14.8a"
+    "crewai[tools]==1.14.8a1"
 ]
 
 [project.scripts]

lib/cli/src/crewai_cli/templates/tool/pyproject.toml

@@ -5,7 +5,7 @@ description = "Power up your crews with {{folder_name}}"
 readme = "README.md"
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.14.8a"
+    "crewai[tools]==1.14.8a1"
 ]
 
 [tool.crewai]

lib/cli/tests/test_create_crew.py

@@ -5,7 +5,10 @@ from pathlib import Path
 from unittest import mock
 
 import pytest
+import tomli
 from click.testing import CliRunner
+from packaging.requirements import Requirement
+from packaging.version import Version
 import crewai_cli.create_json_crew as json_crew
 import crewai_cli.tui_picker as tui_picker
 from crewai_cli.create_crew import create_crew, create_folder_structure
@@ -712,6 +715,14 @@ def test_json_create_provider_preselects_default_model(tmp_path, monkeypatch):
     assert not (tmp_path / "json_crew" / "tests").exists()
     assert not (tmp_path / "json_crew" / "config.jsonc").exists()
 
+    pyproject = tomli.loads((tmp_path / "json_crew" / "pyproject.toml").read_text())
+    dependency = pyproject["project"]["dependencies"][0]
+    assert dependency == "crewai[tools]==1.14.8a1"
+    assert Version("1.14.8a1") in Requirement(dependency).specifier
+    assert pyproject["tool"]["hatch"]["build"]["targets"]["wheel"][
+        "only-include"
+    ] == ["agents", "crew.jsonc", "tools", "knowledge", "skills"]
+
     crew_template = (tmp_path / "json_crew" / "crew.jsonc").read_text()
     assert (
         '"guardrail": "Every factual claim needs context support."'

lib/cli/tests/test_crew_run_tui.py

@@ -4,6 +4,11 @@ import time
 import pytest
 
 from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.memory_events import (
+    MemorySaveCompletedEvent,
+    MemorySaveFailedEvent,
+    MemorySaveStartedEvent,
+)
 from crewai.events.types.observation_events import (
     GoalAchievedEarlyEvent,
     PlanRefinementEvent,
@@ -21,7 +26,12 @@ from crewai.events.types.tool_usage_events import (
 )
 from crewai_cli.command import AuthenticationRequiredError
 from crewai_cli import run_crew
-from crewai_cli.crew_run_tui import CrewRunApp
+from crewai_cli.crew_run_tui import (
+    CrewRunApp,
+    _LOG_ARGS_TEXT_LIMIT,
+    _LOG_RESULT_TEXT_LIMIT,
+    _LOG_TRUNCATION_SUFFIX,
+)
 
 
 def _app_with_plan() -> CrewRunApp:
@@ -335,6 +345,396 @@ def test_internal_reasoning_function_call_is_hidden_from_activity_log() -> None:
     assert app._current_task_steps == []
 
 
+def test_memory_save_events_are_shown_in_activity_log() -> None:
+    app = _app_with_plan()
+    app._current_task_idx = 1
+    app._subscribe()
+    try:
+        _emit_event(
+            MemorySaveStartedEvent(
+                value="2 memories (background)",
+                metadata={},
+                source_type="unified_memory",
+            )
+        )
+        _emit_event(
+            MemorySaveCompletedEvent(
+                value="2 memories saved",
+                metadata={},
+                save_time_ms=123,
+                source_type="unified_memory",
+            )
+        )
+    finally:
+        app._unsubscribe()
+
+    assert len(app._log_entries) == 1
+    assert app._log_entries[0]["tool_name"] == "memory_save"
+    assert app._log_entries[0]["status"] == "success"
+    assert app._log_entries[0]["args"] == "2 memories (background)"
+    assert app._log_entries[0]["result"] == "2 memories saved"
+    assert app._log_entries[0]["error"] is None
+    assert app._log_entries[0]["duration"] == 0.123
+    assert app._log_entries[0]["task_idx"] == 1
+
+
+def test_nested_memory_save_event_is_hidden_for_save_to_memory_tool() -> None:
+    app = _app_with_plan()
+    app._subscribe()
+    try:
+        tool_args = {"contents": ["Fact to remember."]}
+        _emit_event(
+            ToolUsageStartedEvent(
+                tool_name="save_to_memory",
+                tool_args=tool_args,
+            )
+        )
+        _emit_event(
+            MemorySaveStartedEvent(
+                value="Fact to remember.",
+                metadata={},
+                source_type="unified_memory",
+            )
+        )
+        _emit_event(
+            MemorySaveCompletedEvent(
+                value="Fact to remember.",
+                metadata={},
+                save_time_ms=123,
+                source_type="unified_memory",
+            )
+        )
+        now = datetime.now()
+        _emit_event(
+            ToolUsageFinishedEvent(
+                tool_name="save_to_memory",
+                tool_args=tool_args,
+                started_at=now,
+                finished_at=now,
+                output="Saved to memory.",
+            )
+        )
+    finally:
+        app._unsubscribe()
+
+    assert len(app._log_entries) == 1
+    assert app._log_entries[0]["tool_name"] == "save_to_memory"
+    assert app._log_entries[0]["status"] == "success"
+    assert app._log_entries[0]["result"] == "Saved to memory."
+
+
+def test_memory_save_failure_is_shown_in_activity_log() -> None:
+    app = _app_with_plan()
+    app._subscribe()
+    try:
+        _emit_event(
+            MemorySaveStartedEvent(
+                value="background save",
+                metadata={},
+                source_type="unified_memory",
+            )
+        )
+        _emit_event(
+            MemorySaveFailedEvent(
+                value="background save",
+                metadata={},
+                error="embedding connection failed",
+                source_type="unified_memory",
+            )
+        )
+    finally:
+        app._unsubscribe()
+
+    assert app._log_entries[0]["tool_name"] == "memory_save"
+    assert app._log_entries[0]["status"] == "error"
+    assert app._log_entries[0]["error"] == "embedding connection failed"
+    assert app._log_expanded == {0}
+
+
+def test_memory_save_completion_updates_timed_out_row() -> None:
+    app = _app_with_plan()
+    app._subscribe()
+    try:
+        _emit_event(
+            MemorySaveStartedEvent(
+                value="9 memories (background)",
+                metadata={},
+                source_type="unified_memory",
+            )
+        )
+
+        app._log_entries[0]["status"] = "timeout"
+        app._log_entries[0]["error"] = "No result received before crew completed"
+        app._log_entries[0]["duration"] = 8.3
+
+        _emit_event(
+            MemorySaveCompletedEvent(
+                value="9 memories saved",
+                metadata={},
+                save_time_ms=8300,
+                source_type="unified_memory",
+            )
+        )
+    finally:
+        app._unsubscribe()
+
+    assert len(app._log_entries) == 1
+    assert app._log_entries[0]["tool_name"] == "memory_save"
+    assert app._log_entries[0]["status"] == "success"
+    assert app._log_entries[0]["result"] == "9 memories saved"
+    assert app._log_entries[0]["error"] is None
+    assert app._log_entries[0]["duration"] == 8.3
+
+
+def test_memory_save_completion_with_unmatched_id_does_not_update_running_row() -> None:
+    app = _app_with_plan()
+    app._subscribe()
+    try:
+        _emit_event(
+            MemorySaveStartedEvent(
+                value="first background save",
+                metadata={},
+                source_type="unified_memory",
+                parent_event_id="manual-parent",
+            )
+        )
+        _emit_event(
+            MemorySaveStartedEvent(
+                value="second background save",
+                metadata={},
+                source_type="unified_memory",
+                parent_event_id="manual-parent",
+            )
+        )
+
+        _emit_event(
+            MemorySaveCompletedEvent(
+                value="orphan save completed",
+                metadata={},
+                save_time_ms=2800,
+                source_type="unified_memory",
+                parent_event_id="manual-parent",
+                started_event_id="missing-memory-save-start",
+            )
+        )
+    finally:
+        app._unsubscribe()
+
+    assert [entry["status"] for entry in app._log_entries] == [
+        "running",
+        "running",
+        "success",
+    ]
+    assert app._log_entries[0]["args"] == "first background save"
+    assert app._log_entries[1]["args"] == "second background save"
+    assert app._log_entries[2]["result"] == "orphan save completed"
+    assert app._log_entries[2]["started_event_id"] == "missing-memory-save-start"
+
+
+def test_memory_save_failure_with_unmatched_id_does_not_update_running_row() -> None:
+    app = _app_with_plan()
+    app._subscribe()
+    try:
+        _emit_event(
+            MemorySaveStartedEvent(
+                value="first background save",
+                metadata={},
+                source_type="unified_memory",
+                parent_event_id="manual-parent",
+            )
+        )
+        _emit_event(
+            MemorySaveStartedEvent(
+                value="second background save",
+                metadata={},
+                source_type="unified_memory",
+                parent_event_id="manual-parent",
+            )
+        )
+
+        _emit_event(
+            MemorySaveFailedEvent(
+                value="orphan save failed",
+                metadata={},
+                error="embedding connection failed",
+                source_type="unified_memory",
+                parent_event_id="manual-parent",
+                started_event_id="missing-memory-save-start",
+            )
+        )
+    finally:
+        app._unsubscribe()
+
+    assert [entry["status"] for entry in app._log_entries] == [
+        "running",
+        "running",
+        "error",
+    ]
+    assert app._log_entries[0]["args"] == "first background save"
+    assert app._log_entries[1]["args"] == "second background save"
+    assert app._log_entries[2]["args"] == "orphan save failed"
+    assert app._log_entries[2]["error"] == "embedding connection failed"
+    assert app._log_entries[2]["started_event_id"] == "missing-memory-save-start"
+    assert app._log_expanded == {2}
+
+
+def test_memory_save_completion_without_id_does_not_update_stale_row() -> None:
+    app = _app_with_plan()
+    now = time.time()
+    app._log_entries = [
+        {
+            "tool_name": "memory_save",
+            "status": "running",
+            "args": "current background save",
+            "result": None,
+            "error": None,
+            "start_time": now,
+            "duration": None,
+            "task_idx": 1,
+        },
+        {
+            "tool_name": "memory_save",
+            "status": "success",
+            "args": "stale background save",
+            "result": "stale save completed",
+            "error": None,
+            "start_time": now - 10,
+            "duration": 1.0,
+            "task_idx": 1,
+        },
+    ]
+
+    app._subscribe()
+    try:
+        _emit_event(
+            MemorySaveCompletedEvent(
+                value="current save completed",
+                metadata={},
+                save_time_ms=2800,
+                source_type="unified_memory",
+                parent_event_id="manual-parent",
+            )
+        )
+    finally:
+        app._unsubscribe()
+
+    assert [entry["status"] for entry in app._log_entries] == [
+        "success",
+        "success",
+    ]
+    assert app._log_entries[0]["args"] == "current background save"
+    assert app._log_entries[0]["result"] == "current save completed"
+    assert app._log_entries[1]["args"] == "stale background save"
+    assert app._log_entries[1]["result"] == "stale save completed"
+
+
+def test_memory_save_failure_without_id_does_not_update_stale_row() -> None:
+    app = _app_with_plan()
+    now = time.time()
+    app._log_entries = [
+        {
+            "tool_name": "memory_save",
+            "status": "running",
+            "args": "current background save",
+            "result": None,
+            "error": None,
+            "start_time": now,
+            "duration": None,
+            "task_idx": 1,
+        },
+        {
+            "tool_name": "memory_save",
+            "status": "success",
+            "args": "stale background save",
+            "result": "stale save completed",
+            "error": None,
+            "start_time": now - 10,
+            "duration": 1.0,
+            "task_idx": 1,
+        },
+    ]
+
+    app._subscribe()
+    try:
+        _emit_event(
+            MemorySaveFailedEvent(
+                value="current save failed",
+                metadata={},
+                error="embedding connection failed",
+                source_type="unified_memory",
+                parent_event_id="manual-parent",
+            )
+        )
+    finally:
+        app._unsubscribe()
+
+    assert [entry["status"] for entry in app._log_entries] == ["error", "success"]
+    assert app._log_entries[0]["args"] == "current background save"
+    assert app._log_entries[0]["error"] == "embedding connection failed"
+    assert app._log_entries[1]["args"] == "stale background save"
+    assert app._log_entries[1]["result"] == "stale save completed"
+    assert app._log_entries[1]["error"] is None
+    assert app._log_expanded == {0}
+
+
+def test_memory_save_payloads_are_truncated_in_activity_log() -> None:
+    app = _app_with_plan()
+    long_args = "a" * (_LOG_ARGS_TEXT_LIMIT + 10)
+    long_result = "r" * (_LOG_RESULT_TEXT_LIMIT + 10)
+
+    app._subscribe()
+    try:
+        _emit_event(
+            MemorySaveStartedEvent(
+                value=long_args,
+                metadata={},
+                source_type="unified_memory",
+            )
+        )
+        _emit_event(
+            MemorySaveCompletedEvent(
+                value=long_result,
+                metadata={},
+                save_time_ms=8300,
+                source_type="unified_memory",
+            )
+        )
+    finally:
+        app._unsubscribe()
+
+    assert len(app._log_entries[0]["args"]) == _LOG_ARGS_TEXT_LIMIT
+    assert app._log_entries[0]["args"].endswith(_LOG_TRUNCATION_SUFFIX)
+    assert len(app._log_entries[0]["result"]) == _LOG_RESULT_TEXT_LIMIT
+    assert app._log_entries[0]["result"].endswith(_LOG_TRUNCATION_SUFFIX)
+
+
+def test_starting_next_tool_does_not_timeout_memory_save() -> None:
+    app = _app_with_plan()
+    app._subscribe()
+    try:
+        _emit_event(
+            MemorySaveStartedEvent(
+                value="9 memories (background)",
+                metadata={},
+                source_type="unified_memory",
+            )
+        )
+        _emit_event(
+            ToolUsageStartedEvent(
+                tool_name="read_website_content",
+                tool_args={"url": "https://example.com"},
+            )
+        )
+    finally:
+        app._unsubscribe()
+
+    assert app._log_entries[0]["tool_name"] == "memory_save"
+    assert app._log_entries[0]["status"] == "running"
+    assert app._log_entries[0]["error"] is None
+    assert app._log_entries[1]["tool_name"] == "read_website_content"
+    assert app._log_entries[1]["status"] == "running"
+
+
 def test_tool_failure_does_not_override_successful_plan_step_completion() -> None:
     app = _app_with_plan()
     app._subscribe()
@@ -480,6 +880,187 @@ async def test_crew_done_does_not_mark_unfinished_tool_successful() -> None:
     assert app._plan_step_status == {1: "failed", 2: "done", 3: "done"}
 
 
+@pytest.mark.asyncio
+async def test_crew_done_does_not_timeout_memory_save() -> None:
+    app = _app_with_plan()
+
+    async with app.run_test(size=(100, 40)) as pilot:
+        app._log_entries = [
+            {
+                "tool_name": "memory_save",
+                "status": "running",
+                "args": "9 memories (background)",
+                "result": None,
+                "error": None,
+                "start_time": time.time() - 8,
+                "duration": None,
+                "task_idx": 1,
+            },
+            {
+                "tool_name": "search",
+                "status": "running",
+                "args": '{"query": "CrewAI"}',
+                "result": None,
+                "error": None,
+                "start_time": time.time() - 2,
+                "duration": None,
+                "task_idx": 1,
+            },
+        ]
+
+        app._on_crew_done("final output")
+        await pilot.pause()
+
+    assert app._log_entries[0]["status"] == "running"
+    assert app._log_entries[0]["error"] is None
+    assert app._log_entries[1]["status"] == "timeout"
+    assert app._log_entries[1]["error"] == "No result received before crew completed"
+
+
+@pytest.mark.asyncio
+async def test_crew_done_keeps_memory_save_subscription_until_completion(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        "crewai_cli.crew_run_tui._MEMORY_SAVE_DRAIN_GRACE_SECONDS", 0.05
+    )
+    app = _app_with_plan()
+    auto_unsubscribed = False
+
+    async with app.run_test(size=(100, 40)) as pilot:
+        try:
+            assert app._event_handlers
+            started_event = MemorySaveStartedEvent(
+                value="9 memories (background)",
+                metadata={},
+                source_type="unified_memory",
+            )
+            _emit_event(started_event)
+
+            app._on_crew_done("final output")
+            await pilot.pause()
+
+            assert app._log_entries[0]["status"] == "running"
+            assert app._event_handlers
+
+            _emit_event(
+                MemorySaveCompletedEvent(
+                    value="9 memories saved",
+                    metadata={},
+                    save_time_ms=8300,
+                    source_type="unified_memory",
+                    started_event_id=started_event.event_id,
+                )
+            )
+            await pilot.pause()
+
+            assert app._event_handlers
+            await pilot.pause(0.08)
+            auto_unsubscribed = not app._event_handlers
+        finally:
+            app._unsubscribe()
+
+    assert app._log_entries[0]["tool_name"] == "memory_save"
+    assert app._log_entries[0]["status"] == "success"
+    assert app._log_entries[0]["result"] == "9 memories saved"
+    assert app._log_entries[0]["error"] is None
+    assert app._log_entries[0]["duration"] == 8.3
+    assert auto_unsubscribed is True
+
+
+@pytest.mark.asyncio
+async def test_crew_done_waits_for_queued_memory_save_events(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        "crewai_cli.crew_run_tui._MEMORY_SAVE_DRAIN_GRACE_SECONDS", 0.05
+    )
+    app = _app_with_plan()
+    auto_unsubscribed = False
+
+    async with app.run_test(size=(100, 40)) as pilot:
+        try:
+            assert app._event_handlers
+
+            app._on_crew_done("final output")
+
+            assert app._event_handlers
+            started_event = MemorySaveStartedEvent(
+                value="9 memories (background)",
+                metadata={},
+                source_type="unified_memory",
+                parent_event_id="manual-parent",
+            )
+            _emit_event(started_event)
+            await pilot.pause()
+
+            assert app._log_entries[0]["tool_name"] == "memory_save"
+            assert app._log_entries[0]["status"] == "running"
+
+            _emit_event(
+                MemorySaveCompletedEvent(
+                    value="9 memories saved",
+                    metadata={},
+                    save_time_ms=8300,
+                    source_type="unified_memory",
+                    parent_event_id="manual-parent",
+                    started_event_id=started_event.event_id,
+                )
+            )
+            await pilot.pause()
+
+            assert app._event_handlers
+            await pilot.pause(0.08)
+            auto_unsubscribed = not app._event_handlers
+        finally:
+            app._unsubscribe()
+
+    assert app._log_entries[0]["tool_name"] == "memory_save"
+    assert app._log_entries[0]["status"] == "success"
+    assert app._log_entries[0]["args"] == "9 memories (background)"
+    assert app._log_entries[0]["result"] == "9 memories saved"
+    assert app._log_entries[0]["error"] is None
+    assert app._log_entries[0]["duration"] == 8.3
+    assert auto_unsubscribed is True
+
+
+@pytest.mark.asyncio
+async def test_crew_failed_does_not_timeout_memory_save() -> None:
+    app = _app_with_plan()
+
+    async with app.run_test(size=(100, 40)) as pilot:
+        app._log_entries = [
+            {
+                "tool_name": "memory_save",
+                "status": "running",
+                "args": "9 memories (background)",
+                "result": None,
+                "error": None,
+                "start_time": time.time() - 8,
+                "duration": None,
+                "task_idx": 1,
+            },
+            {
+                "tool_name": "search",
+                "status": "running",
+                "args": '{"query": "CrewAI"}',
+                "result": None,
+                "error": None,
+                "start_time": time.time() - 2,
+                "duration": None,
+                "task_idx": 1,
+            },
+        ]
+
+        app._on_crew_failed("boom")
+        await pilot.pause()
+
+    assert app._log_entries[0]["status"] == "running"
+    assert app._log_entries[0]["error"] is None
+    assert app._log_entries[1]["status"] == "error"
+    assert app._log_entries[1]["error"] == "No result received before crew failed"
+
+
 def test_streamed_step_observation_updates_named_step_only() -> None:
     app = _app_with_plan()
 

lib/cli/tests/test_run_crew.py

@@ -5,12 +5,33 @@ from pathlib import Path
 import subprocess
 import sys
 
+import click
 import pytest
 from crewai_core.constants import CREWAI_TRAINED_AGENTS_FILE_ENV
 
 import crewai_cli.run_crew as run_crew_module
 
 
+def test_missing_crewai_package_shows_full_install_hint(monkeypatch):
+    def missing_crewai_package():
+        raise ModuleNotFoundError("No module named 'crewai'", name="crewai")
+
+    monkeypatch.setattr(
+        run_crew_module, "_import_find_crew_json_file", missing_crewai_package
+    )
+
+    with pytest.raises(click.ClickException) as exc_info:
+        run_crew_module.find_crew_json_file()
+
+    message = exc_info.value.message
+    assert "CrewAI CLI is installed without the `crewai` package" in message
+    assert (
+        "uv tool install --force --prerelease=allow 'crewai[tools]==1.14.8a1'"
+        in message
+    )
+    assert "quotes are required in zsh" in message
+
+
 def test_run_crew_forwards_trained_agents_file_to_json_crews(monkeypatch):
     """crewai run -f must reach JSON crews, not only classic subprocess crews."""
     monkeypatch.setattr(run_crew_module, "_has_json_crew", lambda: True)

lib/crewai-core/src/crewai_core/__init__.py

@@ -1 +1 @@
-__version__ = "1.14.8a"
+__version__ = "1.14.8a1"

lib/crewai-files/pyproject.toml

@@ -9,7 +9,7 @@ authors = [
 requires-python = ">=3.10, <3.14"
 dependencies = [
     "Pillow~=12.1.1",
-    "pypdf~=6.10.0",
+    "pypdf~=6.13.3",
     "python-magic>=0.4.27",
     "aiocache~=0.12.3",
     "aiofiles~=24.1.0",
@@ -19,6 +19,8 @@ dependencies = [
 
 [tool.uv]
 exclude-newer = "3 days"
+# pypdf 6.13.3 is a security fix newer than the global supply-chain cutoff.
+exclude-newer-package = { pypdf = "2026-06-18T00:00:00Z" }
 
 [build-system]
 requires = ["hatchling"]

lib/crewai-files/src/crewai_files/__init__.py

@@ -152,4 +152,4 @@ __all__ = [
     "wrap_file_source",
 ]
 
-__version__ = "1.14.8a"
+__version__ = "1.14.8a1"

lib/crewai-tools/pyproject.toml

@@ -10,7 +10,7 @@ requires-python = ">=3.10, <3.14"
 dependencies = [
     "pytube~=15.0.0",
     "requests>=2.33.0,<3",
-    "crewai==1.14.8a",
+    "crewai==1.14.8a1",
     "tiktoken>=0.8.0,<0.13",
     "beautifulsoup4~=4.13.4",
     "python-docx~=1.2.0",

lib/crewai-tools/src/crewai_tools/__init__.py

@@ -330,4 +330,4 @@ __all__ = [
     "ZapierActionTools",
 ]
 
-__version__ = "1.14.8a"
+__version__ = "1.14.8a1"

lib/crewai/pyproject.toml

@@ -8,8 +8,8 @@ authors = [
 ]
 requires-python = ">=3.10, <3.14"
 dependencies = [
-    "crewai-core==1.14.8a",
-    "crewai-cli==1.14.8a",
+    "crewai-core==1.14.8a1",
+    "crewai-cli==1.14.8a1",
     # Core Dependencies
     "pydantic>=2.11.9,<2.13",
     "openai>=2.30.0,<3",
@@ -55,7 +55,7 @@ Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
 tools = [
-    "crewai-tools==1.14.8a",
+    "crewai-tools==1.14.8a1",
 ]
 embeddings = [
     "tiktoken>=0.8.0,<0.13"

lib/crewai/src/crewai/__init__.py

@@ -48,7 +48,7 @@ def _suppress_pydantic_deprecation_warnings() -> None:
 
 _suppress_pydantic_deprecation_warnings()
 
-__version__ = "1.14.8a"
+__version__ = "1.14.8a1"
 
 _LAZY_IMPORTS: dict[str, tuple[str, str]] = {
     "Memory": ("crewai.memory.unified_memory", "Memory"),

lib/crewai/src/crewai/flow/__init__.py

@@ -10,6 +10,7 @@ from crewai.flow.conversation import (
     ConversationalInputs,
 )
 from crewai.flow.dsl import HumanFeedbackResult, human_feedback
+from crewai.flow.expressions import Expression
 from crewai.flow.flow import Flow, and_, listen, or_, router, start
 from crewai.flow.flow_config import flow_config
 from crewai.flow.input_provider import InputProvider, InputResponse
@@ -26,6 +27,7 @@ __all__ = [
     "ConsoleProvider",
     "ConversationalConfig",
     "ConversationalInputs",
+    "Expression",
     "Flow",
     "FlowStructure",
     "HumanFeedbackPending",

lib/crewai/src/crewai/flow/expressions.py

@@ -0,0 +1,329 @@
+"""Runtime expression support for FlowDefinition CEL expressions."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+import json
+from typing import TYPE_CHECKING, Any, TypeAlias, cast
+
+from crewai.utilities.serialization import to_serializable
+
+
+if TYPE_CHECKING:
+    from crewai.flow.runtime import Flow
+else:
+    from typing_extensions import TypeAliasType
+
+
+_CEL_MACROS_WITH_LOCAL_BINDINGS = frozenset(
+    {"all", "exists", "exists_one", "filter", "map"}
+)
+if TYPE_CHECKING:
+    ExpressionData: TypeAlias = (
+        str
+        | int
+        | float
+        | bool
+        | None
+        | list["ExpressionData"]
+        | dict[str, "ExpressionData"]
+    )
+else:
+    ExpressionData = TypeAliasType(
+        "ExpressionData",
+        str
+        | int
+        | float
+        | bool
+        | None
+        | list["ExpressionData"]
+        | dict[str, "ExpressionData"],
+    )
+
+__all__ = [
+    "Expression",
+    "ExpressionData",
+    "ExpressionError",
+]
+
+
+class ExpressionError(ValueError):
+    """An expression failed to parse, validate, render, or evaluate."""
+
+
+class Expression:
+    """CEL expression helper used for definition-time checks and runtime rendering."""
+
+    def __init__(
+        self, value: ExpressionData, *, context: dict[str, Any] | None = None
+    ) -> None:
+        self.value = value
+        self.context = context
+
+    @classmethod
+    def from_flow(
+        cls,
+        value: ExpressionData,
+        flow: Flow[Any],
+        *,
+        local_context: dict[str, Any] | None = None,
+    ) -> Expression:
+        """Build an expression with the standard Flow runtime context."""
+        return cls(value, context=cls._flow_context(flow, local_context=local_context))
+
+    def validate_expression(
+        self,
+        *,
+        allowed_roots: Iterable[str],
+        source: str = "CEL expression",
+    ) -> None:
+        """Validate a full CEL expression without evaluating it."""
+        allowed = frozenset(allowed_roots)
+        expression = self._require_cel_source(cast(str, self.value), source=source)
+        roots = self._collect_root_identifiers(
+            self._compile_cel(expression, source=source)
+        )
+        unknown = sorted(root for root in roots if root not in allowed)
+        if unknown:
+            allowed_list = ", ".join(sorted(allowed))
+            unknown_list = ", ".join(repr(root) for root in unknown)
+            raise ExpressionError(
+                f"unknown CEL root at {source}: {unknown_list}; "
+                f"allowed roots: {allowed_list}. Reference flow data through one "
+                "of those roots, for example state.field or outputs.step_name."
+            )
+
+    def validate_template(
+        self,
+        *,
+        allowed_roots: Iterable[str],
+        source: str = "with block",
+    ) -> None:
+        """Validate nested strings fully wrapped in ``${...}`` as CEL."""
+        self._validate_template_value(
+            self.value, allowed_roots=allowed_roots, source=source
+        )
+
+    def evaluate(self, context: dict[str, Any] | None = None) -> Any:
+        """Evaluate this value as a full CEL expression."""
+        resolved_context = self.context if context is None else context
+        return self._evaluate_cel(
+            self._require_cel_source(cast(str, self.value)),
+            resolved_context or {},
+        )
+
+    def render_template(self, context: dict[str, Any] | None = None) -> Any:
+        """Evaluate nested strings fully wrapped in ``${...}`` as CEL."""
+        resolved_context = self.context if context is None else context
+        return self._render_template_value(self.value, resolved_context or {})
+
+    @staticmethod
+    def _validate_template_value(
+        value: ExpressionData,
+        *,
+        allowed_roots: Iterable[str],
+        source: str,
+    ) -> None:
+        if isinstance(value, str):
+            expression = Expression._expression_marker_source(value, source=source)
+            if expression is not None:
+                Expression(expression).validate_expression(
+                    allowed_roots=allowed_roots, source=source
+                )
+            return
+        if isinstance(value, dict):
+            for key, item in value.items():
+                item_source = f"{source}.{key}" if isinstance(key, str) else source
+                Expression._validate_template_value(
+                    item, allowed_roots=allowed_roots, source=item_source
+                )
+            return
+        if isinstance(value, list):
+            for index, item in enumerate(value):
+                Expression._validate_template_value(
+                    item,
+                    allowed_roots=allowed_roots,
+                    source=f"{source}[{index}]",
+                )
+
+    @staticmethod
+    def _flow_context(
+        flow: Flow[Any], local_context: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        from crewai.flow.runtime._outputs import outputs_by_name
+
+        local_outputs = local_context.get("outputs") if local_context else None
+        outputs = outputs_by_name(
+            flow._method_outputs,
+            local_outputs=local_outputs,
+            serialize=True,
+        )
+        context: dict[str, Any] = {
+            "state": flow._copy_and_serialize_state(),
+            "outputs": outputs,
+        }
+        if local_context:
+            context.update(
+                {
+                    key: to_serializable(value, max_depth=0)
+                    for key, value in local_context.items()
+                    if key not in {"outputs", "state"}
+                }
+            )
+        return context
+
+    @staticmethod
+    def _render_template_value(value: ExpressionData, context: dict[str, Any]) -> Any:
+        if isinstance(value, str):
+            return Expression._render_template_string(value, context)
+        if isinstance(value, dict):
+            return {
+                key: Expression._render_template_value(item, context)
+                for key, item in value.items()
+            }
+        if isinstance(value, list):
+            return [Expression._render_template_value(item, context) for item in value]
+        return value
+
+    @staticmethod
+    def _render_template_string(value: str, context: dict[str, Any]) -> Any:
+        expression = Expression._expression_marker_source(value)
+        if expression is None:
+            return value
+        return Expression._evaluate_cel(expression, context)
+
+    @staticmethod
+    def _expression_marker_source(
+        value: str, *, source: str | None = None
+    ) -> str | None:
+        """Return CEL source when the trimmed string starts with ``${`` and ends with ``}``."""
+        stripped = value.strip()
+        if not stripped.startswith("${"):
+            return None
+        if not stripped.endswith("}"):
+            return None
+
+        expression = stripped[2:-1].strip()
+        if not expression:
+            if source is None:
+                raise ExpressionError("empty CEL expression in with block")
+            raise ExpressionError(f"empty CEL expression at {source}")
+        return expression
+
+    @staticmethod
+    def _evaluate_cel(expression: str, context: dict[str, Any]) -> Any:
+        try:
+            from celpy import Environment
+            from celpy.adapter import CELJSONEncoder, json_to_cel
+            from celpy.evaluation import Context
+
+            environment = Environment()
+            program = environment.program(
+                Expression._compile_cel(expression, environment=environment)
+            )
+            result = program.evaluate(cast(Context, json_to_cel(context)))
+            return json.loads(json.dumps(result, cls=CELJSONEncoder))
+        except Exception as e:
+            raise ExpressionError(
+                f"failed to evaluate CEL expression {expression!r}: {e}"
+            ) from e
+
+    @staticmethod
+    def _compile_cel(
+        expression: str,
+        *,
+        source: str | None = None,
+        environment: Any | None = None,
+    ) -> Any:
+        if environment is None:
+            from celpy import Environment
+
+            environment = Environment()
+        try:
+            return environment.compile(expression)
+        except Exception as e:
+            if source is None:
+                raise
+            raise ExpressionError(
+                f"invalid CEL expression at {source}: {expression!r}. "
+                f"Check the CEL syntax. Parser details: {e}"
+            ) from e
+
+    @staticmethod
+    def _require_cel_source(value: str, *, source: str | None = None) -> str:
+        expression = value.strip()
+        if expression.startswith("${") and expression.endswith("}"):
+            expression = expression[2:-1].strip()
+        if expression:
+            return expression
+        if source is None:
+            raise ExpressionError("empty CEL expression")
+        raise ExpressionError(
+            f"empty CEL expression at {source}. Provide a CEL expression such as "
+            "state.topic or outputs.step_name."
+        )
+
+    @staticmethod
+    def _collect_root_identifiers(
+        tree: Any, local_roots: frozenset[str] = frozenset()
+    ) -> set[str]:
+        """Collect CEL root identifiers, excluding receiver macro local variables."""
+        data = getattr(tree, "data", None)
+        children = list(getattr(tree, "children", []) or [])
+
+        if data == "ident" and children:
+            name = str(children[0])
+            return set() if name in local_roots else {name}
+
+        if data == "ident_arg":
+            return Expression._collect_root_identifiers_from(
+                children[1:], local_roots=local_roots
+            )
+
+        if data == "member_dot_arg":
+            roots = (
+                Expression._collect_root_identifiers(children[0], local_roots)
+                if children
+                else set()
+            )
+            nested_locals = frozenset(
+                {*local_roots, *Expression._receiver_macro_local_roots(children)}
+            )
+            roots.update(
+                Expression._collect_root_identifiers_from(
+                    children[2:], local_roots=nested_locals
+                )
+            )
+            return roots
+
+        return Expression._collect_root_identifiers_from(
+            children, local_roots=local_roots
+        )
+
+    @staticmethod
+    def _collect_root_identifiers_from(
+        trees: Iterable[Any], *, local_roots: frozenset[str]
+    ) -> set[str]:
+        return set().union(
+            *(Expression._collect_root_identifiers(tree, local_roots) for tree in trees)
+        )
+
+    @staticmethod
+    def _receiver_macro_local_roots(children: list[Any]) -> set[str]:
+        if len(children) < 3 or str(children[1]) not in _CEL_MACROS_WITH_LOCAL_BINDINGS:
+            return set()
+        exprlist = children[2]
+        exprs = list(getattr(exprlist, "children", []) or [])
+        if exprs and (name := Expression._single_identifier_name(exprs[0])):
+            return {name}
+        return set()
+
+    @staticmethod
+    def _single_identifier_name(tree: Any) -> str | None:
+        data = getattr(tree, "data", None)
+        children = list(getattr(tree, "children", []) or [])
+        if data == "ident" and children:
+            return str(children[0])
+        if len(children) != 1:
+            return None
+        return Expression._single_identifier_name(children[0])

lib/crewai/src/crewai/flow/flow_definition.py

@@ -12,13 +12,12 @@ from __future__ import annotations
 import json
 import logging
 import re
-from typing import Annotated, Any, Literal, TypeAlias
+from typing import Annotated, Any, Literal, TypeAlias, cast
 
 from pydantic import (
     BaseModel,
     ConfigDict,
     Field,
-    RootModel,
     field_serializer,
     model_validator,
 )
@@ -28,16 +27,21 @@ from crewai.flow.conversational_definition import (
     FlowConversationalDefinition,
     FlowConversationalRouterDefinition,
 )
-from crewai.project.crew_definition import CrewDefinition
+from crewai.flow.expressions import ExpressionData
+from crewai.project.crew_definition import AgentDefinition, CrewDefinition
 
 
 logger = logging.getLogger(__name__)
 
 FlowDefinitionCondition = str | dict[str, Any]
 _STEP_NAME_PATTERN = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+_BASE_CEL_ROOTS = frozenset({"outputs", "state"})
+_EACH_STEP_CEL_ROOTS = frozenset({"item", "outputs", "state"})
 
 __all__ = [
     "FlowActionDefinition",
+    "FlowAgentActionDefinition",
+    "FlowAtomicActionDefinition",
     "FlowCodeActionDefinition",
     "FlowConfigDefinition",
     "FlowConversationalDefinition",
@@ -47,7 +51,7 @@ __all__ = [
     "FlowDefinitionCondition",
     "FlowDictStateDefinition",
     "FlowEachActionDefinition",
-    "FlowEachInnerActionDefinition",
+    "FlowEachStepDefinition",
     "FlowExpressionActionDefinition",
     "FlowHumanFeedbackDefinition",
     "FlowJsonSchemaStateDefinition",
@@ -353,10 +357,14 @@ class FlowCodeActionDefinition(BaseModel):
         description="Import reference for the callable, formatted as module:qualname.",
         examples=["my_project.flows:normalize_topic"],
     )
-    with_: dict[str, Any] | None = Field(
+    with_: dict[str, ExpressionData] | None = Field(
         default=None,
         alias="with",
-        description="Keyword arguments passed to the callable after expression rendering.",
+        description=(
+            "Keyword arguments passed to the callable. String values are evaluated "
+            "as CEL only when the trimmed value starts with ${ and ends with }; "
+            "all other values are literal."
+        ),
         examples=[{"topic": "${state.topic}"}],
     )
 
@@ -377,10 +385,14 @@ class FlowToolActionDefinition(BaseModel):
         description="Import reference for a BaseTool class, formatted as module:qualname.",
         examples=["my_project.tools:SearchTool"],
     )
-    with_: dict[str, Any] | None = Field(
+    with_: dict[str, ExpressionData] | None = Field(
         default=None,
         alias="with",
-        description="Tool input arguments after expression rendering.",
+        description=(
+            "Tool input arguments. String values are evaluated as CEL only when "
+            "the trimmed value starts with ${ and ends with }; all other values "
+            "are literal."
+        ),
         examples=[{"query": "${outputs.normalize_topic}", "limit": 5}],
     )
 
@@ -424,6 +436,33 @@ class FlowCrewActionDefinition(BaseModel):
     )
 
 
+class FlowAgentActionDefinition(BaseModel):
+    """A Flow method action that builds and kicks off a CrewAI agent."""
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        extra="forbid",
+    )
+
+    call: Literal["agent"] = Field(
+        description="Action discriminator. Use agent to run an inline Agent definition.",
+        examples=["agent"],
+    )
+    with_: AgentDefinition = Field(
+        alias="with",
+        description="Inline Agent definition to load and execute for this action.",
+        examples=[
+            {
+                "role": "Analyst",
+                "goal": "Answer user questions",
+                "backstory": "Precise and concise.",
+                "settings": {"llm": "openai/gpt-4o-mini"},
+                "input": "${state.question}",
+            }
+        ],
+    )
+
+
 class FlowExpressionActionDefinition(BaseModel):
     """A Flow method action that evaluates a CEL expression."""
 
@@ -466,38 +505,49 @@ class FlowScriptActionDefinition(BaseModel):
     )
 
 
-FlowInnerActionDefinition = (
+FlowAtomicActionDefinition: TypeAlias = Annotated[
     FlowCodeActionDefinition
     | FlowToolActionDefinition
     | FlowCrewActionDefinition
+    | FlowAgentActionDefinition
     | FlowExpressionActionDefinition
-    | FlowScriptActionDefinition
-)
+    | FlowScriptActionDefinition,
+    Field(discriminator="call"),
+]
 
 
-class FlowEachInnerActionDefinition(RootModel[dict[str, FlowInnerActionDefinition]]):
-    """One named action inside an ``each`` composite action."""
+class FlowEachStepDefinition(BaseModel):
+    """One named step inside an ``each`` composite action."""
 
-    root: dict[str, FlowInnerActionDefinition] = Field(
-        description="Single-entry mapping from an inner action name to its action.",
-        examples=[{"clean": {"call": "script", "code": "return item.strip()"}}],
+    model_config = ConfigDict(
+        populate_by_name=True,
+        extra="forbid",
+    )
+
+    name: str = Field(
+        description="Step name used to reference this step's output.",
+        examples=["clean"],
+    )
+    if_: str | None = Field(
+        default=None,
+        alias="if",
+        description=(
+            "Optional CEL expression evaluated against state, outputs, and local "
+            "context. When present, the step runs only if the expression evaluates "
+            "to true."
+        ),
+        examples=["item.kind == 'invoice'"],
+    )
+    action: FlowAtomicActionDefinition = Field(
+        description="Atomic action to run for this step.",
+        examples=[{"call": "script", "code": "return item.strip()"}],
     )
 
     @model_validator(mode="after")
-    def _validate_action_mapping(self) -> FlowEachInnerActionDefinition:
-        if len(self.root) != 1:
-            raise ValueError("each.do entries must be one-key mappings")
-        _validate_step_name(self.name, field="each.do action names")
+    def _validate_step_name(self) -> FlowEachStepDefinition:
+        _validate_step_name(self.name, field="each.do step names")
         return self
 
-    @property
-    def name(self) -> str:
-        return next(iter(self.root))
-
-    @property
-    def action(self) -> FlowInnerActionDefinition:
-        return next(iter(self.root.values()))
-
 
 class FlowEachActionDefinition(BaseModel):
     """A composite action that runs a sequential mini-pipeline for each item."""
@@ -519,38 +569,40 @@ class FlowEachActionDefinition(BaseModel):
         description="CEL expression that must evaluate to the list to iterate.",
         examples=["state.rows"],
     )
-    do: list[FlowEachInnerActionDefinition] = Field(
+    do: list[FlowEachStepDefinition] = Field(
         description=(
-            "Ordered inner actions to run for each item. Each entry must be a "
-            "single-key mapping naming that inner action."
+            "Ordered steps to run for each item. Each step has a name, optional "
+            "if expression, and atomic action."
         ),
         examples=[
             [
-                {"clean": {"call": "script", "code": "return item.strip()"}},
-                {"tag": {"call": "expression", "expr": "outputs.clean"}},
+                {
+                    "name": "clean",
+                    "action": {"call": "script", "code": "return item.strip()"},
+                },
+                {
+                    "name": "tag",
+                    "if": "outputs.clean != ''",
+                    "action": {"call": "expression", "expr": "outputs.clean"},
+                },
             ]
         ],
     )
 
     @model_validator(mode="after")
-    def _validate_inner_action_list(self) -> FlowEachActionDefinition:
+    def _validate_step_list(self) -> FlowEachActionDefinition:
         if not self.do:
-            raise ValueError("each.do must contain at least one action")
-
-        seen: set[str] = set()
-        for inner_action in self.do:
-            name = inner_action.name
-            if name in seen:
-                raise ValueError(f"each.do action names must be unique: {name!r}")
-            seen.add(name)
+            raise ValueError("each.do must contain at least one step")
 
+        _validate_step_list(self.do, field="each.do")
         return self
 
 
-FlowActionDefinition = (
+FlowActionDefinition: TypeAlias = (
     FlowCodeActionDefinition
     | FlowToolActionDefinition
     | FlowCrewActionDefinition
+    | FlowAgentActionDefinition
     | FlowExpressionActionDefinition
     | FlowScriptActionDefinition
     | FlowEachActionDefinition
@@ -685,6 +737,16 @@ class FlowDefinition(BaseModel):
             _validate_step_name(method_name, field="Flow method names")
         return self
 
+    @model_validator(mode="after")
+    def _validate_cel_expressions(self) -> FlowDefinition:
+        for method_name, method in self.methods.items():
+            _validate_action_cel(
+                method.do,
+                path=f"methods.{method_name}.do",
+                allowed_roots=_BASE_CEL_ROOTS,
+            )
+        return self
+
     def to_dict(self, *, exclude_none: bool = True) -> dict[str, Any]:
         """Serialize the definition to a JSON/YAML-ready dictionary."""
         return self.model_dump(by_alias=True, exclude_none=exclude_none, mode="json")
@@ -733,6 +795,78 @@ def _validate_step_name(name: str, *, field: str) -> None:
         raise ValueError(f"{field} must match {_STEP_NAME_PATTERN.pattern}")
 
 
+def _validate_step_list(steps: list[FlowEachStepDefinition], *, field: str) -> None:
+    seen: set[str] = set()
+    for step in steps:
+        name = step.name
+        if name in seen:
+            raise ValueError(f"{field} step names must be unique: {name!r}")
+        seen.add(name)
+
+
+def _validate_action_cel(
+    action: FlowActionDefinition,
+    *,
+    path: str,
+    allowed_roots: frozenset[str],
+) -> None:
+    from crewai.flow.expressions import Expression
+
+    if isinstance(action, FlowExpressionActionDefinition):
+        Expression(action.expr).validate_expression(
+            allowed_roots=allowed_roots, source=f"{path}.expr"
+        )
+        return
+
+    if isinstance(action, (FlowCodeActionDefinition, FlowToolActionDefinition)):
+        if action.with_ is not None:
+            Expression(action.with_).validate_template(
+                allowed_roots=allowed_roots, source=f"{path}.with"
+            )
+        return
+
+    if isinstance(action, FlowCrewActionDefinition):
+        Expression(cast(ExpressionData, action.with_.inputs)).validate_template(
+            allowed_roots=allowed_roots,
+            source=f"{path}.with.inputs",
+        )
+        return
+
+    if isinstance(action, FlowAgentActionDefinition):
+        Expression(cast(ExpressionData, action.with_.input)).validate_template(
+            allowed_roots=allowed_roots,
+            source=f"{path}.with.input",
+        )
+        return
+
+    if isinstance(action, FlowEachActionDefinition):
+        Expression(action.in_).validate_expression(
+            allowed_roots=_BASE_CEL_ROOTS,
+            source=f"{path}.in",
+        )
+        for index, step in enumerate(action.do):
+            step_path = f"{path}.do[{index}]"
+            if step.if_ is not None:
+                Expression(step.if_).validate_expression(
+                    allowed_roots=_EACH_STEP_CEL_ROOTS,
+                    source=f"{step_path}.if",
+                )
+            _validate_action_cel(
+                step.action,
+                path=f"{step_path}.action",
+                allowed_roots=_EACH_STEP_CEL_ROOTS,
+            )
+        return
+
+    if isinstance(action, FlowScriptActionDefinition):
+        return
+
+    raise TypeError(
+        f"no CEL validation defined for action type {type(action).__name__} at "
+        f"{path}; add a branch to _validate_action_cel for it."
+    )
+
+
 def log_flow_definition_issues(definition: FlowDefinition) -> None:
     for method_name, method in definition.methods.items():
         path = f"methods.{method_name}"

lib/crewai/src/crewai/flow/runtime/_actions.py

@@ -4,23 +4,24 @@ from __future__ import annotations
 
 import ast
 import asyncio
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 import contextvars
 import inspect
 import os
 from typing import TYPE_CHECKING, Any, Protocol, cast
 
+from crewai.flow.expressions import Expression, ExpressionData
 from crewai.flow.flow_definition import (
     FlowActionDefinition,
+    FlowAgentActionDefinition,
     FlowCodeActionDefinition,
     FlowCrewActionDefinition,
     FlowEachActionDefinition,
-    FlowEachInnerActionDefinition,
+    FlowEachStepDefinition,
     FlowExpressionActionDefinition,
     FlowScriptActionDefinition,
     FlowToolActionDefinition,
 )
-from crewai.flow.runtime._expressions import evaluate_expression, render_with_block
 from crewai.flow.runtime._outputs import outputs_by_name
 from crewai.flow.runtime._refs import InvalidRefError, resolve_ref
 
@@ -32,6 +33,8 @@ if TYPE_CHECKING:
 __all__ = ["FlowScriptExecutionDisabledError", "build_action"]
 
 LocalContext = dict[str, Any]
+NestedStepRunner = Callable[[LocalContext], Awaitable[Any]]
+NestedStep = tuple[str, str | None, NestedStepRunner]
 _LOCAL_CONTEXT_KWARG = "__flow_definition_local_context"
 _ALLOW_SCRIPT_EXECUTION_ENV_VAR = "CREWAI_ALLOW_FLOW_SCRIPT_EXECUTION"
 _TRUSTED_SCRIPT_EXECUTION_VALUES = frozenset({"1", "true", "yes"})
@@ -65,9 +68,9 @@ class CodeAction:
         if self.definition.with_ is None:
             return self.handler(*args, **kwargs)
         return self.handler(
-            **render_with_block(
-                self.flow, self.definition.with_, local_context=local_context
-            )
+            **Expression.from_flow(
+                self.definition.with_, self.flow, local_context=local_context
+            ).render_template()
         )
 
     def _resolve_handler(self) -> Callable[..., Any]:
@@ -93,7 +96,9 @@ class ToolAction:
     def run(self, *_args: Any, **kwargs: Any) -> Any:
         local_context = _pop_local_context(kwargs)
         return self.tool.run(
-            **render_with_block(self.flow, self.kwargs, local_context=local_context)
+            **Expression.from_flow(
+                self.kwargs, self.flow, local_context=local_context
+            ).render_template()
         )
 
     def _build_tool(self) -> Any:
@@ -127,13 +132,44 @@ class CrewAction:
 
         local_context = _pop_local_context(kwargs)
         crew_definition = self.definition.with_
-        inputs = render_with_block(
-            self.flow, crew_definition.inputs, local_context=local_context
-        )
+        inputs = Expression.from_flow(
+            cast(ExpressionData, crew_definition.inputs),
+            self.flow,
+            local_context=local_context,
+        ).render_template()
         crew, _ = load_crew_from_definition(crew_definition, source="crew action")
         return await crew.kickoff_async(inputs=inputs)
 
 
+class AgentAction:
+    definition_type = FlowAgentActionDefinition
+
+    def __init__(self, flow: Flow[Any], definition: FlowAgentActionDefinition) -> None:
+        self.flow = flow
+        self.definition = definition
+
+    async def run(self, *_args: Any, **kwargs: Any) -> Any:
+        from crewai.project.json_loader import load_agent_from_definition
+
+        local_context = _pop_local_context(kwargs)
+        rendered_input = Expression.from_flow(
+            cast(ExpressionData, self.definition.with_.input),
+            self.flow,
+            local_context=local_context,
+        ).render_template()
+        if not isinstance(rendered_input, str):
+            raise ValueError("agent input must render to a string")
+
+        agent, response_format = load_agent_from_definition(
+            self.definition.with_,
+            source="agent action",
+        )
+        return await agent.kickoff_async(
+            rendered_input,
+            response_format=response_format,
+        )
+
+
 class ExpressionAction:
     definition_type = FlowExpressionActionDefinition
 
@@ -145,9 +181,9 @@ class ExpressionAction:
 
     def run(self, *_args: Any, **kwargs: Any) -> Any:
         local_context = _pop_local_context(kwargs)
-        return evaluate_expression(
-            self.flow, self.definition.expr, local_context=local_context
-        )
+        return Expression.from_flow(
+            self.definition.expr, self.flow, local_context=local_context
+        ).evaluate()
 
 
 class ScriptAction:
@@ -217,13 +253,13 @@ class EachAction:
     def __init__(self, flow: Flow[Any], definition: FlowEachActionDefinition) -> None:
         self.flow = flow
         self.definition = definition
-        self.inner_actions = [
-            (inner_action.name, self._build_inner_action(inner_action))
-            for inner_action in definition.do
+        self.steps: list[NestedStep] = [
+            (step.name, step.if_, self._build_step_action(step))
+            for step in definition.do
         ]
 
     async def run(self, *_args: Any, **_kwargs: Any) -> list[Any]:
-        items = evaluate_expression(self.flow, self.definition.in_)
+        items = Expression.from_flow(self.definition.in_, self.flow).evaluate()
         if not isinstance(items, list):
             raise ValueError("each.in must evaluate to an array")
 
@@ -231,22 +267,32 @@ class EachAction:
 
         for item in items:
             local_outputs: dict[str, Any] = {}
+            local_context = {"item": item, "outputs": local_outputs}
             last_output: Any = None
-            for name, run_inner_action in self.inner_actions:
-                last_output = await run_inner_action(
-                    {"item": item, "outputs": local_outputs}
-                )
+            for name, condition, run_step_action in self.steps:
+                if condition is not None and not self._condition_matches(
+                    condition, local_context
+                ):
+                    continue
+
+                last_output = await run_step_action(local_context)
                 local_outputs[name] = last_output
             results.append(last_output)
 
         return results
 
-    def _build_inner_action(
-        self, inner_action: FlowEachInnerActionDefinition
-    ) -> Callable[[LocalContext], Any]:
-        run_action = build_action(self.flow, inner_action.action)
+    def _condition_matches(self, condition: str, local_context: LocalContext) -> bool:
+        result = Expression.from_flow(
+            condition, self.flow, local_context=local_context
+        ).evaluate()
+        if not isinstance(result, bool):
+            raise ValueError("if expression must evaluate to a boolean")
+        return result
 
-        async def run_inner_action(local_context: LocalContext) -> Any:
+    def _build_step_action(self, step: FlowEachStepDefinition) -> NestedStepRunner:
+        run_action = build_action(self.flow, step.action)
+
+        async def run_step_action(local_context: LocalContext) -> Any:
             kwargs = {_LOCAL_CONTEXT_KWARG: local_context}
             if inspect.iscoroutinefunction(run_action):
                 result = run_action(**kwargs)
@@ -261,13 +307,14 @@ class EachAction:
                 result = await result
             return result
 
-        return run_inner_action
+        return run_step_action
 
 
 _ACTION_TYPES: tuple[_ActionType, ...] = (
     EachAction,
     CodeAction,
     ToolAction,
+    AgentAction,
     CrewAction,
     ExpressionAction,
     ScriptAction,

lib/crewai/src/crewai/flow/runtime/_expressions.py

@@ -1,146 +0,0 @@
-"""Runtime expression support for FlowDefinition CEL expressions."""
-
-from __future__ import annotations
-
-from itertools import pairwise
-import json
-import re
-from typing import TYPE_CHECKING, Any, cast
-
-from crewai.flow.runtime._outputs import outputs_by_name
-from crewai.utilities.serialization import to_serializable
-
-
-if TYPE_CHECKING:
-    from crewai.flow.runtime import Flow
-
-
-_EXPRESSION_PATTERN = re.compile(r"\$\{([^{}]*)\}")
-
-__all__ = ["FlowExpressionError", "evaluate_expression", "render_with_block"]
-
-
-class FlowExpressionError(ValueError):
-    """A FlowDefinition expression failed to parse or evaluate."""
-
-
-def render_with_block(
-    flow: Flow[Any], value: Any, local_context: dict[str, Any] | None = None
-) -> Any:
-    """Render CEL expressions inside a FlowDefinition ``with:`` payload."""
-    context = _expression_context(flow, local_context=local_context)
-    return _render_value(value, context)
-
-
-def evaluate_expression(
-    flow: Flow[Any], expression: str, local_context: dict[str, Any] | None = None
-) -> Any:
-    """Evaluate a FlowDefinition CEL expression against runtime context."""
-    expression = expression.strip()
-    if not expression:
-        raise FlowExpressionError("empty CEL expression")
-    return _eval_cel(expression, _expression_context(flow, local_context=local_context))
-
-
-def _expression_context(
-    flow: Flow[Any], local_context: dict[str, Any] | None = None
-) -> dict[str, Any]:
-    local_outputs = local_context.get("outputs") if local_context else None
-    outputs = outputs_by_name(
-        flow._method_outputs,
-        local_outputs=local_outputs,
-        serialize=True,
-    )
-    context: dict[str, Any] = {
-        "state": flow._copy_and_serialize_state(),
-        "outputs": outputs,
-    }
-    if local_context:
-        local_values = {
-            key: to_serializable(value, max_depth=0)
-            for key, value in local_context.items()
-            if key not in {"outputs", "state"}
-        }
-        context.update(local_values)
-    return context
-
-
-def _render_value(value: Any, context: dict[str, Any]) -> Any:
-    if isinstance(value, str):
-        return _render_string(value, context)
-    if isinstance(value, dict):
-        return {key: _render_value(item, context) for key, item in value.items()}
-    if isinstance(value, list):
-        return [_render_value(item, context) for item in value]
-    return value
-
-
-def _render_string(value: str, context: dict[str, Any]) -> Any:
-    matches = list(_EXPRESSION_PATTERN.finditer(value))
-    if not matches:
-        _raise_for_invalid_interpolation(value)
-        return value
-
-    _raise_for_literal_braces(value[: matches[0].start()])
-    for previous, current in pairwise(matches):
-        _raise_for_literal_braces(value[previous.end() : current.start()])
-    _raise_for_literal_braces(value[matches[-1].end() :])
-
-    if len(matches) == 1 and matches[0].span() == (0, len(value)):
-        expression = matches[0].group(1).strip()
-        if not expression:
-            raise FlowExpressionError("empty CEL expression in with block")
-        return _eval_cel(expression, context)
-
-    rendered: list[str] = []
-    position = 0
-    for match in matches:
-        start, end = match.span()
-        literal = value[position:start]
-        rendered.append(literal)
-
-        expression = match.group(1).strip()
-        if not expression:
-            raise FlowExpressionError("empty CEL expression in with block")
-        result = _eval_cel(expression, context)
-        rendered.append(result if isinstance(result, str) else json.dumps(result))
-        position = end
-
-    literal = value[position:]
-    rendered.append(literal)
-
-    return "".join(rendered)
-
-
-def _raise_for_invalid_interpolation(value: str) -> None:
-    if "${" not in value:
-        return
-    raise FlowExpressionError(
-        "invalid CEL interpolation in with block: expressions must be enclosed "
-        "as ${...} and cannot contain braces"
-    )
-
-
-def _raise_for_literal_braces(value: str) -> None:
-    if "{" not in value and "}" not in value:
-        return
-    raise FlowExpressionError(
-        "invalid CEL interpolation in with block: expressions must be enclosed "
-        "as ${...} and cannot contain braces"
-    )
-
-
-def _eval_cel(expression: str, context: dict[str, Any]) -> Any:
-    try:
-        from celpy import Environment
-        from celpy.adapter import CELJSONEncoder, json_to_cel
-        from celpy.evaluation import Context
-
-        environment = Environment()
-        program = environment.program(environment.compile(expression))
-        result = program.evaluate(cast(Context, json_to_cel(context)))
-        return json.loads(json.dumps(result, cls=CELJSONEncoder))
-    except Exception as e:
-        raise FlowExpressionError(
-            f"failed to evaluate CEL expression {expression!r}: {e}"
-        ) from e

lib/crewai/src/crewai/memory/unified_memory.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 from concurrent.futures import Future, ThreadPoolExecutor
+from contextlib import suppress
 import contextvars
+import copy
 from datetime import datetime
 import threading
 import time
@@ -53,6 +55,24 @@ def _default_embedder() -> OpenAIEmbeddingFunction:
     return build_embedder(spec)
 
 
+def _non_streaming_analysis_llm(llm: Any) -> Any:
+    """Return an isolated non-streaming LLM for internal memory analysis."""
+    if not isinstance(llm, BaseLLM):
+        return llm
+
+    try:
+        analysis_llm = copy.copy(llm)
+    except Exception:
+        try:
+            analysis_llm = llm.model_copy(deep=False)
+        except Exception:
+            return llm
+
+    with suppress(Exception):
+        analysis_llm.stream = False
+    return analysis_llm
+
+
 class Memory(BaseModel):
     """Unified memory: standalone, LLM-analyzed, with intelligent recall flow.
 
@@ -200,7 +220,9 @@ class Memory(BaseModel):
             query_analysis_threshold=self.query_analysis_threshold,
         )
 
-        self._llm_instance = None if isinstance(self.llm, str) else self.llm
+        self._llm_instance = (
+            None if isinstance(self.llm, str) else _non_streaming_analysis_llm(self.llm)
+        )
         self._embedder_instance = (
             self.embedder
             if (self.embedder is not None and not isinstance(self.embedder, dict))

lib/crewai/src/crewai/project/__init__.py

@@ -15,16 +15,22 @@ from crewai.project.annotations import (
 )
 from crewai.project.crew_base import CrewBase
 from crewai.project.crew_definition import (
+    AgentDefinition,
     CrewAgentDefinition,
     CrewDefinition,
     CrewTaskDefinition,
     PythonReferenceDefinition,
 )
 from crewai.project.crew_loader import load_crew, load_crew_and_kickoff
-from crewai.project.json_loader import load_agent, strip_jsonc_comments
+from crewai.project.json_loader import (
+    load_agent,
+    load_agent_from_definition,
+    strip_jsonc_comments,
+)
 
 
 __all__ = [
+    "AgentDefinition",
     "CrewAgentDefinition",
     "CrewBase",
     "CrewDefinition",
@@ -38,6 +44,7 @@ __all__ = [
     "crew",
     "llm",
     "load_agent",
+    "load_agent_from_definition",
     "load_crew",
     "load_crew_and_kickoff",
     "output_json",

lib/crewai/src/crewai/project/crew_definition.py

@@ -8,6 +8,7 @@ from pydantic import BaseModel, ConfigDict, Field, field_validator, model_valida
 
 
 __all__ = [
+    "AgentDefinition",
     "CrewAgentDefinition",
     "CrewDefinition",
     "CrewTaskDefinition",
@@ -53,6 +54,20 @@ class CrewAgentDefinition(BaseModel):
         return value or {}
 
 
+class AgentDefinition(CrewAgentDefinition):
+    """Inline agent definition used by a Flow agent action."""
+
+    input: str
+    response_format: PythonReferenceDefinition | None = None
+
+    @field_validator("input", mode="before")
+    @classmethod
+    def _validate_input(cls, value: Any) -> Any:
+        if not isinstance(value, str):
+            raise ValueError("agent.input must be a string")
+        return value
+
+
 class CrewTaskDefinition(BaseModel):
     """Task definition used by a crew definition."""
 

lib/crewai/src/crewai/project/json_loader.py

@@ -207,19 +207,18 @@ def load_jsonc_file(source: str | Path) -> Any:
     return parse_jsonc(path.read_text(encoding="utf-8"), source=path)
 
 
-def load_agent(source: str | Path) -> Any:
-    """Load an existing ``Agent`` from a ``.json`` / ``.jsonc`` definition file."""
-    path = Path(source)
-    defn = _expect_object(load_jsonc_file(path), path)
-    root = path.parent.parent if path.parent.name == "agents" else path.parent
+def _instantiate_agent_from_data(
+    defn: dict[str, Any], source_label: str, root: Path
+) -> Any:
+    """Resolve the agent class and kwargs from definition data and instantiate it."""
     agent_class = _agent_class_from_definition(
         defn,
-        f"{path}: type",
+        f"{source_label}: type",
         project_root=root,
     )
     agent_kwargs = _agent_kwargs_from_definition(
         defn,
-        path,
+        source_label,
         agent_class=agent_class,
         project_root=root,
     )
@@ -227,9 +226,50 @@ def load_agent(source: str | Path) -> Any:
     try:
         return agent_class(**agent_kwargs)
     except ValidationError as exc:
-        raise JSONProjectError(_format_validation_error(path, exc)) from exc
+        raise JSONProjectError(_format_validation_error(source_label, exc)) from exc
     except Exception as exc:
-        raise JSONProjectError(f"{path}: failed to load agent: {exc}") from exc
+        raise JSONProjectError(f"{source_label}: failed to load agent: {exc}") from exc
+
+
+def load_agent(source: str | Path) -> Any:
+    """Load an existing ``Agent`` from a ``.json`` / ``.jsonc`` definition file."""
+    path = Path(source)
+    defn = _expect_object(load_jsonc_file(path), path)
+    root = path.parent.parent if path.parent.name == "agents" else path.parent
+    return _instantiate_agent_from_data(defn, str(path), root)
+
+
+def load_agent_from_definition(
+    definition: dict[str, Any] | Any,
+    *,
+    source: str | Path = "<inline agent>",
+    project_root: str | Path | None = None,
+) -> tuple[Any, type[BaseModel] | None]:
+    """Load an ``Agent`` and optional kickoff response model from an inline definition."""
+    from crewai.project.crew_definition import AgentDefinition
+
+    root = Path(project_root) if project_root is not None else Path.cwd()
+    source_label = str(source)
+    agent_definition = (
+        definition
+        if isinstance(definition, AgentDefinition)
+        else AgentDefinition.model_validate(definition)
+    )
+    definition_data = agent_definition.model_dump(mode="python", exclude_none=True)
+    response_format_ref = definition_data.pop("response_format", None)
+    definition_data.pop("input", None)
+
+    agent = _instantiate_agent_from_data(definition_data, source_label, root)
+
+    response_format = None
+    if response_format_ref is not None:
+        response_format = _resolve_model_class(
+            response_format_ref,
+            f"{source_label}: response_format",
+            root,
+        )
+
+    return agent, response_format
 
 
 def validate_crew_project(

lib/crewai/tests/memory/test_unified_memory.py

@@ -19,6 +19,39 @@ from crewai.memory.types import (
 )
 
 
+def test_memory_analysis_llm_is_isolated_from_streaming_agent_llm(
+    tmp_path: Path,
+) -> None:
+    """Memory analysis should not share a mutable streaming LLM with the agent UI."""
+    from crewai.llms.base_llm import BaseLLM
+    from crewai.memory.unified_memory import Memory
+    from crewai.utilities.types import LLMMessage
+
+    class FakeStreamingLLM(BaseLLM):
+        def call(
+            self,
+            messages: str | list[LLMMessage],
+            tools: list[dict] | None = None,
+            callbacks: list | None = None,
+            available_functions: dict | None = None,
+            from_task: object | None = None,
+            from_agent: object | None = None,
+            response_model: type | None = None,
+        ) -> str:
+            return ""
+
+    agent_llm = FakeStreamingLLM(model="fake-model", stream=True)
+    mem = Memory(
+        storage=str(tmp_path / "db"),
+        llm=agent_llm,
+        embedder=lambda texts: [[0.1] for _ in texts],
+    )
+
+    assert mem._llm is not agent_llm
+    assert mem._llm.stream is False
+
+    agent_llm.stream = True
+    assert mem._llm.stream is False
 
 
 def test_memory_record_defaults() -> None:

lib/crewai/tests/project/test_json_loader.py

@@ -7,6 +7,7 @@ from pathlib import Path
 import sys
 
 import pytest
+from pydantic import BaseModel
 
 from crewai.llms.base_llm import BaseLLM
 from crewai.project.json_loader import (
@@ -14,6 +15,7 @@ from crewai.project.json_loader import (
     _looks_like_windows_absolute_path,
     find_json_project_file,
     load_agent,
+    load_agent_from_definition,
     strip_jsonc_comments,
 )
 
@@ -358,6 +360,30 @@ class TestLoadAgent:
             load_agent(Path("/nonexistent/agent.json"))
 
 
+class TestLoadAgentFromDefinition:
+    def test_resolves_response_format_from_project_module(self, tmp_path: Path):
+        (tmp_path / "models.py").write_text(
+            "from pydantic import BaseModel\n"
+            "class AnswerModel(BaseModel):\n"
+            "    answer: str\n"
+        )
+
+        _, response_format = load_agent_from_definition(
+            {
+                "role": "Analyst",
+                "goal": "Analyze data",
+                "backstory": "Data expert.",
+                "input": "Summarize this",
+                "response_format": {"python": "models.AnswerModel"},
+            },
+            source="agent action",
+            project_root=tmp_path,
+        )
+
+        assert issubclass(response_format, BaseModel)
+        assert response_format.__name__ == "AnswerModel"
+
+
 class TestResolveTools:
     def test_unknown_tool_raises_with_guidance(self):
         from crewai.project.json_loader import JSONProjectError, _resolve_tools

lib/crewai/tests/test_checkpoint.py

@@ -631,7 +631,7 @@ class TestLegacyMethodOutputsRestore:
         assert restored.method_outputs == ["first", "second"]
 
     def test_restore_legacy_outputs_evaluates_expressions(self) -> None:
-        from crewai.flow.runtime._expressions import _expression_context
+        from crewai.flow.expressions import Expression
 
         flow = Flow()
         flow._method_outputs = ["legacy"]
@@ -642,7 +642,7 @@ class TestLegacyMethodOutputsRestore:
             cfg = CheckpointConfig(restore_from=loc)
             restored = Flow.from_checkpoint(cfg)
 
-        context = _expression_context(restored)
+        context = Expression._flow_context(restored)
         assert context["outputs"] == {"": "legacy"}
 
     def test_raw_legacy_outputs_property_remains_readable(self) -> None:

lib/crewai/tests/test_flow_definition.py

@@ -37,6 +37,8 @@ def test_flow_public_exports_are_explicit():
     }
     assert set(flow_definition.__all__) == {
         "FlowActionDefinition",
+        "FlowAgentActionDefinition",
+        "FlowAtomicActionDefinition",
         "FlowCodeActionDefinition",
         "FlowConfigDefinition",
         "FlowConversationalDefinition",
@@ -46,7 +48,7 @@ def test_flow_public_exports_are_explicit():
         "FlowDefinitionCondition",
         "FlowDictStateDefinition",
         "FlowEachActionDefinition",
-        "FlowEachInnerActionDefinition",
+        "FlowEachStepDefinition",
         "FlowExpressionActionDefinition",
         "FlowHumanFeedbackDefinition",
         "FlowJsonSchemaStateDefinition",
@@ -79,6 +81,10 @@ def test_flow_definition_json_schema_carries_reference_descriptions():
     assert "not interpolated" in script_properties["code"]["description"]
     assert "not sandboxed" in script_properties["code"]["description"]
 
+    agent_properties = defs["FlowAgentActionDefinition"]["properties"]
+    assert "Inline Agent definition" in agent_properties["with"]["description"]
+    assert "run an inline Agent" in agent_properties["call"]["description"]
+
     state_schema = next(
         branch
         for branch in schema["properties"]["state"]["anyOf"]
@@ -107,7 +113,10 @@ def test_flow_definition_json_schema_carries_reference_descriptions():
 
     each_properties = defs["FlowEachActionDefinition"]["properties"]
     assert "list to iterate" in each_properties["in"]["description"]
-    assert "Ordered inner actions" in each_properties["do"]["description"]
+    assert "Ordered steps" in each_properties["do"]["description"]
+
+    step_properties = defs["FlowEachStepDefinition"]["properties"]
+    assert "runs only if" in step_properties["if"]["description"]
 
 
 def test_flow_definition_json_schema_carries_field_examples_only():
@@ -118,10 +127,12 @@ def test_flow_definition_json_schema_carries_field_examples_only():
         "FlowDefinition",
         "FlowCodeActionDefinition",
         "FlowToolActionDefinition",
+        "FlowAgentActionDefinition",
         "FlowCrewActionDefinition",
         "FlowExpressionActionDefinition",
         "FlowScriptActionDefinition",
         "FlowEachActionDefinition",
+        "FlowEachStepDefinition",
         "FlowMethodDefinition",
         "FlowDictStateDefinition",
         "FlowJsonSchemaStateDefinition",
@@ -152,9 +163,18 @@ def test_flow_definition_json_schema_carries_field_examples_only():
     ]
     assert action_properties["with"]["examples"] == [{"topic": "${state.topic}"}]
 
+    agent_properties = defs["FlowAgentActionDefinition"]["properties"]
+    assert agent_properties["call"]["examples"] == ["agent"]
+    assert agent_properties["with"]["examples"][0]["input"] == "${state.question}"
+
     each_properties = defs["FlowEachActionDefinition"]["properties"]
     assert each_properties["in"]["examples"] == ["state.rows"]
-    assert each_properties["do"]["examples"][0][0]["clean"]["call"] == "script"
+    assert each_properties["do"]["examples"][0][0]["name"] == "clean"
+    assert each_properties["do"]["examples"][0][0]["action"]["call"] == "script"
+    assert each_properties["do"]["examples"][0][1]["if"] == "outputs.clean != ''"
+
+    step_properties = defs["FlowEachStepDefinition"]["properties"]
+    assert step_properties["if"]["examples"] == ["item.kind == 'invoice'"]
 
     method_properties = defs["FlowMethodDefinition"]["properties"]
     assert method_properties["listen"]["examples"] == [
@@ -584,14 +604,16 @@ def test_each_action_round_trips_json_and_yaml():
                         "in": "state.rows",
                         "do": [
                             {
-                                "normalize": {
+                                "name": "normalize",
+                                "action": {
                                     "call": "tool",
                                     "ref": "my_tools:NormalizeRowTool",
                                     "with": {"row": "${ item }"},
                                 }
                             },
                             {
-                                "save": {
+                                "name": "save",
+                                "action": {
                                     "call": "code",
                                     "ref": "my_flow:save_row",
                                     "with": {

lib/crewai/tests/test_flow_from_definition.py

@@ -114,7 +114,7 @@ class EachActionFlow(Flow):
         except RuntimeError:
             pass
         else:
-            raise RuntimeError("inner action ran on the event loop")
+            raise RuntimeError("each step ran on the event loop")
 
         from crewai.flow.flow_context import current_flow_method_name
 
@@ -644,7 +644,7 @@ methods:
     assert flow.kickoff(inputs={"topic": "ai"}) == "found:ai agents"
 
 
-def test_tool_action_rejects_braces_in_embedded_cel_input():
+def test_tool_action_treats_embedded_cel_marker_as_literal():
     definition = FlowDefinition.from_dict(
         {
             "schema": "crewai.flow/v1",
@@ -660,16 +660,62 @@ def test_tool_action_rejects_braces_in_embedded_cel_input():
                             "prefix": "${'p}x'}",
                         },
                     },
-                }
+                },
             },
         }
     )
 
-    with pytest.raises(ValueError, match="cannot contain braces"):
-        Flow.from_definition(definition).kickoff()
+    assert Flow.from_definition(definition).kickoff() == "p}x:wrapped ${'a}b'} value"
 
 
-def test_tool_action_rejects_braces_in_full_cel_input():
+def test_tool_action_treats_marker_with_trailing_text_as_literal():
+    definition = FlowDefinition.from_dict(
+        {
+            "schema": "crewai.flow/v1",
+            "name": "ToolFlow",
+            "methods": {
+                "search": {
+                    "start": True,
+                    "do": {
+                        "call": "tool",
+                        "ref": f"{__name__}:StaticSearchTool",
+                        "with": {
+                            "search_query": "${state.topic} extra",
+                            "prefix": "p",
+                        },
+                    },
+                },
+            },
+        }
+    )
+
+    assert Flow.from_definition(definition).kickoff() == "p:${state.topic} extra"
+
+
+def test_tool_action_rejects_adjacent_markers_as_invalid_cel():
+    with pytest.raises(ValidationError, match="invalid CEL expression"):
+        FlowDefinition.from_dict(
+            {
+                "schema": "crewai.flow/v1",
+                "name": "ToolFlow",
+                "methods": {
+                    "search": {
+                        "start": True,
+                        "do": {
+                            "call": "tool",
+                            "ref": f"{__name__}:StaticSearchTool",
+                            "with": {
+                                "search_query": "${'a'}${'b'}",
+                                "prefix": "p",
+                            },
+                        },
+                    },
+                },
+            }
+        )
+
+
+def test_tool_action_accepts_braces_in_full_cel_marker():
     definition = FlowDefinition.from_dict(
         {
             "schema": "crewai.flow/v1",
@@ -682,16 +728,15 @@ def test_tool_action_rejects_braces_in_full_cel_input():
                         "ref": f"{__name__}:StaticSearchTool",
                         "with": {
                             "search_query": "${{'query': 'ai agents'}.query}",
-                            "prefix": "found",
+                            "prefix": "${'p}x'}",
                         },
                     },
-                }
+                },
             },
         }
     )
 
-    with pytest.raises(ValueError, match="cannot contain braces"):
-        Flow.from_definition(definition).kickoff()
+    assert Flow.from_definition(definition).kickoff() == "p}x:ai agents"
 
 
 def test_tool_action_renders_latest_output_by_method_name():
@@ -766,6 +811,166 @@ methods:
     )
 
 
+def test_agent_action_runs_inline_yaml_definition(monkeypatch: pytest.MonkeyPatch):
+    from crewai import Agent
+
+    async def fake_kickoff_async(
+        self: Agent, messages: str, **_kwargs: Any
+    ) -> dict[str, Any]:
+        return {"agent": self.role, "input": messages}
+
+    monkeypatch.setattr(Agent, "kickoff_async", fake_kickoff_async)
+
+    yaml_str = """
+schema: crewai.flow/v1
+name: AgentFlow
+methods:
+  answer:
+    do:
+      call: agent
+      with:
+        role: Analyst
+        goal: Answer questions
+        backstory: Knows things.
+        input: "${state.question}"
+    start: true
+"""
+
+    flow = Flow.from_definition(FlowDefinition.from_yaml(yaml_str))
+
+    assert flow.kickoff(inputs={"question": "What is CrewAI?"}) == {
+        "agent": "Analyst",
+        "input": "What is CrewAI?",
+    }
+
+
+def test_agent_action_runs_inside_each(monkeypatch: pytest.MonkeyPatch):
+    from crewai import Agent
+
+    async def fake_kickoff_async(
+        self: Agent, messages: str, **_kwargs: Any
+    ) -> str:
+        return f"{self.role}:{messages}"
+
+    monkeypatch.setattr(Agent, "kickoff_async", fake_kickoff_async)
+
+    yaml_str = """
+schema: crewai.flow/v1
+name: AgentEachFlow
+methods:
+  answer_each:
+    do:
+      call: each
+      in: state.questions
+      do:
+        - name: answer
+          action:
+            call: agent
+            with:
+              role: Analyst
+              goal: Answer questions
+              backstory: Knows things.
+              input: "${item}"
+    start: true
+"""
+
+    flow = Flow.from_definition(FlowDefinition.from_yaml(yaml_str))
+
+    assert flow.kickoff(inputs={"questions": ["one", "two"]}) == [
+        "Analyst:one",
+        "Analyst:two",
+    ]
+
+
+def test_agent_action_round_trips_with_inline_definition():
+    definition = FlowDefinition.from_dict(
+        {
+            "schema": "crewai.flow/v1",
+            "name": "AgentFlow",
+            "methods": {
+                "answer": {
+                    "start": True,
+                    "do": {
+                        "call": "agent",
+                        "with": {
+                            "role": "Analyst",
+                            "goal": "Answer questions",
+                            "backstory": "Knows things.",
+                            "settings": {"verbose": True},
+                            "input": "${state.question}",
+                        },
+                    },
+                }
+            },
+        }
+    )
+
+    round_trip = FlowDefinition.from_yaml(definition.to_yaml())
+    action = round_trip.to_dict()["methods"]["answer"]["do"]
+
+    assert action["call"] == "agent"
+    assert action["with"]["role"] == "Analyst"
+    assert action["with"]["input"] == "${state.question}"
+    assert action["with"]["settings"] == {"verbose": True}
+
+
+def test_agent_action_json_schema_describes_inline_agent_definitions():
+    schema_defs = FlowDefinition.json_schema()["$defs"]
+
+    assert set(schema_defs["AgentDefinition"]["properties"]) >= {
+        "role",
+        "goal",
+        "backstory",
+        "settings",
+        "input",
+        "response_format",
+    }
+
+
+def test_agent_action_rejects_non_string_input_in_definition():
+    with pytest.raises(ValidationError, match="agent.input must be a string"):
+        FlowDefinition.from_dict(
+            {
+                "schema": "crewai.flow/v1",
+                "name": "AgentFlow",
+                "methods": {
+                    "answer": {
+                        "start": True,
+                        "do": {
+                            "call": "agent",
+                            "with": {
+                                "role": "Analyst",
+                                "goal": "Answer questions",
+                                "backstory": "Knows things.",
+                                "input": 123,
+                            },
+                        },
+                    }
+                },
+            }
+        )
+
+
+def test_agent_action_reports_invalid_cel_expression():
+    yaml_str = """
+schema: crewai.flow/v1
+name: AgentFlow
+methods:
+  answer:
+    do:
+      call: agent
+      with:
+        role: Analyst
+        goal: Answer questions
+        backstory: Knows things.
+        input: "${state.}"
+    start: true
+"""
+
+    with pytest.raises(ValidationError, match="invalid CEL expression"):
+        FlowDefinition.from_yaml(yaml_str)
+
+
 def test_crew_action_runs_inline_yaml_definition(monkeypatch: pytest.MonkeyPatch):
     from crewai import Crew
 
@@ -1026,10 +1231,8 @@ methods:
     start: true
 """
 
-    flow = Flow.from_definition(FlowDefinition.from_yaml(yaml_str))
-
-    with pytest.raises(ValueError, match="failed to evaluate CEL expression"):
-        flow.kickoff()
+    with pytest.raises(ValidationError, match="invalid CEL expression"):
+        FlowDefinition.from_yaml(yaml_str)
 
 
 def test_code_action_renders_keyword_inputs():
@@ -1081,7 +1284,8 @@ methods:
       call: each
       in: state.rows
       do:
-        - normalize:
+        - name: normalize
+          action:
             call: code
             ref: {__name__}:EachActionFlow.normalize_row
             with:
@@ -1097,7 +1301,7 @@ methods:
     ]
 
 
-def test_each_action_runs_sync_inner_actions_off_event_loop_with_context():
+def test_each_action_runs_sync_steps_off_event_loop_with_context():
     yaml_str = f"""
 schema: crewai.flow/v1
 name: EachFlow
@@ -1107,7 +1311,8 @@ methods:
       call: each
       in: state.rows
       do:
-        - threaded:
+        - name: threaded
+          action:
             call: code
             ref: {__name__}:EachActionFlow.require_threaded_context
             with:
@@ -1123,7 +1328,7 @@ methods:
     assert flow.inner_thread_id != caller_thread_id
 
 
-def test_each_action_runs_async_tool_results_from_sync_inner_actions():
+def test_each_action_runs_async_tool_results_from_sync_steps():
     yaml_str = f"""
 schema: crewai.flow/v1
 name: EachFlow
@@ -1133,7 +1338,8 @@ methods:
       call: each
       in: state.rows
       do:
-        - async_tool:
+        - name: async_tool
+          action:
             call: tool
             ref: {__name__}:AsyncResultTool
             with:
@@ -1222,7 +1428,7 @@ methods:
     assert flow.state["input_matches_output"] is True
 
 
-def test_script_each_action_reads_item_and_inner_outputs(
+def test_script_each_action_reads_item_and_step_outputs(
     monkeypatch: pytest.MonkeyPatch,
 ):
     monkeypatch.setenv("CREWAI_ALLOW_FLOW_SCRIPT_EXECUTION", "1")
@@ -1241,11 +1447,13 @@ methods:
       call: each
       in: state.rows
       do:
-        - clean:
+        - name: clean
+          action:
             call: script
             code: |
               return item.strip()
-        - tag:
+        - name: tag
+          action:
             call: script
             code: |
               return f"{outputs['seed']}:{outputs['clean']}"
@@ -1257,7 +1465,7 @@ methods:
     assert flow.kickoff(inputs={"rows": [" a ", " b "]}) == ["global:a", "global:b"]
 
 
-def test_each_action_uses_iteration_outputs_between_nested_actions():
+def test_each_action_uses_iteration_outputs_between_steps():
     yaml_str = f"""
 schema: crewai.flow/v1
 name: EachFlow
@@ -1267,13 +1475,15 @@ methods:
       call: each
       in: state.rows
       do:
-        - normalize:
+        - name: normalize
+          action:
             call: code
             ref: {__name__}:EachActionFlow.normalize_row
             with:
               row: "${{item}}"
               prefix: saved
-        - save:
+        - name: save
+          action:
             call: code
             ref: {__name__}:EachActionFlow.save_row
             with:
@@ -1290,7 +1500,7 @@ methods:
     ]
 
 
-def test_each_action_resets_inner_outputs_between_iterations():
+def test_each_action_resets_step_outputs_between_iterations():
     yaml_str = """
 schema: crewai.flow/v1
 name: EachFlow
@@ -1300,10 +1510,12 @@ methods:
       call: each
       in: state.rows
       do:
-        - leak_check:
+        - name: leak_check
+          action:
             call: expression
             expr: "has(outputs.previous) ? outputs.previous : 'empty'"
-        - previous:
+        - name: previous
+          action:
             call: expression
             expr: item
     start: true
@@ -1317,7 +1529,7 @@ methods:
     ]
 
 
-def test_each_action_preserves_flow_outputs_and_prefers_inner_outputs():
+def test_each_action_preserves_flow_outputs_and_prefers_step_outputs():
     yaml_str = """
 schema: crewai.flow/v1
 name: EachFlow
@@ -1332,13 +1544,16 @@ methods:
       call: each
       in: state.rows
       do:
-        - before_shadow:
+        - name: before_shadow
+          action:
             call: expression
             expr: "outputs.seed + ':' + item"
-        - seed:
+        - name: seed
+          action:
             call: expression
             expr: "'local:' + item"
-        - after_shadow:
+        - name: after_shadow
+          action:
             call: expression
             expr: "outputs.seed"
     listen: seed
@@ -1356,6 +1571,130 @@ methods:
     ]
 
 
+def test_each_action_runs_simple_if_clauses():
+    yaml_str = """
+schema: crewai.flow/v1
+name: EachIfFlow
+methods:
+  process_rows:
+    do:
+      call: each
+      in: state.rows
+      do:
+        - name: kind
+          action:
+            call: expression
+            expr: item.kind
+        - name: kept
+          if: "outputs.kind == 'keep'"
+          action:
+            call: expression
+            expr: "'kept:' + item.value"
+        - name: skipped
+          if: "outputs.kind != 'keep'"
+          action:
+            call: expression
+            expr: "'skipped:' + item.value"
+    start: true
+"""
+
+    flow = Flow.from_definition(FlowDefinition.from_yaml(yaml_str))
+
+    assert flow.kickoff(
+        inputs={
+            "rows": [
+                {"kind": "keep", "value": "a"},
+                {"kind": "drop", "value": "b"},
+            ]
+        }
+    ) == ["kept:a", "skipped:b"]
+
+
+def test_each_action_accepts_expression_markers_in_explicit_cel_fields():
+    yaml_str = """
+schema: crewai.flow/v1
+name: EachIfFlow
+methods:
+  process_rows:
+    do:
+      call: each
+      in: "${state.rows}"
+      do:
+        - name: kind
+          action:
+            call: expression
+            expr: "${item.kind}"
+        - name: kept
+          if: "${outputs.kind == 'keep'}"
+          action:
+            call: expression
+            expr: "${item.value}"
+    start: true
+"""
+
+    flow = Flow.from_definition(FlowDefinition.from_yaml(yaml_str))
+
+    assert flow.kickoff(inputs={"rows": [{"kind": "keep", "value": "a"}]}) == ["a"]
+
+
+def test_each_action_skipped_if_keeps_previous_output():
+    yaml_str = """
+schema: crewai.flow/v1
+name: EachIfFlow
+methods:
+  process_rows:
+    do:
+      call: each
+      in: state.rows
+      do:
+        - name: original
+          action:
+            call: expression
+            expr: item.value
+        - name: maybe_included
+          if: item.include
+          action:
+            call: expression
+            expr: "'included:' + item.value"
+    start: true
+"""
+
+    flow = Flow.from_definition(FlowDefinition.from_yaml(yaml_str))
+
+    assert flow.kickoff(
+        inputs={
+            "rows": [
+                {"include": True, "value": "a"},
+                {"include": False, "value": "b"},
+            ]
+        }
+    ) == ["included:a", "b"]
+
+
+def test_each_action_if_condition_must_be_boolean():
+    yaml_str = """
+schema: crewai.flow/v1
+name: EachIfFlow
+methods:
+  process_rows:
+    do:
+      call: each
+      in: state.rows
+      do:
+        - name: value
+          if: item.value
+          action:
+            call: expression
+            expr: item.value
+    start: true
+"""
+
+    flow = Flow.from_definition(FlowDefinition.from_yaml(yaml_str))
+
+    with pytest.raises(ValueError, match="if expression must evaluate to a boolean"):
+        flow.kickoff(inputs={"rows": [{"value": "truthy"}]})
+
+
 def test_each_action_empty_list_returns_empty_and_listener_runs_once():
     yaml_str = f"""
 schema: crewai.flow/v1
@@ -1366,7 +1705,8 @@ methods:
       call: each
       in: state.rows
       do:
-        - normalize:
+        - name: normalize
+          action:
             call: code
             ref: {__name__}:EachActionFlow.normalize_row
             with:
@@ -1415,7 +1755,12 @@ def test_each_action_rejects_non_list_inputs(expr, inputs):
                     "do": {
                         "call": "each",
                         "in": expr,
-                        "do": [{"value": {"call": "expression", "expr": "item"}}],
+                        "do": [
+                            {
+                                "name": "value",
+                                "action": {"call": "expression", "expr": "item"},
+                            }
+                        ],
                     },
                 }
             },
@@ -1431,15 +1776,25 @@ def test_each_action_rejects_non_list_inputs(expr, inputs):
     "action_do",
     [
         [],
-        [{"first": {"call": "expression", "expr": "item"}, "second": {"call": "expression", "expr": "item"}}],
-        [{"1bad": {"call": "expression", "expr": "item"}}],
+        [{"value": {"call": "expression", "expr": "item"}}],
+        [{"name": "1bad", "action": {"call": "expression", "expr": "item"}}],
+        [{"name": "missing_action"}],
+        [{"action": {"call": "expression", "expr": "item"}}],
         [
-            {"same": {"call": "expression", "expr": "item"}},
-            {"same": {"call": "expression", "expr": "item"}},
+            {
+                "name": "value",
+                "if": "true",
+                "then": [],
+                "action": {"call": "expression", "expr": "item"},
+            }
+        ],
+        [
+            {"name": "same", "action": {"call": "expression", "expr": "item"}},
+            {"name": "same", "action": {"call": "expression", "expr": "item"}},
         ],
     ],
 )
-def test_each_action_validates_inner_action_shape(action_do):
+def test_each_action_validates_step_shape(action_do):
     with pytest.raises(ValidationError):
         FlowDefinition.from_dict(
             {
@@ -1459,6 +1814,26 @@ def test_each_action_validates_inner_action_shape(action_do):
         )
 
 
+def test_if_clauses_are_rejected_at_method_level():
+    with pytest.raises(ValidationError):
+        FlowDefinition.from_dict(
+            {
+                "schema": "crewai.flow/v1",
+                "name": "TopLevelIfFlow",
+                "methods": {
+                    "process": {
+                        "start": True,
+                        "do": {
+                            "call": "expression",
+                            "if": "true",
+                            "expr": "'ok'",
+                        },
+                    }
+                },
+            }
+        )
+
+
 def test_each_action_rejects_nested_each_actions():
     with pytest.raises(ValidationError):
         FlowDefinition.from_dict(
@@ -1473,12 +1848,14 @@ def test_each_action_rejects_nested_each_actions():
                             "in": "state.rows",
                             "do": [
                                 {
-                                    "nested": {
+                                    "name": "nested",
+                                    "action": {
                                         "call": "each",
                                         "in": "state.children",
                                         "do": [
                                             {
-                                                "child": {
+                                                "name": "child",
+                                                "action": {
                                                     "call": "expression",
                                                     "expr": "item",
                                                 }
@@ -1504,7 +1881,8 @@ methods:
       call: each
       in: state.rows
       do:
-        - validate:
+        - name: validate
+          action:
             call: code
             ref: {__name__}:EachActionFlow.fail_on_bad_row
             with:
@@ -1542,8 +1920,28 @@ def test_expression_action_round_trips():
     assert Flow.from_definition(definition).kickoff(inputs={"score": 90}) == "qualified"
 
 
+def test_explicit_cel_fields_accept_expression_markers():
+    definition = FlowDefinition.from_dict(
+        {
+            "schema": "crewai.flow/v1",
+            "name": "ExpressionFlow",
+            "methods": {
+                "classify": {
+                    "start": True,
+                    "do": {
+                        "call": "expression",
+                        "expr": "${state.score >= 80 ? 'qualified' : 'nurture'}",
+                    },
+                }
+            },
+        }
+    )
+
+    assert Flow.from_definition(definition).kickoff(inputs={"score": 90}) == "qualified"
+
+
 def test_expression_local_context_recurses_into_dataclass_values():
-    from crewai.flow.runtime._expressions import evaluate_expression
+    from crewai.flow.expressions import Expression
 
     class Payload(BaseModel):
         name: str
@@ -1553,15 +1951,37 @@ def test_expression_local_context_recurses_into_dataclass_values():
         payload: Payload
 
     assert (
-        evaluate_expression(
-            Flow(),
+        Expression.from_flow(
             "item.payload.name",
+            Flow(),
             local_context={"item": Row(payload=Payload(name="qualified"))},
-        )
+        ).evaluate()
         == "qualified"
     )
 
 
+def test_expression_empty_context_overrides_stored_context():
+    from crewai.flow.expressions import Expression, ExpressionError
+
+    expression = Expression("state.score", context={"state": {"score": 90}})
+
+    assert expression.evaluate() == 90
+    with pytest.raises(ExpressionError):
+        expression.evaluate({})
+
+
+def test_expression_template_empty_context_overrides_stored_context():
+    from crewai.flow.expressions import Expression, ExpressionError
+
+    expression = Expression(
+        {"score": "${state.score}"}, context={"state": {"score": 90}}
+    )
+
+    assert expression.render_template() == {"score": 90}
+    with pytest.raises(ExpressionError):
+        expression.render_template({})
+
+
 def test_expression_action_can_route_like_if_else():
     yaml_str = f"""
 schema: crewai.flow/v1
@@ -1613,10 +2033,24 @@ methods:
     start: true
 """
 
-    flow = Flow.from_definition(FlowDefinition.from_yaml(yaml_str))
+    with pytest.raises(ValidationError, match="invalid CEL expression"):
+        FlowDefinition.from_yaml(yaml_str)
 
-    with pytest.raises(ValueError, match="failed to evaluate CEL expression"):
-        flow.kickoff()
+
+def test_expression_action_rejects_unknown_cel_root():
+    yaml_str = """
+schema: crewai.flow/v1
+name: ExpressionFlow
+methods:
+  classify:
+    do:
+      call: expression
+      expr: "score >= 80"
+    start: true
+"""
+
+    with pytest.raises(ValidationError, match="unknown CEL root"):
+        FlowDefinition.from_yaml(yaml_str)
 
 
 def test_tool_action_requires_module_qualname_ref():

lib/devtools/src/crewai_devtools/__init__.py

@@ -1,3 +1,3 @@
 """CrewAI development tools."""
 
-__version__ = "1.14.8a"
+__version__ = "1.14.8a1"

pyproject.toml

@@ -171,6 +171,8 @@ info = "Commits must follow Conventional Commits 1.0.0."
 
 [tool.uv]
 exclude-newer = "3 days"
+# pypdf 6.13.3 is a security fix newer than the global supply-chain cutoff.
+exclude-newer-package = { pypdf = "2026-06-18T00:00:00Z" }
 
 # composio-core pins rich<14 but textual requires rich>=14.
 # onnxruntime 1.24+ dropped Python 3.10 wheels; cap it so qdrant[fastembed] resolves on 3.10.
@@ -180,7 +182,8 @@ exclude-newer = "3 days"
 # langchain-text-splitters <1.1.2 has GHSA-fv5p-p927-qmxr (SSRF bypass in split_text_from_url).
 # transformers 4.57.6 has CVE-2026-1839; force 5.4+ (docling 2.84 allows huggingface-hub>=1).
 # cryptography 46.0.6 has CVE-2026-39892; force 46.0.7+.
-# pypdf <6.10.2 has GHSA-4pxv-j86v-mhcw, GHSA-7gw9-cf7v-778f, GHSA-x284-j5p8-9c5p; force 6.10.2+.
+# pypdf <6.10.2 has GHSA-4pxv-j86v-mhcw, GHSA-7gw9-cf7v-778f, GHSA-x284-j5p8-9c5p.
+# pypdf <6.13.3 has GHSA-jm82-fx9c-mx94; force 6.13.3+.
 # uv <0.11.15 has GHSA-4gg8-gxpx-9rph (and earlier GHSA-pjjw-68hj-v9mw); force 0.11.15+.
 # python-multipart <0.0.27 has GHSA-pp6c-gr5w-3c5g (DoS via unbounded multipart headers).
 # gitpython <3.1.50 has GHSA-mv93-w799-cj2w (config_writer newline injection bypassing the 3.1.49 patch -> RCE via core.hooksPath).
@@ -205,7 +208,7 @@ override-dependencies = [
     "urllib3>=2.7.0",
     "transformers>=5.4.0; python_version >= '3.10'",
     "cryptography>=46.0.7",
-    "pypdf>=6.10.2,<7",
+    "pypdf>=6.13.3,<7",
     "uv>=0.11.15,<1",
     "python-multipart>=0.0.27,<1",
     "gitpython>=3.1.50,<4",

uv.lock

@@ -16,6 +16,9 @@ resolution-markers = [
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P3D"
 
+[options.exclude-newer-package]
+pypdf = "2026-06-18T00:00:00Z"
+
 [manifest]
 members = [
     "crewai",
@@ -40,7 +43,7 @@ overrides = [
     { name = "pillow", specifier = ">=12.1.1" },
     { name = "pip", specifier = ">=26.1.2" },
     { name = "pydantic-settings", specifier = ">=2.14.0" },
-    { name = "pypdf", specifier = ">=6.10.2,<7" },
+    { name = "pypdf", specifier = ">=6.13.3,<7" },
     { name = "python-multipart", specifier = ">=0.0.27,<1" },
     { name = "rich", specifier = ">=13.7.1" },
     { name = "starlette", specifier = ">=1.3.1" },
@@ -1584,7 +1587,7 @@ requires-dist = [
     { name = "aiofiles", specifier = "~=24.1.0" },
     { name = "av", specifier = "~=13.0.0" },
     { name = "pillow", specifier = "~=12.1.1" },
-    { name = "pypdf", specifier = "~=6.10.0" },
+    { name = "pypdf", specifier = "~=6.13.3" },
     { name = "python-magic", specifier = ">=0.4.27" },
     { name = "tinytag", specifier = "~=2.2.1" },
 ]
@@ -7188,14 +7191,14 @@ wheels = [
 
 [[package]]
 name = "pypdf"
-version = "6.13.1"
+version = "6.13.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/15/d9/9d12fa0d9660d03320725ff686c961b645a4218940a82296e1272d9e1ff0/pypdf-6.13.1.tar.gz", hash = "sha256:4841d8a4c1589e5833915dc0c7ddfacff80a2e0bcbeb5d1e681fecaa1674b03a", size = 6477811, upload-time = "2026-06-08T11:01:49.344Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/17/18/9947cc201af9ccf76720fd3347bf4f70eb882ce3fcf4cb05f7443e4cf871/pypdf-6.13.3.tar.gz", hash = "sha256:f3cb822769725f1bac658c406cfc9460399043f3750c2d3e4650e0a85eacabd7", size = 6484063, upload-time = "2026-06-17T15:22:00.898Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/dd/8f03e0a5788a5d1feb4550617c3e6db5e9099eaee248a3e482ddaeacbbb0/pypdf-6.13.1-py3-none-any.whl", hash = "sha256:e555e4ce3f561ef069307622f1374136ba964ca6ca24f24158701decaf83ed9b", size = 346259, upload-time = "2026-06-08T11:01:47.741Z" },
+    { url = "https://files.pythonhosted.org/packages/94/56/2967e621598987905fb8cdfadd8f8de6b5c68c9351f0523c4df8409f28f1/pypdf-6.13.3-py3-none-any.whl", hash = "sha256:c6e3f86afb625791510b02ad5480e94b63970bb957df75d44657c282ecc52224", size = 347288, upload-time = "2026-06-17T15:21:59.512Z" },
 ]
 
 [[package]]