diff --git a/.github/workflows/sync-model-catalog.yml b/.github/workflows/sync-model-catalog.yml
index e9e3b267c525..77c354ea4468 100644
--- a/.github/workflows/sync-model-catalog.yml
+++ b/.github/workflows/sync-model-catalog.yml
@@ -60,3 +60,14 @@ jobs:
         run: |
           STATUS=$(curl -s -o /dev/null -w "%{http_code}" "https://cdn.activepieces.com/ai/model-catalog.json?run=$GITHUB_RUN_ID" || true)
           [ "$STATUS" = "200" ] || { echo "Publish verification failed: HTTP $STATUS"; exit 1; }
+
+      - name: Notify Discord on failure
+        if: failure()
+        env:
+          WEBHOOK: ${{ secrets.DISCORD_ON_CALL_WEBHOOK }}
+          BRANCH: ${{ github.ref_name }}
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        run: |
+          jq -n --arg branch "$BRANCH" --arg url "$RUN_URL" \
+            '{content: "🚨 **Sync AI Model Catalog Workflow Failed** 🚨\n\n**Branch:** \($branch)\n**Action URL:** \($url)\n\nThe AI model catalog sync did not finish. Please check the logs for more details."}' \
+            | curl --fail --silent --show-error -H "Content-Type: application/json" -X POST -d @- "$WEBHOOK"
diff --git a/brain/knowledge/ai-intelligence/ai-agents.md b/brain/knowledge/ai-intelligence/ai-agents.md
index d4d06442fe81..8ac923d67ee0 100644
--- a/brain/knowledge/ai-intelligence/ai-agents.md
+++ b/brain/knowledge/ai-intelligence/ai-agents.md
@@ -15,9 +15,9 @@ A flow step type (the `run_agent` action of `@activepieces/piece-ai`) that runs
 | Door (`AgentRunSource`) | Model comes from | Stored as |
 |---|---|---|
 | `CHAT` | `conversation.modelName`, picked in the UI | tier id |
-| `AGENT` | `agent.draft.modelName`; no picker is shown while chatting (`ai-chat-box.tsx` hides it when `agentId` is set) | concrete id |
+| `AGENT` | `agent.draft.modelName`; no picker is shown while chatting (`ai-chat-box.tsx` hides it when `agentId` is set) | tier id on the managed provider; concrete id on an own key or a row saved before ENG-754 |
 | `AGENT_BUILDER` | `conversation.modelName` | tier id |
-| `FLOW_STEP` | `agent.published.modelName`, or the step's own `input.aiProviderModel.model` | concrete id |
+| `FLOW_STEP` | `agent.published.modelName`, or the step's own `input.aiProviderModel.model` | same as `AGENT` |
 
 Three things follow. `run_agent` has two modes: pointed at a saved agent (`agentId` set) the step sends no model and the agent row decides; inline, it sends `input.aiProviderModel.model`. An agent row carries two configs: agent-page chat reads `agent.draft`, a `run_agent` step reads `agent.published` (via `resolvePublishedAgent`), so the same agent can already run different models through different doors. The fast model crosses every door: `firstStepUsesFastModel` (`run-agent-turn.ts`) runs the first step of almost every turn on the fast tier, flow steps included, whatever the user picked. `execute-agent-run.ts` persists `config.tier.id` onto `conversation.modelName` when the job carried no `modelName`, so conversations already hold tier ids today (inline `run_agent`, eval runs, every `AGENT_BUILDER`), read back by `chat-tool-billing.ts` and `chat-analytics-sync.ts`. **A persisted tier id is not a pin.** `pinnedModelOf` (`rpc/rpc-shared.ts`) ignores `conversation.modelName` for a conversation with an agent: that value is the resolved default, and once the console removes that tier it would reach a catalogue-less own-key provider as a literal model id. A saved agent's run model is the agent's own half (draft for AGENT, published for FLOW_STEP); only an agentless inline step reads `conversation.modelName`, which is the step's configured model.
 
@@ -30,6 +30,9 @@ Three things follow. `run_agent` has two modes: pointed at a saved agent (`agent
 - **PredefinedInputsStructure** — per-field `AGENT_DECIDE` / `CHOOSE_YOURSELF` / `LEAVE_EMPTY` baked into the tool so the agent knows which inputs it controls.
 
 ### Gotchas
+
+- **A managed agent row or Run Agent step stores a tier id (`smart`) from ENG-754 on; nothing converts the rows saved before.** `AIModelSelector` (`web/src/features/agents/ai-model/`) lists the published flow tiers by id for the managed provider and never calls `/models` for it; a blank picker pre-fills the published `flow.defaultTierId` once the tiers query settles (it used to take the first tier, Fast), and `withDefaultModel` (`agent-service.ts`) seeds the same default tier id on create. Own-key providers still store concrete ids: `resolveNamedModelId` passes their name through verbatim, so a tier id there would reach the provider as a model name. An older row keeps its concrete id: it runs that model (slash rule), shows the raw id in the picker, and does not follow a re-point until the ENG-753 migration.
+- **A flow-surface run takes its thinking budget from the tier it names, not the default tier.** `resolveRunTier` (`agent-model-resolution.ts`) builds `config.tier` for FLOW_STEP and AGENT runs: a managed tier id gives that tier's `thinkingBudget`, `id` and `modelId`; a concrete id, an own-key model, a tier the file dropped, or no model at all gives the flow default, as every flow-surface run did before ENG-754. So a Heavy agent thinks at Heavy's budget and reports `premium` in `chat.tier`, while a Heavy row saved as `anthropic/claude-opus-4.8` still thinks at Expert's until it is migrated.
 - **A chat turn's data lives in jsonb, so recording something per turn needs no migration.** `agent_conversation.messages` is a `jsonb` column and each entry is a `PersistedAgentMessageSchema`, which already carries optional per-turn fields (`thinkingDurationMs`, `feedback`). Adding another optional one is a zod field plus a `@activepieces/shared` patch bump — no column, no migration, no rollback flag. The conversation row itself only has `modelName`, which is why "record it on the conversation" is usually the wrong instinct: a user can switch tier mid-conversation, so anything that describes one turn belongs on the message, not the row.
 - **But the server does not build those messages, so "no migration" does not mean "cheap".** `messages` arrives already assembled from the worker over RPC (`saveAgentMessages` in `rpc/conversation-rpc.ts`), and the server only persists it and bills off it. Putting a new per-turn field on a message therefore means changing the RPC request schema and the worker that fills it, not editing a server file. Costing this off the jsonb shape alone gave an estimate of about an hour for work that is really a change to the engine contract. Check who authors the object before you price a change to it.
 
@@ -72,7 +75,7 @@ Three things follow. `run_agent` has two modes: pointed at a saved agent (`agent
   - **The curated list is a guess about capability, so the code learns.** A rejection calls `noteReasoningIsMandatory`, which records the id **only if it is curated** so a caller-supplied model id cannot grow the set, and the existing one-shot `shouldRetryStream` re-issues the turn with a minimal budget. `gemini-3.7-flash` is curated *and* reasoning-native, which is exactly the case the list alone would miss.
   - **`satisfies` against the vendor's own reasoning type is near-worthless here.** `{ effort: 'none' }`, `{ enabled: false, max_tokens: n }` and `{ enabled: false, effort: 'minimal' }` all satisfy it, because the vendor supports disabling and it is the *endpoints* that do not. The guard has to be a closed union of the three directives we actually send.
 
-- **A tool's *property keys* are user text too, and nothing guards them.** `mcpToolNameUtils` covers the tool NAME; the input schema's keys come straight from `property.name`, the field labels a customer typed into the MCP trigger, at `agent-run-controller.ts` (`resolveFlowTools`) and `mcp-server-builder.ts` (`registerFlowTools`), which build the shape identically. A field called `Email Sender` produces a key with a space, which Anthropic rejects on the same `^[a-zA-Z0-9_.-]{1,64}$` rule it applies to names, so that flow-as-tool step can never succeed. Sanitising is only half a fix: the payload is handed to the flow as its trigger body, so `{{trigger['Email Sender']}}` in existing flows needs a key→label map to translate back. Fix it in one shared helper, because the MCP server ships the same invalid schema to any Anthropic-backed client.
+- **A tool's *property keys* are user text too, so they go through `mcp-tool-input.ts`.** Field labels a customer typed into the MCP trigger (`Email Sender`) are not valid schema keys on Anthropic. `modelKeyByPropertyName` sanitizes them with `mcpToolNameUtils.toProviderSafeIdentifier`, keeping them unique, with a positional fallback and a length cap. `toFlowPayload` maps the model's args back to the original labels, so `{{trigger['Email Sender']}}` keeps working. The MCP server and agent flow tools both use it; build any new flow-as-tool schema through it.
 
 - **Do not raise `ai` past 7.0.69 — from `ai@7.0.70` the SDK stops auto-executing tools, and it fails silently.** Bisected on 2026-09-21 while trying to reach `experimental_evaluate`. On 7.0.44 (what the repo pins) and every version through 7.0.69, a tool call executes normally. From **7.0.70** onward, including 7.0.103–7.0.107, `generateText`/`streamText` still *recognise* the call — `staticToolCalls=1`, a `tool-call` part is emitted with correctly parsed input — but `execute` is never invoked and `toolResults` stays `0`. No error, no warning. The changelog entry for 7.0.70 is `a828527: Prevent automatic tool execution when a model call ends with an unsafe finish reason`, but the gate fires for every `finishReason` tried, `tool-calls` and `stop` included. Reproduced in a clean project outside the monorepo, on both `MockLanguageModelV3` and `MockLanguageModelV4`, on zod 3 and zod 4; `needsApproval: false` and `toolApproval: () => false` do not restore it, and neither does emitting the full `tool-input-start`/`delta`/`end` lifecycle before the `tool-call`. The alarm is `packages/server/worker/test/lib/agent-eval/agent-tool-call-repair.test.ts` — 4 of its 5 tests go red, and they look like a *repair* regression, which is the wrong trail: a plain valid tool call does not execute either. **Consequence: `experimental_evaluate` (first shipped in 7.0.103) cannot be reached without breaking the agent**, so anything needing typed evaluation calls the gateway's `/v4/ai/evaluation-model` endpoint over `safeHttp` instead of taking the bump. Re-test the table above before any future `ai` upgrade; if a release fixes it, that is the one to jump to.
 
diff --git a/brain/knowledge/ai-intelligence/ai-providers.md b/brain/knowledge/ai-intelligence/ai-providers.md
index 3693e5633703..167ec72035fa 100644
--- a/brain/knowledge/ai-intelligence/ai-providers.md
+++ b/brain/knowledge/ai-intelligence/ai-providers.md
@@ -78,7 +78,7 @@ after a file without chat keys it seeds the chat list from the live flow list.
 - **The pricing console shows bundled constants when no file is published, and says nothing.** `overview()` in `ai-pricing-service.ts` has three states, and two of them render the same numbers: **absent** (`NoSuchKey`) silently seeds the editor from `DEFAULT_PRICING_DRAFT`, the console's own checked-in copy of the tiers and weights, while **unreadable** (any other S3 error) shows those same constants *plus* a banner and blocks publishing. Only **present** is live data. So a screen full of plausible tiers is not evidence that anything was ever published — `curl -I https://cdn.activepieces.com/ai/pricing.json` is. The absent state is deliberate, it is how the first publish bootstraps, but it means "I can see the tiers" and "the prices are live" are unrelated facts. Worse, **absent and misconfigured are the same state**: `cdnClient.getJson` catches `NoSuchKey` and returns `undefined`, so a wrong bucket or an endpoint with the bucket in its path reads as "nothing published yet" and hides behind the defaults. The tell is the History tab — `list` does *not* catch `NoSuchKey`, so the same misconfiguration that reads as empty on the pricing page returns a 500 there. A 500 on history with a normal-looking pricing page means the S3 addressing is wrong, not that the history is empty.
 - **Deleting the live tier file is safe for customers and confusing for everyone else.** `ai/pricing.json` was deleted on 2026-09-24 to drop a leftover test tier, and Activepieces kept serving the right tiers throughout: the 404 makes `fetchTiers` throw, the failure is logged and backed off, and `current()` keeps serving the last good copy the process fetched; only a process that never fetched one, a fresh boot during the outage, runs the `ACTIVEPIECES_CHAT_TIERS` shipped with the release. Two things do change. Each server logs 'Failed to refresh the AI model tiers file' (or 'Failed to load…' on a process that never got a copy) on every failed attempt, and attempts happen at boot and whenever `current()` is called with a stale or missing copy, at most once per five minutes (`FAILURE_BACKOFF_MS`), so a permanent 404 is retried the same way as a blip. And the console reads the missing key as **absent**, so the next publish starts again at `version: 1` while the `ai/pricing/history/` objects from the old numbering are still there — the version number is `live.version + 1`, not a counter, so it is only meaningful between two publishes that never lost the live key. To remove one bad tier, edit and publish; do not delete the object.
 - **`CDN_S3_*` and `AP_S3_*` are two different buckets on two different providers, and mixing them puts public objects in customer data.** `cdn.activepieces.com` is a **DigitalOcean Spaces** bucket, `activepieces-cdn` in `fra1`, fronted by Cloudflare — a 200 from it carries `x-rgw-object-type` and `x-do-cdn-uuid`, which is how you tell. That is where `ai/model-catalog.json`, `ai/pricing.json` and `sdk/embed/*.js` live, and the credentials are the `CDN_S3_*` GitHub secrets. `AP_S3_BUCKET` is something else entirely: the **Cloudflare R2** file-storage bucket (`ap-files-prod` in production) holding run logs, step checkpoints, webhook payloads and flow bundles. The names are similar enough that the pricing console was once configured with the R2 file-storage key by mistake, which would have written a `public-read` `ai/pricing.json` into the customer-data bucket while `cdn.activepieces.com` stayed 404. When wiring anything that publishes to the CDN, confirm the endpoint is the Spaces region origin (`https://fra1.digitaloceanspaces.com`, never with the bucket in the path — the SDK appends `Bucket` itself and the doubled path returns `NoSuchKey` on every call).
-- **The weekly sync workflow can fail and nobody is told.** `sync-model-catalog.yml` has no alert on failure, and the only signal that it broke is a 404 on the object, which every reader swallows. Its run on 2026-08-31 failed with `InvalidAccessKeyId` — the `CDN_S3_ACCESS_KEY_ID` secret in this repo does not match a live key — so `ai/model-catalog.json` has never actually landed. Check `gh run list --workflow=sync-model-catalog.yml` before believing the CDN is the problem. **That same `CDN_S3_*` credential also publishes the AI tier file `ai/pricing.json` from `ap-analytics`** (decision [000039](../decisions/000041-ai-model-tiers-are-published-to-the-cdn-from-a-second-console.md)), so one dead key silently breaks model metadata *and* the published tiers at once: the console hides model costs (`model-catalog-service.ts` logs 'model prices will be hidden' and returns an empty list) while Activepieces keeps serving the tiers bundled in the release. Two features, one credential, no alarm on either.
+- **The weekly sync workflow now pages Discord on failure, but the alert needs `DISCORD_ON_CALL_WEBHOOK` in this repo.** `sync-model-catalog.yml` ends with the same `if: failure()` step as `release-pieces.yml`. Before that it had no alert, and the only signal that it broke is a 404 on the object, which every reader swallows. Its run on 2026-08-31 failed with `InvalidAccessKeyId` — the `CDN_S3_ACCESS_KEY_ID` secret in this repo does not match a live key — so `ai/model-catalog.json` has never actually landed. Check `gh run list --workflow=sync-model-catalog.yml` before believing the CDN is the problem. **That same `CDN_S3_*` credential also publishes the AI tier file `ai/pricing.json` from `ap-analytics`** (decision [000039](../decisions/000041-ai-model-tiers-are-published-to-the-cdn-from-a-second-console.md)), so one dead key silently breaks model metadata *and* the published tiers at once: the console hides model costs (`model-catalog-service.ts` logs 'model prices will be hidden' and returns an empty list) while Activepieces keeps serving the tiers bundled in the release. Two features, one credential, no alarm on either.
 - **A fresh Cloud platform cannot connect any AI provider, and the UI says nothing about why.** The admin page at `/platform/ai` sets `allowWrite = platform.plan.aiProvidersEnabled`, and that column defaults to **false** on the `free` plan (migration `1776…AddDefaultToAiProvidersEnabled`), so the connect button is simply absent rather than disabled-with-a-reason. On Cloud the flag is owned by Autumn (`autumn-utils.ts` lists it among the synced features), so there is nothing to configure locally and no `DEV_ENTERPRISE_PLAN` escape hatch on main. For local Cloud testing, flip it directly: `UPDATE platform_plan SET "aiProvidersEnabled" = true`. Then connect a **BYO key**, not the managed `ACTIVEPIECES` provider — per *Provider visibility* above, the managed row is hidden whenever `OPENROUTER_PROVISION_KEY` is unset, which is the normal local state, and a hidden provider makes `getChatProvider()` return null. Anything gated on a chat provider (chat itself, personalization research) stays silently disabled until a BYO row exists.
 - **Since the AI steps moved to the worker, the server sees every step's model id, and `ai-execute-controller` is the one place to act on it.** The piece POSTs `/v1/ai/execute` with `provider` and `modelId`, the controller builds the `EXECUTE_AI` job from that body, and the worker runs whatever model id the job carries. So anything that needs to rewrite or validate the model a flow step is about to use belongs there, not in the piece — one server-side edit covers all five AI steps, and an old pinned piece bundle keeps working because it only forwards the string it stored. This is what makes storing a tier id in a step cheap: the bundle never has to understand it. Note the agent step does **not** come through here — it resolves separately over `getAgentConfig`, in `agent-config-rpc`. Two conditions sit under that. **An old bundle only forwards the string from `0.11.0` up** — `AI_PIECE_COST_BILLING_VERSION`, the first version whose `ai-step.ts` POSTs `v1/ai/execute`. A step pinned below it runs the pre-worker code that calls the provider from the sandbox, so a tier id there would reach OpenRouter as the literal string. That case is already closed: `migrate-v26-ai-piece-cost-billing` bumps every saved `piece-ai` step below `0.11.0` up to it, which is why a later migration can rewrite what a step stores without touching `pieceVersion` for the runtime. **And resolve on the API, never in the worker**: `ExecuteAiRequest.modelId` is a bare `z.string()` so a tier id passes validation, `getEffectiveProviderAndModel` and `aiUtils.buildWebSearchToolsOrThrow` both read `data.modelId` as a real model, and the `resolveAiProvider` RPC does not carry the model at all, so using it as the seam would mean widening the worker contract.
 - **Managed billing can only price an OpenRouter call, and a call it cannot price is simply not billed.** `openRouterCostOf` (`server/utils/activepieces-ai-cost.ts`) reads `providerMetadata['openrouter'].usage.cost`, with one fallback that GETs `openrouter.ai/api/v1/generation?id=` and takes `total_cost`. If neither answers, `createBillingInfo` returns `undefined` and the turn is never reported — it runs, the customer keeps the output, and nothing is charged. Nothing logs "unbilled". This is what actually welds the managed provider to OpenRouter, more than the client does: `create-language-model.ts` shares one branch for `OPENROUTER` and `ACTIVEPIECES`, every tier `modelId` is an OpenRouter id, and `openrouter-api.ts` mints the per-platform key from `OPENROUTER_PROVISION_KEY`. So putting managed credits on any other gateway needs a second cost extractor and a second generation lookup **first**, or every call through it bills zero. For reference, no Vercel AI Gateway code exists here at all — the only gateway in the repo is Cloudflare's (`CLOUDFLARE_GATEWAY`, the `ai-gateway-provider` package), and `@ai-sdk/gateway` appears only as a transitive dep of `ai` that nothing imports. A BYOK user can already reach Vercel's gateway today through `AIProviderName.CUSTOM`, which takes a base URL plus hand-typed model ids.
@@ -216,3 +216,4 @@ after a file without chat keys it seeds the chat list from the live flow list.
 Paths verified 2026-07-26.
 - **`OPENROUTER_PROVISION_KEY` is a management key and cannot make inference calls; only the per-platform keys it mints can.** OpenRouter states it outright: management keys are for creating, listing, updating and deleting other keys and are rejected by every completion or decisions endpoint. So "we already have an OpenRouter key" is true for provisioning and false for anything that needs to call a model at the instance level (the AI Router's Jev call, for example): that needs an ordinary inference key from the same account, created in the dashboard or via the same `POST /keys` the instance already uses, with a credit `limit`. The AI Router does exactly that since 2026-09-23: it runs on the platform's managed key where credits are on, else the admin's own OpenRouter row, as a worker `EXECUTE_AI` job billed like any AI step.
 - **`z.enum(SomeTsEnum).exclude([SomeTsEnum.MEMBER])` compiles and excludes nothing at the type level; pass the key string, `.exclude(['MEMBER'])`.** zod's `exclude` is typed over `keyof T` and returns `ZodEnum<Omit<T, U[number]>>`. A TS enum member is its own literal type, not the string `'MEMBER'`, so `Omit` finds no key to drop and the inferred value type keeps every member, while the runtime check does exclude it. The symptom is one step removed from the cause: a switch over the parsed field is suddenly non-exhaustive (`switch-exhaustiveness-check` in lint, `TS2366` in the build) even though the branch you removed can never arrive. `/v1/ai/execute` hit this when `ROUTE` was carved out of `AiStepAction` for #15707. Neither vitest nor a package-local eslint run without type information reports it; only the build does.
+- **The managed Activepieces row can never restrict its models, so a finding that the managed picker offers a model the key forbids is not reachable.** The row is inserted with `modelScope: 'all', modelIds: []`, `create()` refuses `provider === ACTIVEPIECES` (`aiProvider.activepiecesIsManaged`), and `update()` handles only `enabledForChat` for it and returns before any scope field is read (`ai-provider-service.ts`). Every published tier therefore runs on it, and any `modelScope` filtering on the managed path is inert. Reviewers (Greptile on #15871) raise this as a P1; answer with these three facts rather than adding a filter.
diff --git a/brain/knowledge/decisions/000032-an-agent-is-a-project-scoped-row-that-flow-steps-reference-live.md b/brain/knowledge/decisions/000032-an-agent-is-a-project-scoped-row-that-flow-steps-reference-live.md
index 31aba2f8cd27..2d1a011bab16 100644
--- a/brain/knowledge/decisions/000032-an-agent-is-a-project-scoped-row-that-flow-steps-reference-live.md
+++ b/brain/knowledge/decisions/000032-an-agent-is-a-project-scoped-row-that-flow-steps-reference-live.md
@@ -34,7 +34,8 @@ rejected alternative was exactly that: dropdown prefills the step, link then gon
   "allow unattended writes" flag, not re-litigating the reference.
 - **Moving a flow between projects breaks the link** — the id is project-local, and git sync carries
   connections but not agents. Hence `externalId` on the row from day one; project state must upsert
-  agents by `(projectId, externalId)`, and until it does the import must fail loudly.
+  agents by `(projectId, externalId)`, and until it does the import must fail loudly. Publish already refuses a
+  missing agent (`assertAgentsResolveInProject`), but release and replace drop `republishFlow`'s error today.
 - Two orphaned tables (`agent`, `agent_run`) from the 2025 module are dropped so the entity can take
   the obvious name. `breaking = true` for rollback safety, no `⛓️‍💥 breaking-change` label.
 - **Autonomy stays a flow** — "Run on a schedule" scaffolds a real flow with a linked step, so there is
diff --git a/brain/knowledge/engineering/ci-pr-review-hygiene.md b/brain/knowledge/engineering/ci-pr-review-hygiene.md
index 44c1c6ddc11c..c89783fbb7e6 100644
--- a/brain/knowledge/engineering/ci-pr-review-hygiene.md
+++ b/brain/knowledge/engineering/ci-pr-review-hygiene.md
@@ -85,7 +85,8 @@ Enforcement is the **`Codeowners review` repository ruleset** (active on the def
 - **Docs videos belong on `cdn.activepieces.com/videos/docs/`, never in the repo — and `docs/resources/` is the legacy path that suggests otherwise.** Every `<video>` already in the wiki points at that CDN prefix, but `docs/resources/` still holds ~43 MB of in-repo gifs from before the convention, so the tree itself gives mixed signals and a contributor reasonably copies the wrong one. [#15399](https://github.com/activepieces/activepieces/pull/15399) added a fresh `docs/videos/` folder with 155 MB of `.mp4` against an 880 MB `.git`, including one byte-identical duplicate. Nothing in CI catches it: `PR size` exempts unmatched areas and counts lines, not bytes, and a binary blob contributes zero lines. Review the *file list* of a docs PR, not just its diff. Once such a branch is pushed the blobs are already on the remote — dropping them at the tip only keeps them out of `main` if the PR is **squash**-merged and the branch deleted, so a merge commit ships them permanently. Because the blobs stay reachable until the branch is deleted, nobody has to re-request the assets from whoever recorded them — pull them straight back out of history with `git archive <commit> docs/videos | tar -x --strip-components=2 -C <dir>`, picking the commit *before* the removal, which is also how you get them under the post-rename filenames the pages already reference.
 - **Mintlify-editor PRs arrive with `untitled-page*.mdx` at the docs root and `(1)`/`(2)`-suffixed media, wired into `docs.json` under those names.** The bot commits whatever the web editor autosaved, so pages land as `docs/untitled-page-5.mdx` rather than in the folder their nav group implies, and re-uploaded assets keep the browser's download-collision suffix (`data-flow-(1).mp4`, `01---insert-panel-(1.2x).mp4`). Mintlify's own link check passes — the names are internally consistent — so nothing flags it. Rename the files, fix the `docs.json` entries, then diff the *flattened nav tree* against `main` rather than reading the raw JSON diff: the editor also reindents, which buried a real change (the Enterprise Control `Security` group demoted to a child of `Guides`) inside 242 lines of whitespace churn on that PR.
 - **After rewriting a lower branch of a stack, the `--onto` upstream you need is that branch's *old* tip, and `<branch>@{1}` is where to read it.** Every commit above a rewritten branch has to be replayed with `git rebase --onto <new lower tip> <old lower tip> <upper>`, and the old tip stops being reachable by name the moment the rebase finishes. Guessing a SHA from an earlier terminal scroll either fails outright with `invalid upstream` or, worse, succeeds against the wrong base and replays a handful of commits instead of all of them, which surfaces as a pile of conflicts the branch has with itself. `git rev-parse <branch>@{1}` reads it from the reflog every time. Re-run the whole `--onto` chain top-down after any lower-branch amend, and confirm afterwards that `git log --format=%s main..<top>` has no duplicate subjects.
-- **When a stacked PR's parent is squash-merged, merge `main` into the child and retarget; do not rebase.** The parent's commits are on `main` by content but not by SHA, so `git merge origin/main` on the child sees both sides make the same change and auto-merges it; only the lines the child *rewrote* from the parent conflict, plus anything `main` changed in the same functions since (PR 2 of the model tiers work, #15825: three brain and docs pages where PR 2 had rewritten PR 1's sentences, and `agent-helpers.ts` where main's `resolveImageModelId` landed next to the surface-threaded fast-model helper). No history rewrite, a normal push, and the PR above it keeps its base untouched; a `--onto` rebase would replay every commit up the stack and force-push each. After the retarget, the PR's Commits tab still lists the parent's original SHAs (they reached `main` only as a squash) while Files changed shows only the child's files; the second view is the one that matters, so do not "fix" the first. Two traps in the resolution. `git checkout --ours <file>` on a conflicted file takes the *whole* file from your side and silently discards main's auto-merged hunks in it, so resolve hunk by hunk and check `git diff origin/main -- <file>` afterwards shows only your lines. And `tsc` against the merged tree resolves `@activepieces/shared` through the built dist, which still holds the pre-merge exports: three phantom "has no exported member" errors vanished after `npx turbo run build --filter=@activepieces/server-utils`. Rebuild the core libs before believing a typecheck, then run the child's own tests. A child branched off an *older* head of its parent (the parent took review fixes after the child was cut) also conflicts in files the child never touched: those are the parent's early copy against its final one on `main`. If `git log <old parent head>..HEAD -- <file>` lists none of the child's commits, `git checkout --theirs <file>` is the right answer there, because the whole file is main's (PR 4 of the model tiers work, #15866: `use-chat.ts`, `core/execution/package.json` and an agent test).
+- **When a stacked PR's parent is squash-merged, merge `main` into the child and retarget; do not rebase.** The parent's commits are on `main` by content but not by SHA, so `git merge origin/main` on the child sees both sides make the same change and auto-merges it; only the lines the child *rewrote* from the parent conflict, plus anything `main` changed in the same functions since (PR 2 of the model tiers work, #15825: three brain and docs pages where PR 2 had rewritten PR 1's sentences, and `agent-helpers.ts` where main's `resolveImageModelId` landed next to the surface-threaded fast-model helper). No history rewrite, a normal push, and the PR above it keeps its base untouched; a `--onto` rebase would replay every commit up the stack and force-push each. After the retarget, the PR's Commits tab still lists the parent's original SHAs (they reached `main` only as a squash) while Files changed shows only the child's files; the second view is the one that matters, so do not "fix" the first. Two traps in the resolution. `git checkout --ours <file>` on a conflicted file takes the *whole* file from your side and silently discards main's auto-merged hunks in it, so resolve hunk by hunk and check `git diff origin/main -- <file>` afterwards shows only your lines. And `tsc` against the merged tree resolves `@activepieces/shared` through the built dist, which still holds the pre-merge exports: three phantom "has no exported member" errors vanished after `npx turbo run build --filter=@activepieces/server-utils`. Rebuild the core libs before believing a typecheck, then run the child's own tests. A child branched off an *older* head of its parent (the parent took review fixes after the child was cut) also conflicts in files the child never touched: those are the parent's early copy against its final one on `main`. If `git log <old parent head>..HEAD -- <file>` lists none of the child's commits, `git checkout --theirs <file>` is the right answer there, because the whole file is main's (PR 4 of the model tiers work, #15866: `use-chat.ts`, `core/execution/package.json` and an agent test). For a file the child *did* change, take main's copy and replay only the child's own commit on top: `git checkout --theirs <files> && git add <files> && git show <child commit> -- <files> | git apply --3way` (it needs the files staged, and in zsh pass the list as an array, since a plain variable is not word-split); only hunks where main moved the child's own lines are left to resolve by hand (PR 5, #15871: six files, one hunk).
+- **Retargeting a PR's base never starts CI, and a push made while the old base conflicts may not start it either.** `ci.yml` listens only to `pull_request` opened, synchronize and reopened; `gh pr edit --base` fires `edited`, which starts nothing. On #15866 the catch-up merge was pushed while the PR still targeted its squash-merged parent's branch, the main CI never ran on that head, and the retarget did not trigger it, so the PR showed only the small checks (title, breaking change, Greptile) and looked green. After a retarget, check `gh pr checks <n>` lists `build-test` and the `api` jobs; if not, push again (an empty `ci:` commit is enough). Never `gh run rerun`: it replays the old event.
 - **Never commit a shared file onto a lower branch of a stack by copying it in from the stack top — you drag the upper branches' edits down with it.** Adding one gotcha bullet to a brain page while sitting on the top branch, then `git checkout <stash-or-top> -- <file>` after switching to the base branch, brings the *whole* file across, so every bullet the upper branches added to that page is silently duplicated onto the base. The commit stat is the tell: a one-line edit that reports six insertions is not a one-line edit. Switch branches first, re-apply the edit against **that branch's own copy** of the file, and re-check the stat before committing.
 - **Cherry-picking a merged PR onto a release branch: the commit-msg hook rejects it, and `breaking-changes.mdx` conflicts pull in other people's entries.** GitHub writes the squash header server-side, so `fix(flows): … instead of reverting them (#14899)` never faced commitlint — replaying it locally trips the 100-character header limit and `git cherry-pick --continue` dies in husky with the working tree half-applied. Finish it with `git commit --no-verify -C <original-sha>` rather than rewording, so the release branch keeps the same subject as `main`. The `Unreleased` section of `docs/install/reference/breaking-changes.mdx` conflicts on almost every pick because it accumulates entries from unrelated `main` work: take only the section your own commit added. **Take it by its own heading, not by "everything after the marker" — the incoming side of that hunk usually runs on into `main`'s copy of an already-published `## X.Y.Z` section, and pasting the tail duplicates ~200 lines of published notes that no test, lint or typecheck will ever notice.** The reliable move is to rebuild the file: `git checkout origin/release/<version> -- docs/install/reference/breaking-changes.mdx`, then insert your entry under its own `## <new version>` heading above the previous release's, and confirm with `git diff --stat` that only your lines are added and `grep -c '^## '` that no version heading appears twice. Then run `bun install` before pushing — the release branch's `bun.lock` is usually stale against its own `package.json`s, and the pick drags those stale piece versions along until install corrects them; `git diff --stat origin/release/<version> -- bun.lock` should come back as just the packages your pick actually bumped. Expect the **PR size** gate to block it too: the picked commits drag their own upstream tests along (769/600 in `server/api` for two picks), and splitting a replay of already-reviewed work is the wrong answer — add `large-pr-ok`.
 - **`api#test-ce` can exit 1 with every test passing — read the `Errors` line, not just `Tests`.** Vitest fails the run on *unhandled* errors too, so the summary reads `Test Files 92 passed`, `Tests 1076 passed`, `Errors 3 errors` and turbo reports `Failed: api#test-ce`. The recurring one is `TypeError: socket.destroySoon is not a function` at `Timeout.forceClose` in `@hono/node-server`, attributed to `test/integration/ce/mcp/mcp-platform-project-selection.test.ts` — a teardown race after the test already finished, not a failure of whatever you changed. Before chasing it, scroll to the `Unhandled Errors` block and check whether any test actually failed; if none did and the stack is in `forceClose`, re-run the job (`gh run rerun <id> --failed`) rather than editing code. Note the log section only has the whole `main` job, so `gh run view --job <id> --log-failed` buries it under thousands of lines of passing-test stderr — grep for `Unhandled Errors` or `Test Files`.
diff --git a/brain/knowledge/flows-execution/chat-activation-metric.md b/brain/knowledge/flows-execution/chat-activation-metric.md
new file mode 100644
index 000000000000..76f97a25375b
--- /dev/null
+++ b/brain/knowledge/flows-execution/chat-activation-metric.md
@@ -0,0 +1,137 @@
+---
+icon: 📈
+---
+
+# Chat Activation Metric
+
+The number the chat and agents roadmap is ranked by: the share of first-time chatters who, within 7 days of their first chat, have an automation that keeps running. It is one SQL query over data that already exists, with no events, column or migration behind it.
+
+**Activated** within 7 days of the user's first CHAT message (the first conversation whose transcript holds a user message; an opened, empty conversation doesn't count), either a chat-built flow is ENABLED with at least 3 SUCCEEDED production runs, or the user owns a published agent created in that window with at least 3 successful runs on at least 2 distinct days.
+**Chat-built flow** a flow whose id is in `output.structuredContent.flowId` of a completed `ap_build_flow` part in `agent_conversation.uiMessages`, and which was created inside the 7-day window.
+**Successful agent run** a conversation with an assistant reply: AGENT-source and ended IDLE, or FLOW_STEP with a `flowRunId` that is a SUCCEEDED production run.
+
+## Stages
+
+S1 first chat → S2 tried to build (`ap_set_build_plan`, `ap_build_flow` or `ap_create_agent`) → S3 flow built or agent created → S4 published → S5 first good production run → S6 activated. Each stage counts users who also passed the earlier ones, so the counts only go down.
+
+## Running it
+
+1. Open a Craftboxes box (`box new -n chat-activation`). The replica is reached through the box's `craftbox` MCP server (`postgres_query`, one read-only statement, 1000 rows max), not through `psql`.
+2. The replica has a 15s statement timeout, so the single query below times out on prod. Run it in stages and join them locally:
+   1. the cohort and S2 counts;
+   2. the chat-built flow ids;
+   3. flow state and run counts, in batches of about 50 flows passed back as `VALUES`;
+   4. agents the cohort owns that were created in the window, with their published state and successful runs.
+   The single query is still the definition. Save the SQL block below as `chat-activation.sql` and it runs as-is on a local or dev database with `psql -v since=2026-06-01 -f chat-activation.sql`.
+3. Record the row, with the date, under Baselines.
+
+```sql
+with first_chat as (
+    select "userId", "platformId", min(created) as t0
+    from agent_conversation
+    where source = 'CHAT' and "uiMessages" @> '[{"role":"user"}]'
+    group by "userId", "platformId"
+),
+cohort as (
+    select *, t0 + interval '7 days' as t7
+    from first_chat
+    where t0 >= :'since'::timestamptz and t0 < now() - interval '7 days'
+),
+chat_parts as (
+    select c."userId", c."platformId", p
+    from agent_conversation c
+    join cohort k on k."userId" = c."userId" and k."platformId" = c."platformId"
+    cross join lateral jsonb_array_elements(coalesce(c."uiMessages", '[]'::jsonb)) m
+    cross join lateral jsonb_array_elements(coalesce(m->'parts', '[]'::jsonb)) p
+    where c.source = 'CHAT' and c.created < k.t7 and p->>'type' = 'tool-call'
+),
+tried as (
+    select distinct "userId", "platformId"
+    from chat_parts
+    where p->>'toolName' in ('ap_set_build_plan', 'ap_build_flow', 'ap_create_agent')
+),
+built_flows as (
+    select distinct cp."userId", cp."platformId", cp.p->'output'->'structuredContent'->>'flowId' as flow_id, f.status, f."publishedVersionId"
+    from chat_parts cp
+    join cohort k on k."userId" = cp."userId" and k."platformId" = cp."platformId"
+    left join flow f on f.id = cp.p->'output'->'structuredContent'->>'flowId'
+    left join project pr on pr.id = f."projectId" and pr."platformId" = cp."platformId"
+    where cp.p->>'toolName' = 'ap_build_flow' and cp.p->>'status' = 'completed'
+        and cp.p->'output'->'structuredContent'->>'flowId' is not null
+        and (f.id is null or (pr.id is not null and f.created < k.t7))
+),
+flow_runs as (
+    select bf."userId", bf."platformId", bf.flow_id, bf.status, bf."publishedVersionId", count(r.id) as good_runs
+    from built_flows bf
+    join cohort k on k."userId" = bf."userId" and k."platformId" = bf."platformId"
+    left join flow_run r on r."flowId" = bf.flow_id
+        and r.environment = 'PRODUCTION' and r.status = 'SUCCEEDED'
+        and r.created >= k.t0 and r.created < k.t7
+    group by 1, 2, 3, 4, 5
+),
+owned_agents as (
+    select k."userId", k."platformId", a.id as agent_id, a.published is not null as is_published
+    from agent a
+    join project pr on pr.id = a."projectId"
+    join cohort k on k."userId" = a."ownerId" and k."platformId" = pr."platformId"
+    where a.created >= k.t0 and a.created < k.t7
+),
+agent_runs as (
+    select oa."userId", oa."platformId", oa.agent_id, oa.is_published,
+        count(ac.id) as good_runs,
+        count(distinct date_trunc('day', ac.created)) as good_days
+    from owned_agents oa
+    join cohort k on k."userId" = oa."userId" and k."platformId" = oa."platformId"
+    left join agent_conversation ac on ac."agentId" = oa.agent_id
+        and ac."platformId" = oa."platformId"
+        and ac.created >= k.t0 and ac.created < k.t7
+        and ac."uiMessages" @> '[{"role":"assistant"}]'
+        and (
+            (ac.source = 'AGENT' and ac.status = 'IDLE')
+            or (ac.source = 'FLOW_STEP' and exists (
+                select 1 from flow_run fr
+                where fr.id = ac."flowRunId" and fr.environment = 'PRODUCTION' and fr.status = 'SUCCEEDED'
+            ))
+        )
+    group by 1, 2, 3, 4
+),
+per_user as (
+    select k."userId", k."platformId",
+        t."userId" is not null as s2_tried,
+        exists (select 1 from built_flows b where b."userId" = k."userId" and b."platformId" = k."platformId")
+            or exists (select 1 from owned_agents o where o."userId" = k."userId" and o."platformId" = k."platformId") as s3_built,
+        exists (select 1 from flow_runs f where f."userId" = k."userId" and f."platformId" = k."platformId" and f."publishedVersionId" is not null)
+            or exists (select 1 from agent_runs a where a."userId" = k."userId" and a."platformId" = k."platformId" and a.is_published) as s4_published,
+        exists (select 1 from flow_runs f where f."userId" = k."userId" and f."platformId" = k."platformId" and f.good_runs >= 1)
+            or exists (select 1 from agent_runs a where a."userId" = k."userId" and a."platformId" = k."platformId" and a.good_runs >= 1) as s5_first_run,
+        exists (select 1 from flow_runs f where f."userId" = k."userId" and f."platformId" = k."platformId" and f.status = 'ENABLED' and f.good_runs >= 3)
+            or exists (select 1 from agent_runs a where a."userId" = k."userId" and a."platformId" = k."platformId" and a.is_published and a.good_runs >= 3 and a.good_days >= 2) as s6_activated
+    from cohort k
+    left join tried t on t."userId" = k."userId" and t."platformId" = k."platformId"
+)
+select
+    count(*) as s1_first_chat,
+    count(*) filter (where s2_tried or s3_built) as s2_tried_to_build,
+    count(*) filter (where s3_built) as s3_built,
+    count(*) filter (where s3_built and s4_published) as s4_published,
+    count(*) filter (where s3_built and s4_published and s5_first_run) as s5_first_good_run,
+    count(*) filter (where s6_activated) as s6_activated,
+    round(100.0 * count(*) filter (where s6_activated) / nullif(count(*), 0), 1) as activation_pct
+from per_user;
+```
+
+## Baselines
+
+| Date | Cohort (first chat before) | S1 | S2 | S3 | S4 | S5 | S6 | Activation |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| 2026-09-29 | 2026-09-22 | 850 | 280 | 229 | 91 | 44 | 25 | 2.9% |
+
+S3 counts a flow that was built in the window and later deleted. On 2026-09-29, 68 of 381 chat-built flows had been deleted since, and agents contributed nothing: 72 exist on Cloud, 3 are published, and 2 have ever run.
+
+## Gotchas
+
+- **Read `uiMessages`, not `messages`.** `messages` is the model context and compaction rewrites it; `uiMessages` is the durable transcript, and it is the only one holding `ap_build_flow` results with the flowId.
+- **Publish state is today's, not day 7's.** `flow.status` and `publishedVersionId` are current values, so a flow that was published and later turned off drops out of S4. Runs are windowed correctly.
+- **The cohort anchor is the first CHAT message, not `chat_rollout_user.chattedAt`.** The rollout table only exists on Cloud and counts one row per user across all platforms, while S1 is per user and platform. Expect the two to be close, not equal.
+- **The chatted count doesn't show the rollout cap.** Platforms whose plan has `chatEnabled` bypass the rollout, and their users still add `chattedAt` rows, so 1,505 chatted users on 2026-09-29 says nothing about `CLOUD_CHAT_ROLLOUT_CAP`.
+- **Small cohorts swing.** Under the rollout cap one user moves a stage by several points, so read the counts next to the percentages.
diff --git a/brain/knowledge/flows-execution/chat.md b/brain/knowledge/flows-execution/chat.md
index f5310b32fa3d..ff6c555aee18 100644
--- a/brain/knowledge/flows-execution/chat.md
+++ b/brain/knowledge/flows-execution/chat.md
@@ -31,12 +31,15 @@ A turn is kept alive / reclaimed by three separate mechanisms in `execute-agent-
 - **Stream idle watchdog** (`STREAM_IDLE_TIMEOUT_MS` 90s, in `streamChunksToClient`): aborts the turn if the drain-stream reader is silent 90s. It must be SUSPENDED while legitimate silent work is in flight — pending tool calls AND in-flight reasoning (`reasoning-start`→`reasoning-end`). **Reasoning-awareness was missing and caused the bug where long "thinking" on the Expert tier randomly aborted a healthy turn** (a >90s gap between reasoning deltas looked like a wedge). Backstop for a genuine mid-reasoning wedge is `MAX_TURN_WALL_CLOCK_MS` (20 min).
 
 ### Gotchas
+- **The streaming lock is per run, not per conversation.** A re-send can claim `activeRunId` before the first job reaches `getAgentConfig`. `agentHelpers.acquireStreamingLock` only lets the owning run set STREAMING; an older run gets `AGENT_RUN_SUPERSEDED` and the worker exits quietly, with no ERROR save and no events. A lock that ignored `runId` let the old run stream unowned while the new one was rejected as busy and marked ERROR, which is how users saw nothing after tapping a starter card twice.
+- **A failed turn used to leave status ERROR with an empty reply.** The error text only travelled as a websocket `ERROR` event, so a reload, another tab, or a user who was away saw a dead conversation (and often no user message either when the job died inside `getAgentConfig`, before it persists the turn). The `execute-agent-run.ts` catch now sends `failure: { message, userMessage? }` on the empty `saveAgentMessages` call and `conversation-rpc.ts` appends it to `uiMessages` as an assistant text reply; `use-chat.ts` shows the Retry banner when a loaded conversation is ERROR. Stale STREAMING to IDLE recovery, a worker that never picks the job up, and `assertAgentMessageRateLimitNotExceeded` still leave no reply of their own.
+- **A built flow ends with a "Turn it on?" card, never an auto-publish**: an audit found 40% of built-but-unpublished flows ended on "open it to review", some claiming LIVE. Chat never publishes on its own; only a yes to the card calls `ap_lock_and_publish` (`build_flow.md` "Turn it on?"). Pinned by the `build-then-ask-turn-it-on` fixture (`askedToTurnItOn`, `noLiveClaimWithoutPublish`). The live-claim check is a regex plus "was `ap_lock_and_publish` called", so it cannot see whether publish succeeded.
 - **Server-managed connections**: the LLM never sees connection externalIds; `ap_execute_action` auto-fills them from a Redis store.
 - **Prompt-injection taint**: a per-turn `taintState` flips to `tainted` once the turn reads outside or user data (MCP tools, web/search/scrape, `ap_explore_data`, `ap_execute_action`, `ap_run_code`, `ap_list_across_projects`, configured tools). It forces the action-preview gate on non-read-only actions, blocks saved-agent edits, and makes `ap_remember` ask before saving (memory reaches every future conversation). It carries one message: each saved reply stores `tainted` (this reply's own reads, via `createTaintState`), and the next message starts from it. Deletes are confirmed always, not by taint.
 - **Write-check gate**: before a live `ap_test_flow`, `__flow_write_check` RPC flags write/destructive PIECE steps; read-only flows run ungated; gate fails open on RPC error.
 - **Cloud rollout cap**: opens to non-embed users without `chatEnabled` until 200 distinct users have sent a message (`CLOUD_CHAT_ROLLOUT_CAP`); grandfathered after close. Embedded sessions never see chat.
 - **Flow correctness is 100% prompt/guide-driven — nothing in code enforces it.** The "#1 silent bug" ("Class A"): the agent frames a *recurring* automation as a *one-time task* and omits any anti-reprocessing step, so run N+1 redoes run N's work (re-pays, re-sends). It's a design-time reasoning gap, not a testing gap — `ap_test_flow` runs ONCE, so a single test looks perfect; the bug only shows on the 2nd run. Fix lives in the prompt (`chat-system-prompt.md` `<decision_framework>` + `build_flow.md` "Recurring flows must not reprocess") + capability eval fixtures with a `recurring_avoids_reprocessing` judge dimension. The platform already has every primitive (Tables New-Record webhook, polling `DedupeStrategy`, `_dedupe_key`, Store, update/delete-record); the agent just wasn't reaching for them. Watch the `build_flow.md` "don't over-build" bias — it once actively discouraged the fix.
-- **The context budget ignores tool schemas and reserved `max_tokens`.** Anthropic/OpenRouter count both against the 200k window; `agent-compaction.ts` budgets neither. It trims history to `COMPACTION_THRESHOLD (0.7) × 200_000 = 140_000` and its fit check looks only at message chars, while `run-agent-turn.ts` sets `maxOutputTokens: tier.thinkingBudget + 32_000` → 52k reserved on premium, plus ~12k of tool schemas (62 tools, 41 via MCP). 140k + 12k + 52k = 204k, so a conversation that compacts to just under the threshold still 400s with "maximum context length is 200000 tokens" — and it gets retried ~6× (`streamText maxRetries: 3` × `MAX_STREAM_RETRIES`), burning ~20s per turn. `maxOutputTokens` is set at the `streamText` call level, so the full thinking budget stays reserved even on step one where `prepareStep` disables thinking and swaps in haiku-4.5 (real case: 148_628 text + 11_872 tool + 52_000 output = 212_500; dropping the unused 20k reservation alone would have fit). `ESTIMATED_TOKENS_PER_MESSAGE = 200` also sizes the recent window by message *count*, so a 12-message history holding ~235k tokens of uploaded documents summarized only 1 message. When budgeting, subtract the reserved output window and tool-schema size from `getMaxContextTokens`, and don't reserve `thinkingBudget` on a thinking-disabled step.
+- **The context budget subtracts what the request reserves.** Anthropic/OpenRouter count tool schemas and the reserved `max_tokens` against the 200k window, so `getAgentConfig` passes `reservedTokens` (the clamped output window from `agentAiUtils.affordableOutputTokens`, the same helper the worker uses for `maxOutputTokens`, plus `TOOL_SCHEMA_TOKEN_ESTIMATE = 12_000`) into `agentCompaction`. The threshold, the fit check and the recent window are all measured against `maxContext - reservedTokens`, and the recent window is sized by estimated tokens, not message count. The tool-schema figure is a constant because the tools are built in the worker and the API never sees their definitions. The worker sets `maxOutputTokens` per step in `prepareStep`, so a thinking-disabled step (round one, discovery phase) does not reserve `thinkingBudget`. The system prompt's size is added to the reserve for the window and fit check, and each message is capped at 20k chars in the summary request so the summarizer itself cannot overflow.
 - **A write tool in `BUILD_ONLY_TOOL_NAMES` is only reachable if something flips the phase for it.** The denylist is the consistent home for anything that writes (`ap_create_flow`, `ap_create_table`, `ap_lock_and_publish` are all in it), but the only route out of `discovery` is `ap_set_phase`, whose description tells the model to switch when it starts *building an automation*. A tool for a subject with no build guide and no sibling build-only call, the agent-building tools being the case that found this, becomes invisible in any conversation that never builds a flow: `activeToolsForPhase` filters it out and the prompt names no tool, so the model cannot discover that it exists. Classifying by "does it write" is not enough; check what would actually flip the phase in a conversation about *that* subject. The four agent *write* tools (`ap_create_agent`, `ap_update_agent`, `ap_add_agent_tool`, `ap_remove_agent_tool`) were added to the set and then reverted for exactly this, with a test pinning the choice; `ap_list_agents` is a read and was never in it, so the group is five tools and only four were ever candidates.
 - **Capability notes are built where `discoveryOnly` is not known, so a prompt can promise tools the worker has stripped.** `getAgentConfig` composes the system prompt in the api, while `discoveryOnly` rides on the job data; before Aug 2026 it never crossed that boundary. Meanwhile the worker strips image tools, email tools and the agent tools on such a run, so the notes claimed all three. Two of the three had been wrong since long before anyone noticed, because each note computed its own availability term. The flag now travels with the config request and the three notes read one shared `actingRun = !dryRun && !discoveryOnly`. Whenever a tool group is gated on a run mode in the worker, the note that advertises it has to be gated on the same term, in one place.
 - **Tool output can't be trusted to waive a charge.** A user's own MCP server or `ap_run_code` controls its output's top-level keys, and they reach the persisted part unchanged. Chat billing only honours `billedAtCost` from `ap_web_search` and `ap_generate_image`; a new built-in tool that bills at cost must be added to `TOOLS_THAT_BILL_AT_COST` in `chatBilling`.
diff --git a/brain/knowledge/memory.md b/brain/knowledge/memory.md
index 3b7c59302334..0befdb61ec63 100644
--- a/brain/knowledge/memory.md
+++ b/brain/knowledge/memory.md
@@ -2,6 +2,7 @@
 - 2026-09-24 — `test-unit` (api unit tests) only joined the PR pipeline on 2026-09-20 (#15653). A branch whose last CI run predates that has never had its unit tests run in CI; expect first-time failures when it merges `main`, as #15550 did (a test mock disagreeing with the real code, not a merge problem).
 - 2026-09-27 — PR 3 of the configurable tiers work (`feat/tier-endpoint`, ENG-768): `GET /v1/ai-providers/tiers` serves both lists and both web pickers read it; a new chat no longer hardcodes `smart`. Found on the way: the live `ai/pricing.json` republished on 2026-09-26 carried `defaultTierId: fast`, which never reached web chats only because the web sent `smart` explicitly; it is being republished as `smart`.
 - 2026-09-28 — PR 4 of the configurable tiers work (`feat/tier-ai-piece`, ENG-752): the AI piece's managed text dropdown (piece 0.12.0, `minimumSupportedRelease` 0.93.0) offers the published flow tiers and stores the tier id, falling back to the bundled tier ids, never `/models`. `aiModelResolution.resolveTierModelId` (`src/app/ai/`, CE) turns the id into today's flow model in `ai-execute-controller` before enqueue, skips image steps, and logs `model.id` and `tier.id` on both branches. Merge gate: `origin/main`'s root version must be below 0.93.0 when it merges.
+- 2026-09-28 — PR 5 of the configurable tiers work (`feat/tier-agent-step`, ENG-754): managed agents and Run Agent steps store the flow tier id, a blank picker pre-fills the published default, and a named tier supplies its own thinking budget (Heavy 10k → 20k). Chosen that day: older rows show their raw model id and keep Expert's budget until ENG-753, with no display or budget mapping; own-key agents get no server-side guard, PR 6's tier map will cover them.
 - 2026-09-20 — Found while planning the AI tier work: managed AI piece steps under-billed for about 23 days, between #14942 (2026-08-24) and #15494 (2026-09-16). #14942 changed the AI piece's `provider` prop to store an object (`{ provider, configId }`), but `flow-run-ai-usage-extractor` read that field with a string-only helper, so it resolved to `'unknown'`, failed the `provider !== ACTIVEPIECES` check in `resolveAiCreditWeight`, and charged **1 credit** per step instead of the model's table weight. It hit the five non-agent AI steps only, and only those configured or re-saved inside that window — a step saved earlier still held a plain string and billed correctly. `run_agent` was never affected, because it stores `aiProviderModel` instead. Nothing logged an error, and every test in the file passed a string provider, so the suite was green the whole time. The code is gone (#15494 deleted the extractor and bills on real provider cost now), so there is nothing left to fix — but the cloud credit events for that window are still wrong, and nobody has reconciled them.
 - 2026-09-20 — The live `ai/pricing.json` (version 1, published 2026-09-14) carried a leftover test tier `tier-4` / "New tier" on `anthropic/claude-opus-4.8`, created by clicking "add tier" in the pricing console and publishing. It was removed on 2026-09-24 by deleting the whole object, so the key is 404 until someone publishes again from the console; every server falls back to the bundled tiers and warns every five minutes until then. Next time, edit the row and publish; do not delete the object.
 - 2026-09-06 — Follow-up (Option B, "stub-writer cascade"): fix `engine-run-callback-service.ts` `ensureLogsFileExists` (line 84-86) so a fresh log-file stub isn't written with `{ steps: {}, tags: [] }` when the underlying file is missing — that stub is what the next BullMQ retry downloads and trips `EmptyResumeStateError` on. Options: (a) store `internalError` on `flow_run` itself so no stub is needed; (b) use a distinguishable stub shape (`executionState: null`) that the engine reader rejects fast; (c) `UnrecoverableError` in worker on state-loss errors so BullMQ doesn't retry the stub. Handles manual-admin-ops case (case #5 in the retention-hunt discussion) and any non-retention internal-error that would otherwise loop. Ping user once C.2/W.1/#2/#4 have landed.
diff --git a/packages/core/execution/package.json b/packages/core/execution/package.json
index f642e826e8f0..e8fa3d370d0a 100644
--- a/packages/core/execution/package.json
+++ b/packages/core/execution/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@activepieces/core-execution",
-  "version": "0.23.4",
+  "version": "0.23.5",
   "type": "commonjs",
   "main": "./dist/src/index.js",
   "scripts": {
diff --git a/packages/core/execution/src/lib/workers/worker-contract.ts b/packages/core/execution/src/lib/workers/worker-contract.ts
index 78ce7655228d..23a3fd0a0cf2 100644
--- a/packages/core/execution/src/lib/workers/worker-contract.ts
+++ b/packages/core/execution/src/lib/workers/worker-contract.ts
@@ -184,6 +184,7 @@ export type SaveAgentMessagesRequest = {
     uiMessages: unknown[]
     title?: string
     modelName?: string
+    failure?: { message: string, userMessage?: string }
 }
 
 export type SaveAgentFileRequest = {
diff --git a/packages/core/utils/package.json b/packages/core/utils/package.json
index 038de4dadb1e..20638a9b878b 100644
--- a/packages/core/utils/package.json
+++ b/packages/core/utils/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@activepieces/core-utils",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "type": "commonjs",
   "main": "./dist/src/index.js",
   "scripts": {
diff --git a/packages/core/utils/src/lib/activepieces-error.ts b/packages/core/utils/src/lib/activepieces-error.ts
index 5696e6c790f0..d6621c427a72 100644
--- a/packages/core/utils/src/lib/activepieces-error.ts
+++ b/packages/core/utils/src/lib/activepieces-error.ts
@@ -50,6 +50,7 @@ export type ApErrorParams =
     | TriggerUpdateStatusErrorParams
     | TriggerFailedErrorParams
     | ValidationErrorParams
+    | AgentRunSupersededErrorParams
     | FileTooLargeErrorParams
     | InvitationOnlySignUpParams
     | UserIsInActiveErrorParams
@@ -325,6 +326,13 @@ ErrorCode.VALIDATION,
 }
 >
 
+export type AgentRunSupersededErrorParams = BaseErrorParams<
+ErrorCode.AGENT_RUN_SUPERSEDED,
+{
+    message: string
+}
+>
+
 export type FileTooLargeErrorParams = BaseErrorParams<
 ErrorCode.FILE_TOO_LARGE,
 {
@@ -592,6 +600,7 @@ export enum ErrorCode {
     USER_IS_INACTIVE = 'USER_IS_INACTIVE',
     USER_NOT_FOUND_ON_PLATFORM = 'USER_NOT_FOUND_ON_PLATFORM',
     VALIDATION = 'VALIDATION',
+    AGENT_RUN_SUPERSEDED = 'AGENT_RUN_SUPERSEDED',
     FILE_TOO_LARGE = 'FILE_TOO_LARGE',
     INVALID_LICENSE_KEY = 'INVALID_LICENSE_KEY',
     EMAIL_ALREADY_HAS_ACTIVATION_KEY = 'EMAIL_ALREADY_HAS_ACTIVATION_KEY',
diff --git a/packages/core/utils/src/lib/deno.ts b/packages/core/utils/src/lib/deno.ts
index a020c90a5a89..abb7bae61f51 100644
--- a/packages/core/utils/src/lib/deno.ts
+++ b/packages/core/utils/src/lib/deno.ts
@@ -50,7 +50,11 @@ export const deno = {
                     message = JSON.parse(resultJson)
                 }
                 catch {
-                    reject(sandboxError.build({ error: 'Deno process returned a malformed result', stdout: userOutput, stderr: capturedStderr }))
+                    const processDied = code !== 0 || signal !== null
+                    const error = processDied
+                        ? `Deno process exited with code ${code} and signal ${signal} while writing its result`
+                        : 'Deno process returned a malformed result'
+                    reject(sandboxError.build({ error, stdout: userOutput, stderr: capturedStderr }))
                     return
                 }
 
diff --git a/packages/server/api/src/app/ee/agent/agent-compaction.ts b/packages/server/api/src/app/ee/agent/agent-compaction.ts
index 5c22903a7352..889d0dd5bfa3 100644
--- a/packages/server/api/src/app/ee/agent/agent-compaction.ts
+++ b/packages/server/api/src/app/ee/agent/agent-compaction.ts
@@ -10,8 +10,8 @@ const COMPACTION_THRESHOLD = 0.7
 const RECENT_WINDOW_RATIO = 0.3
 const CHARS_PER_TOKEN_ESTIMATE = 4
 const MIN_MESSAGES_BEFORE_COMPACTION = 6
-const ESTIMATED_TOKENS_PER_MESSAGE = 200
 const MAX_TOOL_RESULT_CHARS_FOR_SUMMARY = 2_000
+const SUMMARY_OUTPUT_RESERVE_TOKENS = 4_000
 
 const COMPACTION_SYSTEM_PROMPT = readFileSync(
     path.resolve('packages/server/api/src/assets/prompts/chat-compaction-prompt.md'),
@@ -22,20 +22,33 @@ function estimateTokenCount({ messages, systemPromptLength }: {
     messages: ModelMessage[]
     systemPromptLength: number
 }): number {
-    const totalChars = JSON.stringify(messages).length + systemPromptLength
-    return Math.ceil(totalChars / CHARS_PER_TOKEN_ESTIMATE)
+    return tokensIn(JSON.stringify(messages)) + Math.ceil(systemPromptLength / CHARS_PER_TOKEN_ESTIMATE)
 }
 
-function shouldCompact({ estimatedTokens, provider, messageCount }: {
+function contextBudget({ provider, reservedTokens }: { provider: AIProviderName, reservedTokens: number }): number {
+    return Math.max(0, aiProviderUtils.getMaxContextTokens({ provider }) - reservedTokens)
+}
+
+function recentWindowSizeFor({ messages, targetTokens }: { messages: ModelMessage[], targetTokens: number }): number {
+    let tokens = 0
+    let size = 0
+    for (let i = messages.length - 1; i > 0 && tokens < targetTokens; i--) {
+        tokens += tokensIn(JSON.stringify(messages[i]))
+        size++
+    }
+    return Math.min(Math.max(2, size), messages.length - 1)
+}
+
+function shouldCompact({ estimatedTokens, provider, messageCount, reservedTokens }: {
     estimatedTokens: number
     provider: AIProviderName
     messageCount: number
+    reservedTokens: number
 }): boolean {
     if (messageCount < MIN_MESSAGES_BEFORE_COMPACTION) {
         return false
     }
-    const maxContext = aiProviderUtils.getMaxContextTokens({ provider })
-    return estimatedTokens > maxContext * COMPACTION_THRESHOLD
+    return estimatedTokens > contextBudget({ provider, reservedTokens }) * COMPACTION_THRESHOLD
 }
 
 /**
@@ -55,20 +68,19 @@ function snapToSafeMessageBoundary({ messages, rawCutoff }: {
     return idx
 }
 
-async function compactMessages({ messages, existingSummary, summarizedUpToIndex, provider, model, log }: {
+async function compactMessages({ messages, existingSummary, summarizedUpToIndex, provider, reservedTokens, model, log }: {
     messages: ModelMessage[]
     existingSummary: string | null
     summarizedUpToIndex: number | null
     provider: AIProviderName
+    reservedTokens: number
     model: LanguageModel
     log: FastifyBaseLogger
 }): Promise<{ summary: string, summarizedUpToIndex: number }> {
-    const maxContext = aiProviderUtils.getMaxContextTokens({ provider })
-    const targetRecentTokens = maxContext * RECENT_WINDOW_RATIO
-    const recentWindowSize = Math.min(
-        Math.max(2, Math.floor(targetRecentTokens / ESTIMATED_TOKENS_PER_MESSAGE)),
-        messages.length - 1,
-    )
+    const recentWindowSize = recentWindowSizeFor({
+        messages,
+        targetTokens: contextBudget({ provider, reservedTokens }) * RECENT_WINDOW_RATIO,
+    })
     const rawCutoff = messages.length - recentWindowSize
     const newCutoffIndex = snapToSafeMessageBoundary({ messages, rawCutoff })
 
@@ -83,12 +95,17 @@ async function compactMessages({ messages, existingSummary, summarizedUpToIndex,
         contentToSummarize += `Previous conversation summary:\n${existingSummary}\n\nNew messages since last summary:\n`
     }
 
-    for (const msg of messagesToSummarize) {
-        const content = extractTextContent(msg)
+    const texts = messagesToSummarize.map((msg) => extractTextContent(msg))
+    const summaryInputTokens = contextBudget({ provider, reservedTokens: SUMMARY_OUTPUT_RESERVE_TOKENS }) * COMPACTION_THRESHOLD
+        - tokensIn(COMPACTION_SYSTEM_PROMPT)
+        - tokensIn(contentToSummarize)
+    const perMessageTokens = fairShareCap({ lengths: texts.map(tokensIn), budget: summaryInputTokens })
+    messagesToSummarize.forEach((msg, i) => {
+        const content = truncateToTokens({ text: texts[i], maxTokens: perMessageTokens })
         if (content) {
             contentToSummarize += `[${msg.role}]: ${content}\n`
         }
-    }
+    })
 
     log.info({
         totalMessages: messages.length,
@@ -108,11 +125,12 @@ async function compactMessages({ messages, existingSummary, summarizedUpToIndex,
     return { summary, summarizedUpToIndex: newCutoffIndex }
 }
 
-function buildCompactedPayload({ messages, summary, summarizedUpToIndex, provider }: {
+function buildCompactedPayload({ messages, summary, summarizedUpToIndex, provider, reservedTokens }: {
     messages: ModelMessage[]
     summary: string | null
     summarizedUpToIndex: number | null
     provider: AIProviderName
+    reservedTokens: number
 }): ModelMessage[] {
     if (!summary || summarizedUpToIndex === null) {
         return messages
@@ -121,19 +139,18 @@ function buildCompactedPayload({ messages, summary, summarizedUpToIndex, provide
     const recentMessages = messages.slice(summarizedUpToIndex)
     const summaryText = `[Previous conversation summary]\n${summary}\n[End of summary — conversation continues below]`
 
-    const maxContext = aiProviderUtils.getMaxContextTokens({ provider })
-    const threshold = maxContext * COMPACTION_THRESHOLD
-    const summaryCharLen = JSON.stringify(summaryText).length
-    const recentLengths = recentMessages.map((m) => JSON.stringify(m).length)
+    const budget = contextBudget({ provider, reservedTokens })
+    const threshold = budget * COMPACTION_THRESHOLD
+    const recentTokens = recentMessages.map((m) => tokensIn(JSON.stringify(m)))
 
-    let runningCharLen = summaryCharLen + recentLengths.reduce((a, b) => a + b, 0)
+    let runningTokens = tokensIn(JSON.stringify(summaryText)) + recentTokens.reduce((a, b) => a + b, 0)
     let startIdx = 0
 
     while (
         startIdx < recentMessages.length - 1
-        && (Math.ceil(runningCharLen / CHARS_PER_TOKEN_ESTIMATE) > threshold || recentMessages[startIdx].role === 'tool')
+        && (runningTokens > threshold || recentMessages[startIdx].role === 'tool')
     ) {
-        runningCharLen -= recentLengths[startIdx]
+        runningTokens -= recentTokens[startIdx]
         startIdx++
     }
 
@@ -152,9 +169,7 @@ function buildCompactedPayload({ messages, summary, summarizedUpToIndex, provide
             ...trimmedRecent.slice(1),
         ]
         : [{ role: 'user', content: summaryText }, ...trimmedRecent]
-    const finalEstimate = Math.ceil(runningCharLen / CHARS_PER_TOKEN_ESTIMATE)
-
-    if (finalEstimate > maxContext) {
+    if (runningTokens > budget) {
         throw new ActivepiecesError({
             code: ErrorCode.CHAT_CONTEXT_LIMIT_EXCEEDED,
             params: {},
@@ -164,10 +179,47 @@ function buildCompactedPayload({ messages, summary, summarizedUpToIndex, provide
     return finalPayload
 }
 
-function truncateForSummary(output: string): string {
+function fairShareCap({ lengths, budget }: { lengths: number[], budget: number }): number {
+    const ascending = [...lengths].sort((a, b) => a - b)
+    let remaining = budget
+    for (let i = 0; i < ascending.length; i++) {
+        const share = Math.floor(remaining / (ascending.length - i))
+        if (ascending[i] > share) {
+            return Math.max(0, share)
+        }
+        remaining -= ascending[i]
+    }
+    return Number.POSITIVE_INFINITY
+}
+
+function tokenCost(codePoint: string): number {
+    return codePoint.charCodeAt(0) < 128 ? 1 / CHARS_PER_TOKEN_ESTIMATE : 1
+}
+
+function tokensIn(text: string): number {
+    let tokens = 0
+    for (const codePoint of text) {
+        tokens += tokenCost(codePoint)
+    }
+    return Math.ceil(tokens)
+}
+
+function truncateToTokens({ text, maxTokens }: { text: string, maxTokens: number }): string {
+    if (tokensIn(text) <= maxTokens) return text
+    const codePoints = [...text]
+    let used = 0
+    let kept = 0
+    while (kept < codePoints.length && used + tokenCost(codePoints[kept]) <= maxTokens) {
+        used += tokenCost(codePoints[kept])
+        kept++
+    }
+    return `${codePoints.slice(0, kept).join('')}…[truncated ${codePoints.length - kept} chars]`
+}
+
+function truncateForSummary({ output, limit }: { output: string, limit: number }): string {
     const codePoints = [...output]
-    if (codePoints.length <= MAX_TOOL_RESULT_CHARS_FOR_SUMMARY) return output
-    return `${codePoints.slice(0, MAX_TOOL_RESULT_CHARS_FOR_SUMMARY).join('')}…[truncated ${codePoints.length - MAX_TOOL_RESULT_CHARS_FOR_SUMMARY} chars]`
+    if (codePoints.length <= limit) return output
+    return `${codePoints.slice(0, limit).join('')}…[truncated ${codePoints.length - limit} chars]`
 }
 
 function extractTextContent(message: ModelMessage): string {
@@ -187,7 +239,7 @@ function extractTextContent(message: ModelMessage): string {
             }
             else if (part.type === 'tool-result' && 'output' in part) {
                 const output = typeof part.output === 'string' ? part.output : JSON.stringify(part.output)
-                text += `[Tool result: ${truncateForSummary(output)}]`
+                text += `[Tool result: ${truncateForSummary({ output, limit: MAX_TOOL_RESULT_CHARS_FOR_SUMMARY })}]`
             }
         }
     }
diff --git a/packages/server/api/src/app/ee/agent/agent-helpers.ts b/packages/server/api/src/app/ee/agent/agent-helpers.ts
index 41272c51e472..3047b5fddfb5 100644
--- a/packages/server/api/src/app/ee/agent/agent-helpers.ts
+++ b/packages/server/api/src/app/ee/agent/agent-helpers.ts
@@ -350,6 +350,25 @@ async function claimConversationForRun({ conversationId, runId }: { conversation
     })
 }
 
+async function acquireStreamingLock({ conversationId, runId }: { conversationId: string, runId?: string }): Promise<StreamingLockResult> {
+    const builder = conversationRepo()
+        .createQueryBuilder()
+        .update()
+        .set({ status: AgentConversationStatus.STREAMING })
+        .where('id = :id AND status != :streaming', { id: conversationId, streaming: AgentConversationStatus.STREAMING })
+    if (!isNil(runId)) {
+        builder.andWhere('("activeRunId" IS NULL OR "activeRunId" = :runId)', { runId })
+    }
+    const result = await builder.returning('id').execute()
+    const lockedRows: unknown[] = result.raw ?? []
+    if (lockedRows.length > 0) {
+        return 'acquired'
+    }
+    const current = await conversationRepo().findOneBy({ id: conversationId })
+    const supersededByNewerRun = !isNil(runId) && !isNil(current?.activeRunId) && current.activeRunId !== runId
+    return supersededByNewerRun ? 'superseded' : 'busy'
+}
+
 async function resolveFlowTools({ projectId, tools, log }: { projectId: string, tools: AgentTool[], log: FastifyBaseLogger }): Promise<ResolvedAgentFlowTool[]> {
     const flowToolRequests = tools.filter((tool): tool is AgentFlowTool => tool.type === AgentToolType.FLOW)
     if (flowToolRequests.length === 0) {
@@ -411,6 +430,7 @@ async function assertAgentsSurfaceAvailable({ platformId, log }: { platformId: s
 export const agentHelpers = {
     jobFieldsFromConfig,
     claimConversationForRun,
+    acquireStreamingLock,
     resolveFlowTools,
     agentsSurfaceAvailable,
     assertAgentsSurfaceAvailable,
@@ -439,3 +459,5 @@ export const agentHelpers = {
 }
 
 type AgentJobConfigFields = Pick<ExecuteAgentRunJobData, 'tools' | 'structuredOutput' | 'maxSteps' | 'modelName' | 'provider' | 'providerConfigId' | 'promptOverride'>
+
+export type StreamingLockResult = 'acquired' | 'busy' | 'superseded'
diff --git a/packages/server/api/src/app/ee/agent/agent-model-resolution.ts b/packages/server/api/src/app/ee/agent/agent-model-resolution.ts
index f99809069111..28bd415f476b 100644
--- a/packages/server/api/src/app/ee/agent/agent-model-resolution.ts
+++ b/packages/server/api/src/app/ee/agent/agent-model-resolution.ts
@@ -15,6 +15,16 @@ function resolveTier({ tierId, surface }: { tierId: string | null, surface: Mode
     return modelTierCatalog.current(surface).resolveTier({ tierId })
 }
 
+function resolveRunTier({ provider, modelName, selectedModel, surface }: { provider: AIProviderName, modelName: string | null, selectedModel: string | null, surface: ModelTierSurface }): ModelTier {
+    if (surface === 'chat') {
+        return resolveTier({ tierId: selectedModel, surface })
+    }
+    const namedTier = provider === AIProviderName.ACTIVEPIECES && !isNil(modelName) && isTierId({ modelName })
+        ? findTier({ tierId: modelName, surface })
+        : undefined
+    return namedTier ?? resolveTier({ tierId: null, surface })
+}
+
 function nativeModelIdFor({ tier }: { tier: ModelTier }): string | null {
     return tier.nativeModelId ?? ACTIVEPIECES_CHAT_TIERS.find((shipped) => shipped.id === tier.id)?.nativeModelId ?? null
 }
@@ -117,6 +127,7 @@ export const agentModelResolution = {
     surfaceOf,
     findTier,
     resolveTier,
+    resolveRunTier,
     nativeModelIdFor,
     resolveNamedModelId,
     resolveModelIdForProvider,
diff --git a/packages/server/api/src/app/ee/agent/agent-service.ts b/packages/server/api/src/app/ee/agent/agent-service.ts
index 073b3285b23a..5845ef9bbb34 100644
--- a/packages/server/api/src/app/ee/agent/agent-service.ts
+++ b/packages/server/api/src/app/ee/agent/agent-service.ts
@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto'
 import { AgentToolType, McpAuthType } from '@activepieces/core-piece-types'
-import { ActivepiecesError, apId, ApId, connectionTemplate, Cursor, ErrorCode, isNil, omit, Permission, PlatformId, ProjectId, sanitizeObjectForPostgresql, SeekPage, unique, UserId } from '@activepieces/core-utils'
+import { ActivepiecesError, AIProviderName, apId, ApId, connectionTemplate, Cursor, ErrorCode, isNil, omit, Permission, PlatformId, ProjectId, sanitizeObjectForPostgresql, SeekPage, unique, UserId } from '@activepieces/core-utils'
 import { Agent, AgentConfig, AgentFlowTool, AgentKnowledgeBaseTool, AgentListSort, AgentMoveLoss, AgentMoveLossKind, AgentMovePreview, AgentRunSource, AgentSummary, agentUtils, AgentVisibility, CreateAgentRequest, DefaultProjectRole, Project, ProjectType, UpdateAgentRequest } from '@activepieces/shared'
 import { FastifyBaseLogger } from 'fastify'
 import { Brackets, EntityManager, In, SelectQueryBuilder } from 'typeorm'
@@ -431,7 +431,9 @@ async function withDefaultModel({ draft, platformId, projectId, log }: {
     if (isNil(provider)) {
         return draft
     }
-    const modelName = agentHelpers.defaultModelIdForProvider({ provider, surface: 'flow' })
+    const modelName = provider === AIProviderName.ACTIVEPIECES
+        ? agentHelpers.resolveTier({ tierId: null, surface: 'flow' }).id
+        : agentHelpers.defaultModelIdForProvider({ provider, surface: 'flow' })
     if (isNil(modelName)) {
         return { ...draft, provider }
     }
diff --git a/packages/server/api/src/app/ee/agent/rpc/agent-config-rpc.ts b/packages/server/api/src/app/ee/agent/rpc/agent-config-rpc.ts
index 9ab01d02267d..cbc27a07ecfa 100644
--- a/packages/server/api/src/app/ee/agent/rpc/agent-config-rpc.ts
+++ b/packages/server/api/src/app/ee/agent/rpc/agent-config-rpc.ts
@@ -1,6 +1,6 @@
 import { ActivepiecesError, ErrorCode, isNil, spreadIfDefined, tryCatch } from '@activepieces/core-utils'
-import { agentAiUtils, aiUtils, ModelTierSurface } from '@activepieces/server-utils'
-import { AgentConfigResponse, AgentConversationStatus, AgentRunSource, AiProviderToolChoices, AiProviderToolConfig, AIProviderWithoutSensitiveData, GetAgentConfigRequest, GetEnabledAiToolsResponse, GetProviderConfigResponse, PersistedAgentMessage, PersistedAgentPartType, PersistedAgentRole } from '@activepieces/shared'
+import { agentAiUtils, aiUtils } from '@activepieces/server-utils'
+import { AgentConfigResponse, AgentRunSource, GetAgentConfigRequest, GetEnabledAiToolsResponse, PersistedAgentMessage, PersistedAgentPartType, PersistedAgentRole } from '@activepieces/shared'
 import { ModelMessage } from 'ai'
 import { FastifyBaseLogger } from 'fastify'
 import { agentApprovalGate } from '.././agent-approval-gate'
@@ -12,7 +12,6 @@ import { chatPersonalizationService } from '.././personalization/chat-personaliz
 import { agentPrompt } from '.././prompt/agent-prompt'
 import { agentSurfaceNotes } from '.././prompt/agent-surface-notes'
 import { UserIdentity } from '.././prompt/agent-user-identity'
-import { aiProviderService, ProviderScope } from '../../../ai/ai-provider-service'
 import { aiToolConfigService } from '../../../ai/ai-tool-config-service'
 import { appConnectionService } from '../../../app-connection/app-connection-service/app-connection-service'
 import { system } from '../../../helper/system/system'
@@ -21,6 +20,7 @@ import { platformService } from '../../../platform/platform.service'
 import { userService } from '../../../user/user-service'
 import { smtpEmailSender } from '../../helper/email/email-sender/smtp-email-sender'
 
+import { chosenProviders } from './chosen-providers'
 import { CONNECTION_INVENTORY_LIMIT, loadOrStartConversation } from './rpc-shared'
 
 
@@ -95,30 +95,30 @@ export const agentConfigRpc = (log: FastifyBaseLogger) => ({
 
         const aiTools: GetEnabledAiToolsResponse = dryRun ? {} : enabledAiTools
         const surface = agentHelpers.surfaceOf({ source: requestedSource })
-        const chosenProviders = dryRun
+        const chosen = dryRun
             ? { search: null, image: null }
-            : await resolveChosenProviders({ platformId, choices: providerChoices, surface, scope: runScope, log })
+            : await chosenProviders.resolveForRun({ platformId, choices: providerChoices, surface, scope: runScope, log })
         const actingRun = !dryRun && !discoveryOnly
         const emailEnabled = actingRun && carriesChatContext && smtpEmailSender(log).isSmtpConfigured()
         const agentsAvailable = actingRun && agentsSurfaceOn
         const fetchAvailable = !dryRun
         // Tavily takes precedence over native LLM search; native is only the no-Tavily fallback.
         const tavilySearchAvailable = !isNil(aiTools.webSearch)
-        const webSearchAvailable = fetchAvailable && (tavilySearchAvailable || aiUtils.supportsWebSearch((chosenProviders.search?.credentials ?? providerConfig).provider))
+        const webSearchAvailable = fetchAvailable && (tavilySearchAvailable || aiUtils.supportsWebSearch((chosen.search?.credentials ?? providerConfig).provider))
         const generatesImagesOnProvider = actingRun && isNil(aiTools.imageGeneration)
         const imageModelId = !generatesImagesOnProvider
             ? undefined
-            : chosenProviders.image?.modelId ?? await agentHelpers.resolveImageModelId({ platformId, providerConfig, scope: runScope, log })
+            : chosen.image?.modelId ?? await agentHelpers.resolveImageModelId({ platformId, providerConfig, scope: runScope, log })
 
-        const lockResult = await agentHelpers.conversationRepo()
-            .createQueryBuilder()
-            .update()
-            .set({ status: AgentConversationStatus.STREAMING })
-            .where('id = :id AND status != :streaming', { id: conversationId, streaming: AgentConversationStatus.STREAMING })
-            .returning('id')
-            .execute()
-        const lockedRows: unknown[] = lockResult.raw ?? []
-        if (lockedRows.length === 0) {
+        const lock = await agentHelpers.acquireStreamingLock({ conversationId, ...spreadIfDefined('runId', input.runId) })
+        if (lock === 'superseded') {
+            log.info({ conversation: { id: conversationId } }, '[agentRpc#getAgentConfig] Run superseded by a newer message before it started')
+            throw new ActivepiecesError({
+                code: ErrorCode.AGENT_RUN_SUPERSEDED,
+                params: { message: 'This message was replaced by a newer one' },
+            })
+        }
+        if (lock === 'busy') {
             log.warn({ conversation: { id: conversationId } }, '[agentRpc#getAgentConfig] Concurrent run rejected (conversation already STREAMING)')
             throw new ActivepiecesError({
                 code: ErrorCode.VALIDATION,
@@ -131,10 +131,8 @@ export const agentConfigRpc = (log: FastifyBaseLogger) => ({
         }
 
         const selectedModel = modelName ?? conversation.modelName ?? null
-        // The tier resolver finds no tier for a concrete model id and silently returns the default,
-        // so a source that names its own model must never be routed through it.
         const namesItsOwnModel = surface === 'flow'
-        const tier = agentHelpers.resolveTier({ tierId: namesItsOwnModel ? null : selectedModel, surface })
+        const tier = agentHelpers.resolveRunTier({ provider: providerConfig.provider, modelName: modelName ?? null, selectedModel, surface })
         const resolvedModelId = namesItsOwnModel && !isNil(modelName)
             ? agentHelpers.resolveNamedModelId({ provider: providerConfig.provider, modelName, surface, modelScope: providerConfig.modelScope, modelIds: providerConfig.modelIds, log })
             : await agentHelpers.resolveModelId({ platformId, providerConfig, selectedModel, surface, scope: runScope, log })
@@ -206,10 +204,13 @@ export const agentConfigRpc = (log: FastifyBaseLogger) => ({
         })
         await agentApprovalGate.clearCancel({ conversationId })
 
+        const reservedOutputTokens = await agentAiUtils.affordableOutputTokens({ provider: providerConfig.provider, modelIds: [resolvedModelId, fastModelId], thinkingBudget: tier.thinkingBudget })
+        const reservedTokens = reservedOutputTokens + TOOL_SCHEMA_TOKEN_ESTIMATE
+        const payloadReservedTokens = reservedTokens + agentAiUtils.estimateTokenCount({ messages: [], systemPromptLength: systemPromptText.length })
         const estimatedTokens = agentCompaction.estimateTokenCount({ messages: llmHistory, systemPromptLength: systemPromptText.length })
         let compactionState = { summary: conversation.summary ?? null, summarizedUpToIndex: conversation.summarizedUpToIndex ?? null }
 
-        const willCompact = agentCompaction.shouldCompact({ estimatedTokens, provider: providerConfig.provider, messageCount: llmHistory.length })
+        const willCompact = agentCompaction.shouldCompact({ estimatedTokens, provider: providerConfig.provider, messageCount: llmHistory.length, reservedTokens })
         log.debug({ estimatedTokens, willCompact, messageCount: llmHistory.length, systemPromptLength: systemPromptText.length }, '[agentRpc#getAgentConfig] Compaction decision')
         if (willCompact) {
             const model = aiUtils.createModel({
@@ -221,6 +222,7 @@ export const agentConfigRpc = (log: FastifyBaseLogger) => ({
                 existingSummary: compactionState.summary,
                 summarizedUpToIndex: compactionState.summarizedUpToIndex,
                 provider: providerConfig.provider,
+                reservedTokens: payloadReservedTokens,
                 model,
                 log,
             })
@@ -236,6 +238,7 @@ export const agentConfigRpc = (log: FastifyBaseLogger) => ({
             summary: compactionState.summary,
             summarizedUpToIndex: compactionState.summarizedUpToIndex,
             provider: providerConfig.provider,
+            reservedTokens: payloadReservedTokens,
         })
 
         log.info({
@@ -255,9 +258,9 @@ export const agentConfigRpc = (log: FastifyBaseLogger) => ({
             modelId: resolvedModelId,
             fastModelId,
             ...spreadIfDefined('imageModelId', imageModelId),
-            ...spreadIfDefined('searchCredentials', chosenProviders.search?.credentials),
-            ...spreadIfDefined('searchModelId', chosenProviders.search?.modelId),
-            ...spreadIfDefined('imageCredentials', chosenProviders.image?.credentials),
+            ...spreadIfDefined('searchCredentials', chosen.search?.credentials),
+            ...spreadIfDefined('searchModelId', chosen.search?.modelId),
+            ...spreadIfDefined('imageCredentials', chosen.image?.credentials),
             systemPrompt: systemPromptText,
             messages: messagesForLlm,
             allMessages,
@@ -278,60 +281,4 @@ export const agentConfigRpc = (log: FastifyBaseLogger) => ({
 
 })
 
-async function resolveChosenProviders({ platformId, choices, surface, scope, log }: { platformId: string, choices: AiProviderToolChoices, surface: ModelTierSurface, scope: ProviderScope, log: FastifyBaseLogger }): Promise<ChosenProviders> {
-    if (isNil(choices.webSearch) && isNil(choices.imageGeneration)) {
-        return { search: null, image: null }
-    }
-    const configs = await aiProviderService(log).listConfigs(platformId)
-    const [search, image] = await Promise.all([
-        resolveChosenProvider({ platformId, configs, choice: choices.webSearch, scope, log }).then((credentials) => withSearchModel({ platformId, credentials, surface, scope, log })),
-        resolveChosenProvider({ platformId, configs, choice: choices.imageGeneration, scope, log }).then((credentials) => withImageModel({ credentials, modelId: choices.imageGeneration?.modelId, log })),
-    ])
-    return { search, image }
-}
-
-async function withSearchModel({ platformId, credentials, surface, scope, log }: { platformId: string, credentials: GetProviderConfigResponse | null, surface: ModelTierSurface, scope: ProviderScope, log: FastifyBaseLogger }): Promise<ChosenProvider | null> {
-    if (isNil(credentials)) {
-        return null
-    }
-    const { data: modelId, error } = await tryCatch(() => agentHelpers.resolveFastModelId({ platformId, providerConfig: credentials, surface, scope, log }))
-    if (error) {
-        log.warn({ error, aiProvider: { id: credentials.configId } }, '[agentRpc#getAgentConfig] Chosen search provider has no usable model, using the chat provider')
-        return null
-    }
-    return { credentials, modelId }
-}
-
-function withImageModel({ credentials, modelId, log }: { credentials: GetProviderConfigResponse | null, modelId: string | undefined, log: FastifyBaseLogger }): ChosenProvider | null {
-    if (isNil(credentials) || isNil(modelId)) {
-        return null
-    }
-    const modelAllowed = credentials.modelScope !== 'selected' || credentials.modelIds.includes(modelId)
-    if (!modelAllowed) {
-        log.warn({ aiProvider: { id: credentials.configId } }, '[agentRpc#getAgentConfig] Chosen image model is no longer allowed on its key, using the chat provider')
-        return null
-    }
-    return { credentials, modelId }
-}
-
-async function resolveChosenProvider({ platformId, configs, choice, scope, log }: { platformId: string, configs: AIProviderWithoutSensitiveData[], choice: AiProviderToolConfig | undefined, scope: ProviderScope, log: FastifyBaseLogger }): Promise<GetProviderConfigResponse | null> {
-    const row = isNil(choice) ? undefined : configs.find((config) => config.id === choice.aiProviderId)
-    if (isNil(row)) {
-        return null
-    }
-    const { data, error } = await tryCatch(() => aiProviderService(log).getConfigOrThrow({ platformId, provider: row.provider, scope, configId: row.id }))
-    if (error) {
-        log.warn({ error, aiProvider: { id: row.id } }, '[agentRpc#getAgentConfig] Chosen AI provider cannot serve this run, using the chat provider')
-    }
-    return data ?? null
-}
-
-type ChosenProvider = {
-    credentials: GetProviderConfigResponse
-    modelId: string
-}
-
-type ChosenProviders = {
-    search: ChosenProvider | null
-    image: ChosenProvider | null
-}
+const TOOL_SCHEMA_TOKEN_ESTIMATE = 12_000
diff --git a/packages/server/api/src/app/ee/agent/rpc/chosen-providers.ts b/packages/server/api/src/app/ee/agent/rpc/chosen-providers.ts
new file mode 100644
index 000000000000..d209400b0007
--- /dev/null
+++ b/packages/server/api/src/app/ee/agent/rpc/chosen-providers.ts
@@ -0,0 +1,68 @@
+import { isNil, tryCatch } from '@activepieces/core-utils'
+import { ModelTierSurface } from '@activepieces/server-utils'
+import { AiProviderToolChoices, AiProviderToolConfig, AIProviderWithoutSensitiveData, GetProviderConfigResponse } from '@activepieces/shared'
+import { FastifyBaseLogger } from 'fastify'
+import { aiProviderService, ProviderScope } from '../../../ai/ai-provider-service'
+import { agentHelpers } from '../agent-helpers'
+
+async function resolveForRun({ platformId, choices, surface, scope, log }: { platformId: string, choices: AiProviderToolChoices, surface: ModelTierSurface, scope: ProviderScope, log: FastifyBaseLogger }): Promise<ChosenProviders> {
+    if (isNil(choices.webSearch) && isNil(choices.imageGeneration)) {
+        return { search: null, image: null }
+    }
+    const configs = await aiProviderService(log).listConfigs(platformId)
+    const [search, image] = await Promise.all([
+        keyCredentialsForRun({ platformId, configs, choice: choices.webSearch, scope, log }).then((credentials) => searchKeyWithFastModel({ platformId, credentials, surface, scope, log })),
+        keyCredentialsForRun({ platformId, configs, choice: choices.imageGeneration, scope, log }).then((credentials) => imageKeyIfModelAllowed({ credentials, modelId: choices.imageGeneration?.modelId, log })),
+    ])
+    return { search, image }
+}
+
+async function keyCredentialsForRun({ platformId, configs, choice, scope, log }: { platformId: string, configs: AIProviderWithoutSensitiveData[], choice: AiProviderToolConfig | undefined, scope: ProviderScope, log: FastifyBaseLogger }): Promise<GetProviderConfigResponse | null> {
+    const row = isNil(choice) ? undefined : configs.find((config) => config.id === choice.aiProviderId)
+    if (isNil(row)) {
+        return null
+    }
+    const { data, error } = await tryCatch(() => aiProviderService(log).getConfigOrThrow({ platformId, provider: row.provider, scope, configId: row.id }))
+    if (error) {
+        log.warn({ error, aiProvider: { id: row.id } }, '[chosenProviders#resolveForRun] Chosen AI provider cannot serve this run, using the chat provider')
+    }
+    return data ?? null
+}
+
+async function searchKeyWithFastModel({ platformId, credentials, surface, scope, log }: { platformId: string, credentials: GetProviderConfigResponse | null, surface: ModelTierSurface, scope: ProviderScope, log: FastifyBaseLogger }): Promise<ChosenProvider | null> {
+    if (isNil(credentials)) {
+        return null
+    }
+    const { data: modelId, error } = await tryCatch(() => agentHelpers.resolveFastModelId({ platformId, providerConfig: credentials, surface, scope, log }))
+    if (error) {
+        log.warn({ error, aiProvider: { id: credentials.configId } }, '[chosenProviders#resolveForRun] Chosen search provider has no usable model, using the chat provider')
+        return null
+    }
+    return { credentials, modelId }
+}
+
+function imageKeyIfModelAllowed({ credentials, modelId, log }: { credentials: GetProviderConfigResponse | null, modelId: string | undefined, log: FastifyBaseLogger }): ChosenProvider | null {
+    if (isNil(credentials) || isNil(modelId)) {
+        return null
+    }
+    const modelAllowed = credentials.modelScope !== 'selected' || credentials.modelIds.includes(modelId)
+    if (!modelAllowed) {
+        log.warn({ aiProvider: { id: credentials.configId } }, '[chosenProviders#resolveForRun] Chosen image model is no longer allowed on its key, using the chat provider')
+        return null
+    }
+    return { credentials, modelId }
+}
+
+export const chosenProviders = {
+    resolveForRun,
+}
+
+type ChosenProvider = {
+    credentials: GetProviderConfigResponse
+    modelId: string
+}
+
+type ChosenProviders = {
+    search: ChosenProvider | null
+    image: ChosenProvider | null
+}
diff --git a/packages/server/api/src/app/ee/agent/rpc/conversation-rpc.ts b/packages/server/api/src/app/ee/agent/rpc/conversation-rpc.ts
index 42aa6b448961..4bbc696d4584 100644
--- a/packages/server/api/src/app/ee/agent/rpc/conversation-rpc.ts
+++ b/packages/server/api/src/app/ee/agent/rpc/conversation-rpc.ts
@@ -1,5 +1,5 @@
 import { ActivepiecesError, ErrorCode, isNil, sanitizeObjectForPostgresql, spreadIfDefined } from '@activepieces/core-utils'
-import { AgentConversationStatus, AgentCreditsLeftRequest, AgentRunSource, FileCompression, FileType, HeartbeatAgentConversationRequest, ReadAgentFileRequest, ReadFlowStepFileResponse, SaveAgentFileRequest, SaveAgentFileResponse, SaveAgentMessagesRequest, UpdateAgentProgressRequest, UpdateProjectContextRequest } from '@activepieces/shared'
+import { AgentConversationStatus, AgentCreditsLeftRequest, AgentRunSource, FileCompression, FileType, HeartbeatAgentConversationRequest, PersistedAgentPartType, PersistedAgentRole, ReadAgentFileRequest, ReadFlowStepFileResponse, SaveAgentFileRequest, SaveAgentFileResponse, SaveAgentMessagesRequest, UpdateAgentProgressRequest, UpdateProjectContextRequest } from '@activepieces/shared'
 import { FastifyBaseLogger } from 'fastify'
 import { readConversationFile } from '.././agent-file-utils'
 import { agentHelpers } from '.././agent-helpers'
@@ -66,7 +66,8 @@ export const conversationRpc = (log: FastifyBaseLogger) => ({
         // that case — keep the richer history that updateAgentProgress persisted incrementally. The
         // status still reflects success/error so the UI is correct; only the destructive content
         // overwrite is suppressed. (uiMessages tracks messages, so we gate both on the same check.)
-        const storedMessageCount = ((await agentHelpers.conversationRepo().findOneBy({ id: input.conversationId }))?.messages as unknown[] | undefined)?.length ?? 0
+        const stored = await agentHelpers.conversationRepo().findOneBy({ id: input.conversationId })
+        const storedMessageCount = stored?.messages.length ?? 0
         const wouldShrinkHistory = input.messages.length < storedMessageCount
         const persistContent = isSuccessfulCompletion && !wouldShrinkHistory
 
@@ -76,7 +77,14 @@ export const conversationRpc = (log: FastifyBaseLogger) => ({
             if (input.title) updates.title = input.title
             if (input.modelName) updates.modelName = input.modelName
         }
-        else if (wouldShrinkHistory) {
+        const failureAppend = isNil(input.failure) ? null : failureAppendFor({ stored: stored?.uiMessages ?? [], failure: input.failure })
+        if (!isNil(failureAppend)) {
+            updates.uiMessages = () => 'coalesce("uiMessages", \'[]\'::jsonb) || :failureUiMessages::jsonb'
+            if (failureAppend.modelMessages.length > 0) {
+                updates.messages = () => 'coalesce("messages", \'[]\'::jsonb) || :failureModelMessages::jsonb'
+            }
+        }
+        if (wouldShrinkHistory) {
             log.warn({
                 conversation: { id: input.conversationId },
                 run: { id: input.runId },
@@ -85,7 +93,15 @@ export const conversationRpc = (log: FastifyBaseLogger) => ({
             }, '[agentRpc#saveAgentMessages] Refused shrinking save — kept incrementally-persisted history')
         }
 
-        const saveLanded = await updateConversationForRun({ conversationId: input.conversationId, runId: input.runId, updates })
+        const saveLanded = await updateConversationForRun({
+            conversationId: input.conversationId,
+            runId: input.runId,
+            updates,
+            ...spreadIfDefined('parameters', isNil(failureAppend) ? undefined : {
+                failureUiMessages: JSON.stringify(sanitizeObjectForPostgresql(failureAppend.uiMessages)),
+                failureModelMessages: JSON.stringify(sanitizeObjectForPostgresql(failureAppend.modelMessages)),
+            }),
+        })
         if (!saveLanded) {
             log.warn({ conversation: { id: input.conversationId }, run: { id: input.runId } }, 'saveAgentMessages: no row updated — conversation deleted or superseded by a newer run; skipping analytics and usage tracking')
         }
@@ -114,7 +130,7 @@ export const conversationRpc = (log: FastifyBaseLogger) => ({
         if (!isNil(input.messages)) {
             updates.messages = input.messages
         }
-        await updateConversationForRun({ conversationId: input.conversationId, runId: input.runId, updates })
+        await updateConversationForRun({ conversationId: input.conversationId, runId: input.runId, updates, onlyWhileStreaming: true })
         log.debug({ conversation: { id: input.conversationId }, uiMessageCount: input.uiMessages.length, messageCount: input.messages?.length }, '[agentRpc#updateAgentProgress] Progress persisted')
     },
 
@@ -161,3 +177,26 @@ export const conversationRpc = (log: FastifyBaseLogger) => ({
     },
 
 })
+
+function isObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && !isNil(value)
+}
+
+function failureAppendFor({ stored, failure }: { stored: unknown[], failure: { message: string, userMessage?: string } }): FailureAppend {
+    const lastStored = stored.at(-1)
+    const endsWithThisUserMessage = isObject(lastStored) && lastStored.role === PersistedAgentRole.USER
+    const restoresUserTurn = !isNil(failure.userMessage) && !endsWithThisUserMessage
+    const userTurn = restoresUserTurn
+        ? [{ role: PersistedAgentRole.USER, parts: [{ type: PersistedAgentPartType.TEXT, text: failure.userMessage }] }]
+        : []
+    const failureReply = { role: PersistedAgentRole.ASSISTANT, parts: [{ type: PersistedAgentPartType.TEXT, text: failure.message }] }
+    return {
+        uiMessages: [...userTurn, failureReply],
+        modelMessages: restoresUserTurn ? [{ role: 'user', content: failure.userMessage }] : [],
+    }
+}
+
+type FailureAppend = {
+    uiMessages: unknown[]
+    modelMessages: unknown[]
+}
diff --git a/packages/server/api/src/app/ee/agent/rpc/rpc-shared.ts b/packages/server/api/src/app/ee/agent/rpc/rpc-shared.ts
index 83ef9284469e..b4bbe731efcc 100644
--- a/packages/server/api/src/app/ee/agent/rpc/rpc-shared.ts
+++ b/packages/server/api/src/app/ee/agent/rpc/rpc-shared.ts
@@ -16,19 +16,27 @@ import { mcpUtils } from '../../../mcp/tools/mcp-utils'
 // Gate the UPDATE on the persisted owning run (activeRunId, claimed at turn start) so a run
 // preempted by a newer message matches zero rows — the ownership check is part of the write, with
 // no check-then-write window. A nil runId or unclaimed row (activeRunId IS NULL) writes freely.
-export async function updateConversationForRun({ conversationId, runId, updates }: {
+export async function updateConversationForRun({ conversationId, runId, updates, parameters, onlyWhileStreaming }: {
     conversationId: string
     runId?: string
     updates: Record<string, unknown>
+    parameters?: Record<string, unknown>
+    onlyWhileStreaming?: boolean
 }): Promise<boolean> {
     const builder = agentHelpers.conversationRepo()
         .createQueryBuilder()
         .update()
         .set(updates)
         .where('id = :id', { id: conversationId })
+    if (!isNil(parameters)) {
+        builder.setParameters(parameters)
+    }
     if (!isNil(runId)) {
         builder.andWhere('("activeRunId" IS NULL OR "activeRunId" = :runId)', { runId })
     }
+    if (onlyWhileStreaming === true) {
+        builder.andWhere('status = :streamingStatus', { streamingStatus: AgentConversationStatus.STREAMING })
+    }
     const result = await builder.returning('id').execute()
     const updatedRows: unknown[] = result.raw ?? []
     return updatedRows.length > 0
diff --git a/packages/server/api/src/assets/prompts/chat-system-prompt.md b/packages/server/api/src/assets/prompts/chat-system-prompt.md
index fad24e413d99..905a718a3d57 100644
--- a/packages/server/api/src/assets/prompts/chat-system-prompt.md
+++ b/packages/server/api/src/assets/prompts/chat-system-prompt.md
@@ -326,7 +326,7 @@ Every request starts with `<discovery>` — understand WHAT and WHY first.
 
 **One-time vs recurring — read the signal, don't default to recurring.** A one-time task and a scheduled automation are different builds; misreading the cadence wastes the whole turn. Decide from the wording:
 - **One-time** (→ `one_time_task`): an imperative to act *now* on data that already exists — "categorize *these* tickets", "send *this* now", "check my inbox", "score the rows in my sheet". No recurrence cue → treat as one-time.
-- **Recurring** (→ `<automation_build>`): an explicit ongoing/triggered cue — "when/whenever/each time/every new …", "every day/hour", "on a schedule", "from now on".
+- **Recurring** (→ `<automation_build>`): an explicit ongoing/triggered cue — "when/whenever/each time/every new …", "every day/hour", "on a schedule", "from now on", or the words "workflow", "automation", "monitor", "keep track of" used for something ongoing (an imperative to act once, like "track down this issue now", is still one-time). Build a flow for these; never answer with a one-off `ap_run_code` / `ap_web_search` or the showcase instead.
 - Only when the cadence is genuinely ambiguous, ask the single binary business question ("Run this once, or every time?") via `ap_show_questions` — never guess recurring. (Converting a one-time task into a recurring one later: `build_flow.md` → "Converting a one-time task".)
 - **Once it's recurring, guarantee it won't reprocess.** A recurring flow that reads data which persists between runs (a sheet, a table, an inbox, a record set) sees the SAME data again on the next run — so during discovery you MUST settle *what makes run N+1 skip what run N already handled*: a "new item"/dedup trigger instead of read-all, a processed-flag filter, delete/archive-after, or a stored high-water mark. Treating a recurring job as if it runs once — read-all → act → done, with no such mechanism — is the #1 silent logic bug (e.g. a weekly "summarize hours and tell me who to pay" that re-pays everyone every week because nobody was marked paid). This shapes the trigger and steps, so decide it now, not after building; the mechanisms are in `build_flow.md` → "Recurring flows must not reprocess".
 
@@ -350,7 +350,7 @@ This applies ONLY to deliverables the user asked you to produce. Normal conversa
 1. **DISCOVER** — follow `<discovery>`: understand the goal, then INFER the business logic from context (their company/domain, their data via `ap_explore_data`, market practice). Don't ask the user to supply categories, routing, or thresholds. If it's recurring and reads persistent data, also settle how run N+1 avoids reprocessing run N's data (see `<decision_framework>`) — a build-shaping decision, not an afterthought.
 2. **RESEARCH (the 2-call happy path)** — `ap_research_pieces({pieceNames:[app], forIntent:"<what you're doing>"})` for the apps involved (missing app → `http_fallback`); read the returned `recommendedActions` + each action's AI hint to pick the right action in one shot. Then call `ap_get_piece_props({pieceName, actionName, auth})` ONCE with the connection — this resolves the dropdowns/dynamic sub-fields AND returns `requiredInputs` + a ready-to-run `exampleInput`. Don't call `ap_resolve_property_options` separately when that one `ap_get_piece_props(auth)` call already resolved the field. Fill the example, then execute.
 3. **HANDOFF** — write a one-line recap of what you'll build and go. Make sure each app has a connection the user selected (`ap_show_connection_picker`/`ap_show_connection_required`). Pick sensible context-grounded defaults for every open choice; only show a choice-only `ap_show_questions` for a single make-or-break business choice you truly can't infer. No separate approval step, no upfront questionnaire.
-4. **BUILD** — `ap_set_phase('build')`, publish the live build plan with `ap_set_build_plan` (`phase: 'detecting'`, all steps `pending`), load `build_flow`, and execute it — keep the plan updated as you go and finish it with `phase: 'done'` + `flowId`. A short real-text line between build phases is welcome to keep the user in the loop (e.g. "Connections are set — wiring up the steps now"), but keep it light: the build card carries the detailed play-by-play, so don't narrate every step. When all steps are done and the link is shared, deliver the closing brief: what you built, the assumptions you made (each editable), and the obvious next improvements.
+4. **BUILD** — `ap_set_phase('build')`, publish the live build plan with `ap_set_build_plan` (`phase: 'detecting'`, all steps `pending`), load `build_flow`, and execute it — keep the plan updated as you go and finish it with `phase: 'done'` + `flowId`. A short real-text line between build phases is welcome to keep the user in the loop (e.g. "Connections are set — wiring up the steps now"), but keep it light: the build card carries the detailed play-by-play, so don't narrate every step. When all steps are done and the link is shared, deliver the closing brief: what you built, the assumptions you made (each editable), and the obvious next improvements. Chat never publishes on its own: end every validated flow with one "Turn it on?" quick-reply card, and only a yes calls `ap_lock_and_publish` (see `build_flow` → "Turn it on?"). Never end on "open it to review", and never call a flow you just built live, running or active unless publish succeeded for it (for other flows, report the status the tools show).
 </automation_build>
 
 <links>
diff --git a/packages/server/api/src/assets/prompts/guides/build_flow.md b/packages/server/api/src/assets/prompts/guides/build_flow.md
index bc032855e2b9..ac2cb0f61e9a 100644
--- a/packages/server/api/src/assets/prompts/guides/build_flow.md
+++ b/packages/server/api/src/assets/prompts/guides/build_flow.md
@@ -111,7 +111,11 @@ Wire the **specific fields** a step consumes, never an entire upstream output. A
 - **Simple flows** (linear, no branches/loops): `ap_build_flow` → validate every step (below) → test for real with cases (below) → reflect (below) → `ap_manage_notes`.
 - **Flows with loops**: `ap_build_flow` supports nesting. For steps inside a loop, set `parentStepName` to the loop step's name and `stepLocationRelativeToParent` to `INSIDE_LOOP`. Steps that omit `parentStepName` are placed after the last top-level step (not inside the loop).
 - **Complex flows** (branches, routers, many steps): `ap_create_flow` → configure trigger → validate → for each action: `ap_add_step` → validate → test for real with cases (below) → reflect → `ap_manage_notes`.
-- Share the flow link. The flow is a draft — do NOT auto-publish.
+- Share the flow link, then finish per "Turn it on?" below. Never auto-publish, and never leave a validated flow ending on "open it to review".
+
+## Turn it on? — the one way every built flow ends
+Chat NEVER publishes on its own. A flow only runs once published, so once it validates (and passes its test, when a test ran), end with exactly one `ap_show_quick_replies` (or `ap_show_questions`) card: "Turn it on?" with chips like "Turn it on" / "Not yet". Only a yes publishes: call `ap_lock_and_publish({flowId})` right away, then say it is live. "Not yet" leaves it a draft.
+**Never say a flow you just built is live, running, active or turned on unless `ap_lock_and_publish` succeeded for it.** If publish returned an error, say so and fix it. Until then call it "a draft, not running yet". For a flow you did not just build, report the status the tools show (`ap_list_flows` shows it), never a guess.
 
 **After `ap_build_flow`** it creates the skeleton but does NOT validate configs or field mappings. You MUST: (1) `ap_validate_step_config` on the trigger and each step, (2) fix any errors with `ap_update_step`/`ap_update_trigger`, (3) `ap_validate_flow` to confirm all steps are valid.
 
diff --git a/packages/server/api/test/integration/cloud/agent/agent-resend-race.test.ts b/packages/server/api/test/integration/cloud/agent/agent-resend-race.test.ts
new file mode 100644
index 000000000000..4154973d78b7
--- /dev/null
+++ b/packages/server/api/test/integration/cloud/agent/agent-resend-race.test.ts
@@ -0,0 +1,47 @@
+import { AgentConversationStatus } from '@activepieces/shared'
+import { FastifyInstance } from 'fastify'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { agentHelpers } from '../../../../src/app/ee/agent/agent-helpers'
+import { db } from '../../../helpers/db'
+import { createTestContext } from '../../../helpers/test-context'
+import { setupTestEnvironment, teardownTestEnvironment } from '../../../helpers/test-setup'
+
+let app: FastifyInstance
+
+beforeAll(async () => {
+    app = await setupTestEnvironment()
+})
+
+afterAll(async () => {
+    await teardownTestEnvironment()
+})
+
+describe('re-sending a message while the first run has not started yet', () => {
+    it('lets the newer run start and turns the older run away without a busy rejection', async () => {
+        const ctx = await createTestContext(app, { plan: { chatEnabled: true } })
+        const created = await ctx.post('/v1/agents/conversations', { title: 'Resend' })
+        const conversationId = created.json().id
+
+        await agentHelpers.claimConversationForRun({ conversationId, runId: 'run-1' })
+        await agentHelpers.claimConversationForRun({ conversationId, runId: 'run-2' })
+
+        const older = await agentHelpers.acquireStreamingLock({ conversationId, runId: 'run-1' })
+        const newer = await agentHelpers.acquireStreamingLock({ conversationId, runId: 'run-2' })
+
+        expect(older).toBe('superseded')
+        expect(newer).toBe('acquired')
+        const stored = await db.findOneByOrFail<{ status: string, activeRunId: string }>('agent_conversation', { id: conversationId })
+        expect(stored.status).toBe(AgentConversationStatus.STREAMING)
+        expect(stored.activeRunId).toBe('run-2')
+    })
+
+    it('still reports busy when the same run finds the conversation already streaming', async () => {
+        const ctx = await createTestContext(app, { plan: { chatEnabled: true } })
+        const created = await ctx.post('/v1/agents/conversations', { title: 'Busy' })
+        const conversationId = created.json().id
+        await agentHelpers.claimConversationForRun({ conversationId, runId: 'run-1' })
+
+        expect(await agentHelpers.acquireStreamingLock({ conversationId, runId: 'run-1' })).toBe('acquired')
+        expect(await agentHelpers.acquireStreamingLock({ conversationId, runId: 'run-1' })).toBe('busy')
+    })
+})
diff --git a/packages/server/api/test/integration/ee/agent/agent-controller.test.ts b/packages/server/api/test/integration/ee/agent/agent-controller.test.ts
index 1d1ff6547f28..2033c56d76a1 100644
--- a/packages/server/api/test/integration/ee/agent/agent-controller.test.ts
+++ b/packages/server/api/test/integration/ee/agent/agent-controller.test.ts
@@ -71,6 +71,22 @@ describe('agent crud', () => {
         expect(agent.draft.provider).toBe(AIProviderName.OPENROUTER)
     })
 
+    it('fills in the default tier id, not the model behind it, when the platform runs on Activepieces credits', async () => {
+        process.env.AP_OPENROUTER_PROVISION_KEY = 'test-provision-key'
+        try {
+            const ctx = await context()
+            await mockAndSaveAIProvider({ platformId: ctx.platform.id, provider: AIProviderName.ACTIVEPIECES, enabledForChat: true })
+
+            const agent = await createAgent(ctx)
+
+            expect(agent.draft.modelName).toBe('smart')
+            expect(agent.draft.provider).toBe(AIProviderName.ACTIVEPIECES)
+        }
+        finally {
+            delete process.env.AP_OPENROUTER_PROVISION_KEY
+        }
+    })
+
     it('keeps a model the request did name, even where a default was available', async () => {
         const ctx = await context()
         await mockAndSaveAIProvider({ platformId: ctx.platform.id, provider: AIProviderName.OPENROUTER, enabledForChat: true })
diff --git a/packages/server/api/test/unit/app/agent/agent-compaction.test.ts b/packages/server/api/test/unit/app/agent/agent-compaction.test.ts
index 98e135449136..38fd7293c23f 100644
--- a/packages/server/api/test/unit/app/agent/agent-compaction.test.ts
+++ b/packages/server/api/test/unit/app/agent/agent-compaction.test.ts
@@ -1,8 +1,18 @@
 import { AIProviderName, ErrorCode } from '@activepieces/core-utils'
-import { ModelMessage } from 'ai'
-import { describe, expect, it } from 'vitest'
+import { generateText, ModelMessage } from 'ai'
+import { MockLanguageModelV3 } from 'ai/test'
+import Fastify from 'fastify'
+import { describe, expect, it, vi } from 'vitest'
 import { agentCompaction } from '../../../../src/app/ee/agent/agent-compaction'
 
+vi.mock('ai', async (importOriginal) => ({
+    ...(await importOriginal<Record<string, unknown>>()),
+    generateText: vi.fn().mockResolvedValue({ text: 'summary' }),
+}))
+
+const summaryModel = new MockLanguageModelV3()
+const silentLog = Fastify({ logger: false }).log
+
 function makeMessages(count: number, charsPer = 100): ModelMessage[] {
     return Array.from({ length: count }, (_, i) => ({
         role: i % 2 === 0 ? 'user' as const : 'assistant' as const,
@@ -36,6 +46,7 @@ describe('agentCompaction.shouldCompact', () => {
         const result = agentCompaction.shouldCompact({
             estimatedTokens: 999_999,
             provider: AIProviderName.ANTHROPIC,
+            reservedTokens: 0,
             messageCount: 5,
         })
         expect(result).toBe(false)
@@ -46,6 +57,7 @@ describe('agentCompaction.shouldCompact', () => {
         const result = agentCompaction.shouldCompact({
             estimatedTokens: 100_000,
             provider: AIProviderName.ANTHROPIC,
+            reservedTokens: 0,
             messageCount: 20,
         })
         expect(result).toBe(false)
@@ -56,6 +68,7 @@ describe('agentCompaction.shouldCompact', () => {
         const result = agentCompaction.shouldCompact({
             estimatedTokens: 150_000,
             provider: AIProviderName.ANTHROPIC,
+            reservedTokens: 0,
             messageCount: 20,
         })
         expect(result).toBe(true)
@@ -66,6 +79,7 @@ describe('agentCompaction.shouldCompact', () => {
         const result = agentCompaction.shouldCompact({
             estimatedTokens: 150_000,
             provider: AIProviderName.GOOGLE,
+            reservedTokens: 0,
             messageCount: 20,
         })
         expect(result).toBe(false)
@@ -80,6 +94,7 @@ describe('agentCompaction.buildCompactedPayload', () => {
             summary: null,
             summarizedUpToIndex: null,
             provider: AIProviderName.ANTHROPIC,
+            reservedTokens: 0,
         })
         expect(result).toBe(messages)
     })
@@ -91,6 +106,7 @@ describe('agentCompaction.buildCompactedPayload', () => {
             summary: 'User discussed flow creation.',
             summarizedUpToIndex: 7,
             provider: AIProviderName.ANTHROPIC,
+            reservedTokens: 0,
         })
 
         expect(result.length).toBe(4) // 1 summary + 3 recent (index 7,8,9)
@@ -115,6 +131,7 @@ describe('agentCompaction.buildCompactedPayload', () => {
             summary: 'Short summary.',
             summarizedUpToIndex: 5,
             provider: AIProviderName.ANTHROPIC,
+            reservedTokens: 0,
         })
 
         // Should have trimmed some recent messages
@@ -134,6 +151,7 @@ describe('agentCompaction.buildCompactedPayload', () => {
             summary: 'Summary',
             summarizedUpToIndex: 0,
             provider: AIProviderName.ANTHROPIC,
+            reservedTokens: 0,
         })).toThrow(expect.objectContaining({
             error: expect.objectContaining({
                 code: ErrorCode.CHAT_CONTEXT_LIMIT_EXCEEDED,
@@ -159,6 +177,7 @@ describe('agentCompaction.buildCompactedPayload', () => {
             summary: 'Summary of earlier messages.',
             summarizedUpToIndex: 4,
             provider: AIProviderName.ANTHROPIC,
+            reservedTokens: 0,
         })
 
         // First message should be summary, second should NOT be a tool message
@@ -177,9 +196,119 @@ describe('agentCompaction.buildCompactedPayload', () => {
             summary: 'Brief summary.',
             summarizedUpToIndex: 15,
             provider: AIProviderName.ANTHROPIC,
+            reservedTokens: 0,
         })
 
         // 1 summary + 5 recent messages (index 15-19)
         expect(result.length).toBe(6)
     })
 })
+
+describe('agentCompaction with reserved tokens', () => {
+    const RESERVED_TOKENS = 11_872 + 52_000
+
+    it('compacts a history that fits the window only if output and tool schemas were free', () => {
+        expect(agentCompaction.shouldCompact({
+            estimatedTokens: 110_000,
+            provider: AIProviderName.ANTHROPIC,
+            messageCount: 20,
+            reservedTokens: RESERVED_TOKENS,
+        })).toBe(true)
+    })
+
+    it('keeps the payload plus reserved tokens inside the context window', () => {
+        const messages: ModelMessage[] = Array.from({ length: 12 }, (_, i) => ({
+            role: i % 2 === 0 ? 'user' as const : 'assistant' as const,
+            content: 'x'.repeat(78_000),
+        }))
+        const result = agentCompaction.buildCompactedPayload({
+            messages,
+            summary: 'summary',
+            summarizedUpToIndex: 0,
+            provider: AIProviderName.ANTHROPIC,
+            reservedTokens: RESERVED_TOKENS,
+        })
+        const payloadTokens = Math.ceil(JSON.stringify(result).length / 4)
+        expect(payloadTokens + RESERVED_TOKENS).toBeLessThanOrEqual(200_000)
+    })
+
+    it('sizes the recent window by tokens, so a few huge messages are summarized', async () => {
+        const messages: ModelMessage[] = Array.from({ length: 12 }, (_, i) => ({
+            role: i % 2 === 0 ? 'user' as const : 'assistant' as const,
+            content: 'x'.repeat(78_000),
+        }))
+        const result = await agentCompaction.compactMessages({
+            messages,
+            existingSummary: null,
+            summarizedUpToIndex: null,
+            provider: AIProviderName.ANTHROPIC,
+            reservedTokens: RESERVED_TOKENS,
+            model: summaryModel,
+            log: silentLog,
+        })
+        expect(result.summarizedUpToIndex).toBeGreaterThanOrEqual(8)
+    })
+
+    it('bounds the summary request so oversized documents cannot overflow it', async () => {
+        const messages: ModelMessage[] = Array.from({ length: 12 }, (_, i) => ({
+            role: i % 2 === 0 ? 'user' as const : 'assistant' as const,
+            content: 'x'.repeat(500_000),
+        }))
+        await agentCompaction.compactMessages({
+            messages,
+            existingSummary: null,
+            summarizedUpToIndex: null,
+            provider: AIProviderName.ANTHROPIC,
+            reservedTokens: RESERVED_TOKENS,
+            model: summaryModel,
+            log: silentLog,
+        })
+        const request = vi.mocked(generateText).mock.calls.at(-1)?.[0]
+        expect(String(request?.prompt).length / 4 + 4_000).toBeLessThan(200_000)
+    })
+
+    it('counts non-Latin text as a token per character, so a long Chinese document cannot overflow the summarizer', async () => {
+        const messages: ModelMessage[] = [
+            { role: 'user', content: '工作流'.repeat(60_000) },
+            ...Array.from({ length: 19 }, (_, i) => ({
+                role: i % 2 === 0 ? 'assistant' as const : 'user' as const,
+                content: i % 2 === 0 ? 'Noted.' : 'x'.repeat(29_000),
+            })),
+        ]
+        await agentCompaction.compactMessages({
+            messages,
+            existingSummary: null,
+            summarizedUpToIndex: null,
+            provider: AIProviderName.OPENROUTER,
+            reservedTokens: 66_000,
+            model: summaryModel,
+            log: silentLog,
+        })
+        const prompt = String(vi.mocked(generateText).mock.calls.at(-1)?.[0]?.prompt)
+        const chineseChars = [...prompt].filter((char) => char.charCodeAt(0) >= 128).length
+        const latinChars = [...prompt].length - chineseChars
+        expect(chineseChars + latinChars / 4).toBeLessThan(128_000 - 4_000)
+    })
+
+    it('keeps a long document whole in the summary request when the whole request fits', async () => {
+        const documentText = `START ${'d'.repeat(66_000)} THE-LAST-DETAIL`
+        const messages: ModelMessage[] = [
+            { role: 'user', content: documentText },
+            ...Array.from({ length: 19 }, (_, i) => ({
+                role: i % 2 === 0 ? 'assistant' as const : 'user' as const,
+                content: i % 2 === 0 ? 'Noted.' : 'x'.repeat(29_000),
+            })),
+        ]
+        await agentCompaction.compactMessages({
+            messages,
+            existingSummary: null,
+            summarizedUpToIndex: null,
+            provider: AIProviderName.OPENROUTER,
+            reservedTokens: 66_000,
+            model: summaryModel,
+            log: silentLog,
+        })
+        const request = vi.mocked(generateText).mock.calls.at(-1)?.[0]
+        expect(String(request?.prompt)).toContain('THE-LAST-DETAIL')
+    })
+})
diff --git a/packages/server/api/test/unit/app/ee/agent/agent-model-resolution.test.ts b/packages/server/api/test/unit/app/ee/agent/agent-model-resolution.test.ts
index 88a4b08961ca..cd1af713e699 100644
--- a/packages/server/api/test/unit/app/ee/agent/agent-model-resolution.test.ts
+++ b/packages/server/api/test/unit/app/ee/agent/agent-model-resolution.test.ts
@@ -226,6 +226,31 @@ describe('defaultModelIdForProvider', () => {
     })
 })
 
+describe('resolveRunTier', () => {
+    const runTier = ({ provider = AIProviderName.ACTIVEPIECES, modelName, surface = 'flow' }: { provider?: AIProviderName, modelName: string | null, surface?: ModelTierSurface }) =>
+        agentModelResolution.resolveRunTier({ provider, modelName, selectedModel: modelName, surface })
+
+    it('gives a run that names a managed tier that tier, so Heavy thinks on its own budget rather than the default one', () => {
+        expect(runTier({ modelName: 'premium' })).toMatchObject({ id: 'premium', thinkingBudget: 20_000 })
+        expect(runTier({ modelName: 'deep' })).toMatchObject({ id: 'deep', modelId: 'anthropic/claude-fable-5.1' })
+    })
+
+    it('keeps the default tier for a concrete model id, a tier the file no longer carries, or no model at all', () => {
+        expect(runTier({ modelName: 'anthropic/claude-opus-4.8' }).id).toBe('smart')
+        expect(runTier({ modelName: 'tier-9' }).id).toBe('smart')
+        expect(runTier({ modelName: null }).id).toBe('smart')
+    })
+
+    it('never reads an own-key deployment named like a tier as that tier', () => {
+        expect(runTier({ provider: AIProviderName.AZURE, modelName: 'premium' }).id).toBe('smart')
+    })
+
+    it('resolves the chat pick on the chat list', () => {
+        expect(runTier({ modelName: 'smart', surface: 'chat' }).modelId).toBe('google/gemini-3.7-flash')
+        expect(runTier({ modelName: 'turbo', surface: 'chat' }).id).toBe('turbo')
+    })
+})
+
 describe('resolveNamedModelId', () => {
     beforeEach(() => {
         warn.mockClear()
diff --git a/packages/server/api/test/unit/app/ee/agent/agent-rpc-handlers.test.ts b/packages/server/api/test/unit/app/ee/agent/agent-rpc-handlers.test.ts
index 5e3dd033fac0..ca937f6c8ccc 100644
--- a/packages/server/api/test/unit/app/ee/agent/agent-rpc-handlers.test.ts
+++ b/packages/server/api/test/unit/app/ee/agent/agent-rpc-handlers.test.ts
@@ -14,9 +14,10 @@ vi.mock('../../../../../src/app/waitpoints/resume-service', () => ({
     resumeService: () => ({ resumeFromWaitpoint: mockResumeFromWaitpoint }),
 }))
 
-const { mockSet, mockWhere, mockAndWhere, mockExecute, mockFindOneBy, mockFindOne, mockSave, mockTrack, mockSendConversationUpdate } = vi.hoisted(() => ({
+const { mockSet, mockSetParameters, mockWhere, mockAndWhere, mockExecute, mockFindOneBy, mockFindOne, mockSave, mockTrack, mockSendConversationUpdate } = vi.hoisted(() => ({
     mockSave: vi.fn(),
     mockSet: vi.fn(),
+    mockSetParameters: vi.fn(),
     mockWhere: vi.fn(),
     mockAndWhere: vi.fn(),
     mockExecute: vi.fn().mockResolvedValue({ raw: [{ id: 'conv-1' }] }),
@@ -102,6 +103,7 @@ vi.mock('@activepieces/server-utils', async (importOriginal) => ({
 type QueryBuilderMock = {
     update: () => QueryBuilderMock
     set: (values: unknown) => QueryBuilderMock
+    setParameters: (params: unknown) => QueryBuilderMock
     where: (sql: string, params: unknown) => QueryBuilderMock
     andWhere: (sql: string, params: unknown) => QueryBuilderMock
     returning: (columns: string) => QueryBuilderMock
@@ -122,6 +124,7 @@ vi.mock('../../../../../src/app/ee/agent/agent-helpers', () => ({
                 const builder: QueryBuilderMock = {
                     update: () => builder,
                     set: (values) => { mockSet(values); return builder },
+                    setParameters: (params) => { mockSetParameters(params); return builder },
                     where: (_sql, params) => { mockWhere(params); return builder },
                     andWhere: (_sql, params) => { mockAndWhere(params); return builder },
                     returning: () => builder,
@@ -796,3 +799,55 @@ describe('agentRpcHandlers.executePieceTool — which account a configured actio
         expect(call.connectionExternalId).toBeUndefined()
     })
 })
+
+describe('agentRpcHandlers.saveAgentMessages: a failed turn leaves a visible reply', () => {
+    beforeEach(() => {
+        mockSet.mockClear()
+        mockSetParameters.mockClear()
+        mockAndWhere.mockClear()
+        mockFindOneBy.mockReset()
+    })
+
+    it('appends the failure and restores a user message that never got stored, in the transcript and the model context', async () => {
+        mockFindOneBy.mockResolvedValue({ messages: [], uiMessages: [] })
+
+        await agentRpcHandlers(noopLogger as never).saveAgentMessages({
+            conversationId: 'conv-1', runId: 'run-1', messages: [], uiMessages: [],
+            failure: { message: 'provider is down', userMessage: 'Do my hiring' },
+        } as never)
+
+        const updates = mockSet.mock.calls[0][0]
+        const params = mockSetParameters.mock.calls[0][0]
+        expect(updates.status).toBe('ERROR')
+        expect(typeof updates.uiMessages).toBe('function')
+        expect(typeof updates.messages).toBe('function')
+        expect(JSON.parse(params.failureUiMessages)).toEqual([
+            { role: 'user', parts: [{ type: 'text', text: 'Do my hiring' }] },
+            { role: 'assistant', parts: [{ type: 'text', text: 'provider is down' }] },
+        ])
+        expect(JSON.parse(params.failureModelMessages)).toEqual([{ role: 'user', content: 'Do my hiring' }])
+    })
+
+    it('appends only the failure reply when the user message is already the last stored one', async () => {
+        const storedUser = { role: 'user', parts: [{ type: 'text', text: 'Do my hiring' }] }
+        mockFindOneBy.mockResolvedValue({ messages: [{ role: 'user' }], uiMessages: [storedUser] })
+
+        await agentRpcHandlers(noopLogger as never).saveAgentMessages({
+            conversationId: 'conv-1', runId: 'run-1', messages: [], uiMessages: [],
+            failure: { message: 'boom', userMessage: 'Do my hiring' },
+        } as never)
+
+        expect(mockSet.mock.calls[0][0].messages).toBeUndefined()
+        expect(JSON.parse(mockSetParameters.mock.calls[0][0].failureUiMessages)).toEqual([
+            { role: 'assistant', parts: [{ type: 'text', text: 'boom' }] },
+        ])
+    })
+
+    it('only saves progress while the turn is still streaming, so a late progress save cannot wipe the failure reply', async () => {
+        await agentRpcHandlers(noopLogger as never).updateAgentProgress({
+            conversationId: 'conv-1', runId: 'run-1', uiMessages: [],
+        } as never)
+
+        expect(mockAndWhere).toHaveBeenCalledWith({ streamingStatus: 'STREAMING' })
+    })
+})
diff --git a/packages/server/api/test/unit/app/ee/agent/chosen-providers.test.ts b/packages/server/api/test/unit/app/ee/agent/chosen-providers.test.ts
new file mode 100644
index 000000000000..883f43e4a2df
--- /dev/null
+++ b/packages/server/api/test/unit/app/ee/agent/chosen-providers.test.ts
@@ -0,0 +1,105 @@
+import { AIProviderName } from '@activepieces/core-utils'
+import { GetProviderConfigResponse } from '@activepieces/shared'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockListConfigs, mockGetConfigOrThrow, mockResolveFastModelId } = vi.hoisted(() => ({
+    mockListConfigs: vi.fn(),
+    mockGetConfigOrThrow: vi.fn(),
+    mockResolveFastModelId: vi.fn(),
+}))
+
+vi.mock('../../../../../src/app/ai/ai-provider-service', () => ({
+    aiProviderService: () => ({
+        listConfigs: mockListConfigs,
+        getConfigOrThrow: mockGetConfigOrThrow,
+    }),
+}))
+
+vi.mock('../../../../../src/app/ee/agent/agent-helpers', () => ({
+    agentHelpers: { resolveFastModelId: mockResolveFastModelId },
+}))
+
+const { chosenProviders } = await import('../../../../../src/app/ee/agent/rpc/chosen-providers')
+
+const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() } as never
+const platformId = 'platform-1'
+const scope = { type: 'project', projectId: 'project-1' } as const
+
+function credentialsFor({ modelScope, modelIds }: { modelScope: 'all' | 'selected', modelIds: string[] }): GetProviderConfigResponse {
+    return { provider: AIProviderName.GOOGLE, configId: 'key-1', platformId, auth: { apiKey: 'k' }, config: {}, modelScope, modelIds }
+}
+
+describe('chosenProviders.resolveForRun', () => {
+    beforeEach(() => {
+        mockListConfigs.mockReset().mockResolvedValue([{ id: 'key-1', provider: AIProviderName.GOOGLE }])
+        mockGetConfigOrThrow.mockReset().mockResolvedValue(credentialsFor({ modelScope: 'all', modelIds: [] }))
+        mockResolveFastModelId.mockReset().mockResolvedValue('gemini-2.5-flash')
+    })
+
+    it('skips every lookup when nothing was chosen', async () => {
+        const chosen = await chosenProviders.resolveForRun({ platformId, choices: {}, surface: 'chat', scope, log })
+
+        expect(chosen).toEqual({ search: null, image: null })
+        expect(mockListConfigs).not.toHaveBeenCalled()
+    })
+
+    it('uses the chosen key and its fast model for search, checked against the run scope', async () => {
+        const chosen = await chosenProviders.resolveForRun({ platformId, choices: { webSearch: { aiProviderId: 'key-1' } }, surface: 'chat', scope, log })
+
+        expect(mockGetConfigOrThrow).toHaveBeenCalledWith({ platformId, provider: AIProviderName.GOOGLE, scope, configId: 'key-1' })
+        expect(chosen.search).toMatchObject({ credentials: { configId: 'key-1' }, modelId: 'gemini-2.5-flash' })
+    })
+
+    it('falls back to the chat provider when the search key has no usable model', async () => {
+        mockResolveFastModelId.mockRejectedValue(new Error('no text model'))
+
+        const chosen = await chosenProviders.resolveForRun({ platformId, choices: { webSearch: { aiProviderId: 'key-1' } }, surface: 'chat', scope, log })
+
+        expect(chosen.search).toBeNull()
+    })
+
+    it('falls back when the key no longer serves the run\'s project', async () => {
+        mockGetConfigOrThrow.mockRejectedValue(new Error('scoped away'))
+
+        const chosen = await chosenProviders.resolveForRun({ platformId, choices: { webSearch: { aiProviderId: 'key-1' }, imageGeneration: { aiProviderId: 'key-1', modelId: 'img-1' } }, surface: 'chat', scope, log })
+
+        expect(chosen).toEqual({ search: null, image: null })
+    })
+
+    it('never resolves a key that is not on the platform', async () => {
+        const chosen = await chosenProviders.resolveForRun({ platformId, choices: { webSearch: { aiProviderId: 'foreign-key' } }, surface: 'chat', scope, log })
+
+        expect(chosen.search).toBeNull()
+        expect(mockGetConfigOrThrow).not.toHaveBeenCalled()
+    })
+
+    it('keeps an image model the key still allows', async () => {
+        mockGetConfigOrThrow.mockResolvedValue(credentialsFor({ modelScope: 'selected', modelIds: ['img-1'] }))
+
+        const chosen = await chosenProviders.resolveForRun({ platformId, choices: { imageGeneration: { aiProviderId: 'key-1', modelId: 'img-1' } }, surface: 'chat', scope, log })
+
+        expect(chosen.image).toMatchObject({ credentials: { configId: 'key-1' }, modelId: 'img-1' })
+    })
+
+    it('keeps any image model on a key that allows every model', async () => {
+        mockGetConfigOrThrow.mockResolvedValue(credentialsFor({ modelScope: 'all', modelIds: [] }))
+
+        const chosen = await chosenProviders.resolveForRun({ platformId, choices: { imageGeneration: { aiProviderId: 'key-1', modelId: 'img-1' } }, surface: 'chat', scope, log })
+
+        expect(chosen.image).toMatchObject({ modelId: 'img-1' })
+    })
+
+    it('ignores an image choice that names no model', async () => {
+        const chosen = await chosenProviders.resolveForRun({ platformId, choices: { imageGeneration: { aiProviderId: 'key-1' } }, surface: 'chat', scope, log })
+
+        expect(chosen.image).toBeNull()
+    })
+
+    it('falls back when the saved image model was removed from the key', async () => {
+        mockGetConfigOrThrow.mockResolvedValue(credentialsFor({ modelScope: 'selected', modelIds: ['img-2'] }))
+
+        const chosen = await chosenProviders.resolveForRun({ platformId, choices: { imageGeneration: { aiProviderId: 'key-1', modelId: 'img-1' } }, surface: 'chat', scope, log })
+
+        expect(chosen.image).toBeNull()
+    })
+})
diff --git a/packages/server/engine/test/core/code/deno-code-sandbox.test.ts b/packages/server/engine/test/core/code/deno-code-sandbox.test.ts
index c9d3e8dd88c1..593283869c91 100644
--- a/packages/server/engine/test/core/code/deno-code-sandbox.test.ts
+++ b/packages/server/engine/test/core/code/deno-code-sandbox.test.ts
@@ -169,6 +169,24 @@ describe('denoCodeSandbox permission boundary', () => {
         })
     })
 
+    describe('classifies a truncated result line', () => {
+        it('reports the exit code and signal when the process dies while writing its result', async () => {
+            await expectRejection(runModule(`
+                const encoder = new TextEncoder();
+                console.log = (line) => { Deno.stdout.writeSync(encoder.encode(String(line).slice(0, 45))); Deno.exit(7); };
+                export const code = async () => ({ some: 'value' })
+            `), /exited with code 7 and signal null while writing its result/)
+        })
+
+        it('keeps the malformed-result error for an unparseable line after a clean exit', async () => {
+            await expectRejection(runModule(`
+                const encoder = new TextEncoder();
+                console.log = (line) => { Deno.stdout.writeSync(encoder.encode(String(line).slice(0, 45) + '\\n')); };
+                export const code = async () => ({ some: 'value' })
+            `), /returned a malformed result/)
+        })
+    })
+
     describe('runs TypeScript natively', () => {
         it('type-strips TS syntax without a compile step', async () => {
             const result = await runModule(`
diff --git a/packages/server/utils/src/agent-ai-utils.ts b/packages/server/utils/src/agent-ai-utils.ts
index 2f538ce405df..7cf901e05b26 100644
--- a/packages/server/utils/src/agent-ai-utils.ts
+++ b/packages/server/utils/src/agent-ai-utils.ts
@@ -3,9 +3,11 @@ import { agentPersistenceUtils, agentToolClassification, PersistedAgentPart, Per
 import { agentProviderOptions } from './agent-provider-options'
 import { ModelMessage, TelemetryOptions } from 'ai'
 import { createEvlogIntegration } from 'evlog/ai'
+import { modelCatalog } from './model-catalog'
 import { wideEvent } from './wide-event'
 
 
+const MAX_RESPONSE_OUTPUT_TOKENS = 32_000
 const KEEP_RECENT_TOOL_RESULTS = 6
 const COLLAPSE_OUTPUT_OVER_CHARS = 600
 // Tool results that are the agent's working memory of an action's input schema — never collapsed,
@@ -385,7 +387,20 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
     return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
 
+async function affordableOutputTokens({ provider, modelIds, thinkingBudget }: { provider: AIProviderName, modelIds: (string | undefined)[], thinkingBudget: number }): Promise<number> {
+    const catalog = await modelCatalog.load()
+    const ceilings = modelIds.map((modelId) => isNil(modelId) ? undefined : catalog.lookup({ provider, modelId })?.maxOutputTokens)
+    return clampOutputTokens({ thinkingBudget, ceilings })
+}
+
+function clampOutputTokens({ thinkingBudget, ceilings }: { thinkingBudget: number, ceilings: (number | undefined)[] }): number {
+    const known = ceilings.filter((ceiling) => !isNil(ceiling))
+    return Math.min(thinkingBudget + MAX_RESPONSE_OUTPUT_TOKENS, ...known)
+}
+
 export const agentAiUtils = {
+    affordableOutputTokens,
+    clampOutputTokens,
     stripThinkingBlocks,
     sanitizeTruncatedAssistantTail,
     collectStepMessages,
diff --git a/packages/server/utils/test/agent-ai-utils.test.ts b/packages/server/utils/test/agent-ai-utils.test.ts
index 1fdb69e44097..f7fd823538c1 100644
--- a/packages/server/utils/test/agent-ai-utils.test.ts
+++ b/packages/server/utils/test/agent-ai-utils.test.ts
@@ -1,8 +1,9 @@
 import { AIProviderName } from '@activepieces/core-utils'
 import { ACTIVEPIECES_CHAT_TIERS, PersistedAgentPartType, PersistedToolCallStatus } from '@activepieces/shared'
 import { ModelMessage } from 'ai'
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import { agentAiUtils } from '../src/agent-ai-utils'
+import { modelCatalog } from '../src/model-catalog'
 
 const { sanitizeTruncatedAssistantTail } = agentAiUtils
 
@@ -498,3 +499,75 @@ describe('a message transform never hands the provider an empty history', () =>
         expect(stripped[0].role).toBe('user')
     })
 })
+
+const catalogOf = (byId: Record<string, number>) => ({
+    lookup: ({ modelId }: { modelId: string }) => {
+        const stripped = modelId.replace(/^(us|eu|apac|global)\./, '')
+        const maxOutputTokens = byId[stripped]
+        return maxOutputTokens === undefined ? undefined : { maxOutputTokens }
+    },
+})
+
+describe('agentAiUtils.affordableOutputTokens', () => {
+    const SMART_TIER_THINKING = 10_000
+
+    it('reads through a region-prefixed Bedrock id, which is how the picker spells them', async () => {
+        vi.spyOn(modelCatalog, 'load').mockResolvedValue(catalogOf({ 'amazon.nova-pro-v1:0': 10_000 }))
+
+        await expect(agentAiUtils.affordableOutputTokens({
+            provider: AIProviderName.BEDROCK,
+            modelIds: ['eu.amazon.nova-pro-v1:0'],
+            thinkingBudget: SMART_TIER_THINKING,
+        })).resolves.toBe(10_000)
+    })
+
+    it('keeps the turn inside the smaller ceiling when the fast round runs a different model', async () => {
+        vi.spyOn(modelCatalog, 'load').mockResolvedValue(catalogOf({ 'amazon.nova-pro-v1:0': 10_000, 'amazon.nova-micro-v1:0': 5_000 }))
+
+        await expect(agentAiUtils.affordableOutputTokens({
+            provider: AIProviderName.BEDROCK,
+            modelIds: ['eu.amazon.nova-pro-v1:0', 'eu.amazon.nova-micro-v1:0'],
+            thinkingBudget: SMART_TIER_THINKING,
+        })).resolves.toBe(5_000)
+    })
+
+    it('leaves the budget alone for a model the catalog has never heard of', async () => {
+        vi.spyOn(modelCatalog, 'load').mockResolvedValue(catalogOf({}))
+
+        await expect(agentAiUtils.affordableOutputTokens({
+            provider: AIProviderName.BEDROCK,
+            modelIds: ['eu.some.brand-new-model-v9:0'],
+            thinkingBudget: SMART_TIER_THINKING,
+        })).resolves.toBe(42_000)
+    })
+
+    it('does not shrink a turn because the catalog was unreachable', async () => {
+        vi.spyOn(modelCatalog, 'load').mockResolvedValue({ lookup: () => undefined })
+
+        await expect(agentAiUtils.affordableOutputTokens({
+            provider: AIProviderName.BEDROCK,
+            modelIds: ['eu.amazon.nova-pro-v1:0', undefined],
+            thinkingBudget: SMART_TIER_THINKING,
+        })).resolves.toBe(42_000)
+    })
+})
+
+describe('agentAiUtils.clampOutputTokens', () => {
+    const SMART_TIER_THINKING = 10_000
+
+    it('asks for the full budget when no model declares a ceiling', () => {
+        expect(agentAiUtils.clampOutputTokens({ thinkingBudget: SMART_TIER_THINKING, ceilings: [undefined, undefined] })).toBe(42_000)
+    })
+
+    it('never asks a model for more than it accepts', () => {
+        expect(agentAiUtils.clampOutputTokens({ thinkingBudget: SMART_TIER_THINKING, ceilings: [10_000] })).toBe(10_000)
+    })
+
+    it('respects the smaller ceiling when the turn spans two models', () => {
+        expect(agentAiUtils.clampOutputTokens({ thinkingBudget: SMART_TIER_THINKING, ceilings: [64_000, 8_192] })).toBe(8_192)
+    })
+
+    it('leaves a generous ceiling alone rather than raising the ask to meet it', () => {
+        expect(agentAiUtils.clampOutputTokens({ thinkingBudget: SMART_TIER_THINKING, ceilings: [200_000] })).toBe(42_000)
+    })
+})
diff --git a/packages/server/worker/src/lib/execute/jobs/ee/agent/execute-agent-run.ts b/packages/server/worker/src/lib/execute/jobs/ee/agent/execute-agent-run.ts
index 37d65bbe53d2..299372b052ce 100644
--- a/packages/server/worker/src/lib/execute/jobs/ee/agent/execute-agent-run.ts
+++ b/packages/server/worker/src/lib/execute/jobs/ee/agent/execute-agent-run.ts
@@ -66,6 +66,7 @@ export const executeAgentRunJob: JobHandler<ExecuteAgentRunJobData, FireAndForge
         let runProvider: string | undefined
         let runModelId: string | undefined
         let answer: AgentResult | undefined
+        let configLoaded = false
         const structured: { output?: Record<string, unknown> } = {}
 
         let progressSequence = 0
@@ -103,6 +104,7 @@ export const executeAgentRunJob: JobHandler<ExecuteAgentRunJobData, FireAndForge
                 ...spreadIfDefined('discoveryOnly', discoveryOnly),
             })
 
+            configLoaded = true
             const { credentials } = config
             const { provider } = credentials
             const searchCredentials = config.searchCredentials ?? credentials
@@ -398,6 +400,10 @@ export const executeAgentRunJob: JobHandler<ExecuteAgentRunJobData, FireAndForge
             })
         }
         catch (err) {
+            if (apErrorOf(err)?.code === ErrorCode.AGENT_RUN_SUPERSEDED) {
+                log.info({ conversation: { id: conversationId }, run: { id: runId } }, '[executeAgentRun] Run superseded by a newer message, exiting quietly')
+                return { kind: JobResultKind.FIRE_AND_FORGET, status: EngineResponseStatus.OK }
+            }
             const errorClass = classifyAgentRunError({ error: err, provider: runProvider })
             log[errorClass === 'internal' ? 'error' : 'warn']({ error: err, conversation: { id: conversationId }, provider: runProvider, model: { id: runModelId }, agentRun: { errorClass, source } }, '[executeAgentRun] Agent job failed')
             const errorMessage = apErrorOf(err)?.message ?? formatPieceError(err).message
@@ -417,6 +423,7 @@ export const executeAgentRunJob: JobHandler<ExecuteAgentRunJobData, FireAndForge
             // its prior context instead of resetting the conversation.
             await ctx.apiClient.saveAgentMessages({
                 conversationId, runId, messages: [], uiMessages: [],
+                failure: { message: clientMessage, ...(configLoaded ? {} : { userMessage }) },
             }).catch(() => {})
             await sendEventWithRetry({
                 event: { type: AgentEventType.ERROR, data: { message: clientMessage, ...spreadIfDefined('code', isCreditError ? ErrorCode.QUOTA_EXCEEDED : undefined) } },
diff --git a/packages/server/worker/src/lib/execute/jobs/ee/agent/run-agent-turn.ts b/packages/server/worker/src/lib/execute/jobs/ee/agent/run-agent-turn.ts
index f3fc9209de3c..0340a57f9a74 100644
--- a/packages/server/worker/src/lib/execute/jobs/ee/agent/run-agent-turn.ts
+++ b/packages/server/worker/src/lib/execute/jobs/ee/agent/run-agent-turn.ts
@@ -1,9 +1,8 @@
 import { AIProviderName, ErrorCode, formatPieceError, isNil, isObject, isProviderBillingError, isTransientProviderError, spreadIfDefined, tryCatch, tryCatchSync } from '@activepieces/core-utils'
-import { agentAiUtils, ContentPartLike, modelCatalog } from '@activepieces/server-utils'
+import { agentAiUtils, ContentPartLike } from '@activepieces/server-utils'
 import { AgentPhase, AgentRunSource, agentToolClassification, agentToolPhases, AI_PROVIDER_ENTITY_TYPES, aiProviderUtils, apErrorOf, CHAT_CREDITS_PER_TOOL_CALL, chatBilling, ChatToolCall, PersistedAgentPart } from '@activepieces/shared'
 import { APICallError, generateText, isLoopFinished, isStepCount, LanguageModel, LanguageModelUsage, ModelMessage, NoSuchToolError, RetryError, StepResultPerformance, StopCondition, streamText, ToolExecutionOptions, ToolSet } from 'ai'
 
-const MAX_RESPONSE_OUTPUT_TOKENS = 32_000
 const MAX_AUTO_CONTINUATIONS = 3
 const MAX_EMPTY_CONTINUATIONS = 2
 const MAX_STREAM_RETRIES = 1
@@ -91,7 +90,8 @@ export async function runAgentTurn({ model, fastModel, provider, systemPrompt, m
     let lastFinishReason = ''
     let budgetExceeded = false
 
-    const maxOutputTokens = await affordableOutputTokens({ provider, modelIds: [modelId, fastModelId], thinkingBudget: tier.thinkingBudget })
+    const maxOutputTokens = await agentAiUtils.affordableOutputTokens({ provider, modelIds: [modelId, fastModelId], thinkingBudget: tier.thinkingBudget })
+    const maxOutputTokensWithoutThinking = agentAiUtils.clampOutputTokens({ thinkingBudget: 0, ceilings: [maxOutputTokens] })
 
     const runStreamAttempt = (attemptMessages: ModelMessage[]): ReturnType<typeof streamText> => streamText({
         model,
@@ -128,6 +128,7 @@ export async function runAgentTurn({ model, fastModel, provider, systemPrompt, m
             return {
                 ...(usesFastModel ? { model: fastModel } : {}),
                 activeTools: agentToolPhases.activeToolsForPhase({ phase: phaseState.phase, allToolNames }).filter((name) => paidToolsAffordable || !chatBilling.isPaidTool(name)),
+                maxOutputTokens: disableThinking ? maxOutputTokensWithoutThinking : maxOutputTokens,
                 providerOptions: agentAiUtils.buildProviderOptions({ provider, tier, modelId: lastStepModelId, disableThinking }),
                 ...boundContextForStep({ baseMessages: attemptMessages, steps, systemPrompt, provider }),
             }
@@ -412,17 +413,6 @@ export function looksEmptyResultText(text: string): boolean {
     return /"found"\s*:\s*false|\bempty result\b|no results matched|"result"\s*:\s*\[\s*\]|"results"\s*:\s*\[\s*\]/i.test(text)
 }
 
-export async function affordableOutputTokens({ provider, modelIds, thinkingBudget }: { provider: AIProviderName, modelIds: (string | undefined)[], thinkingBudget: number }): Promise<number> {
-    const catalog = await modelCatalog.load()
-    const ceilings = modelIds.map((modelId) => isNil(modelId) ? undefined : catalog.lookup({ provider, modelId })?.maxOutputTokens)
-    return clampOutputTokens({ thinkingBudget, ceilings })
-}
-
-export function clampOutputTokens({ thinkingBudget, ceilings }: { thinkingBudget: number, ceilings: (number | undefined)[] }): number {
-    const known = ceilings.filter((ceiling) => !isNil(ceiling))
-    return Math.min(thinkingBudget + MAX_RESPONSE_OUTPUT_TOKENS, ...known)
-}
-
 function completedToolCalls(steps: ReadonlyArray<{ toolResults: ReadonlyArray<{ toolName: string, output: unknown }> }>): ChatToolCall[] {
     return steps.flatMap((step) => step.toolResults.map((result) => ({ toolName: result.toolName, output: result.output })))
 }
diff --git a/packages/server/worker/test/lib/agent-eval/core/fixture.ts b/packages/server/worker/test/lib/agent-eval/core/fixture.ts
index bafa8f9e7936..4ddc67a3740f 100644
--- a/packages/server/worker/test/lib/agent-eval/core/fixture.ts
+++ b/packages/server/worker/test/lib/agent-eval/core/fixture.ts
@@ -8,6 +8,9 @@ export type ChatEvalAssertion =
     | { type: 'calledBefore', a: string, b: string }
     | { type: 'reachedToolWithin', toolName: string, n: number }
     | { type: 'maxQuestionCards', n: number, toolNames?: string[] }
+    | { type: 'neverCalledTool', toolName: string }
+    | { type: 'askedToTurnItOn' }
+    | { type: 'noLiveClaimWithoutPublish' }
 
 export type ChatEvalJudgeDimension = {
     dimension: string
diff --git a/packages/server/worker/test/lib/agent-eval/core/transcript-assertions.test.ts b/packages/server/worker/test/lib/agent-eval/core/transcript-assertions.test.ts
index 6ee15cfa0e0b..e514f6c77d85 100644
--- a/packages/server/worker/test/lib/agent-eval/core/transcript-assertions.test.ts
+++ b/packages/server/worker/test/lib/agent-eval/core/transcript-assertions.test.ts
@@ -131,3 +131,32 @@ describe('transcriptAssertions.maxQuestionCards', () => {
         expect(transcriptAssertions.maxQuestionCards(result, 1, ['ap_show_questions']).pass).toBe(true)
     })
 })
+
+describe('transcriptAssertions publish behaviour', () => {
+    const build = toolCall({ toolName: 'ap_build_flow', order: 0, phase: 'build' })
+    const publish = toolCall({ toolName: 'ap_lock_and_publish', order: 1, phase: 'build' })
+
+    it('fails when a flow is built and ends on open it to review, or is published without asking', () => {
+        const review = makeResult({ toolCalls: [build], uiParts: [textPart('Open it to review.')] })
+        expect(transcriptAssertions.askedToTurnItOn(review).pass).toBe(false)
+        expect(transcriptAssertions.askedToTurnItOn(makeResult({ toolCalls: [build, publish] })).pass).toBe(false)
+    })
+
+    it('passes when a card is shown before any publish', () => {
+        const card = { ...toolCall({ toolName: 'ap_show_quick_replies', order: 1 }), input: { replies: ['Turn it on', 'Not yet'] } }
+        const unrelated = { ...toolCall({ toolName: 'ap_show_quick_replies', order: 1 }), input: { replies: ['Open it to review'] } }
+        expect(transcriptAssertions.askedToTurnItOn(makeResult({ toolCalls: [build, card] })).pass).toBe(true)
+        expect(transcriptAssertions.askedToTurnItOn(makeResult({ toolCalls: [build, unrelated] })).pass).toBe(false)
+    })
+
+    it('fails a live claim without a publish call and allows it after one', () => {
+        const uiParts = [textPart('Your flow is live and will run every morning.')]
+        expect(transcriptAssertions.noLiveClaimWithoutPublish(makeResult({ uiParts })).pass).toBe(false)
+        expect(transcriptAssertions.noLiveClaimWithoutPublish(makeResult({ uiParts, toolCalls: [build, publish] })).pass).toBe(true)
+    })
+
+    it('flags a forbidden one-off tool', () => {
+        const result = makeResult({ toolCalls: [toolCall({ toolName: 'ap_run_code', order: 0 })] })
+        expect(transcriptAssertions.neverCalledTool(result, 'ap_run_code').pass).toBe(false)
+    })
+})
diff --git a/packages/server/worker/test/lib/agent-eval/core/transcript-assertions.ts b/packages/server/worker/test/lib/agent-eval/core/transcript-assertions.ts
index 6370667c2321..b101fdea4f3b 100644
--- a/packages/server/worker/test/lib/agent-eval/core/transcript-assertions.ts
+++ b/packages/server/worker/test/lib/agent-eval/core/transcript-assertions.ts
@@ -10,6 +10,16 @@ const ASKED_HOW_PATTERNS = [
 
 const DEFAULT_QUESTION_CARD_PATTERN = /question|quick_repl/i
 
+const PUBLISH_TOOL_NAME = 'ap_lock_and_publish'
+
+const TURN_IT_ON_PATTERN = /turn (it )?on|publish|go live|activate|enable/i
+
+const LIVE_CLAIM_PATTERNS = [
+    /\b(is|it's|it is|now|already|currently) (live|running|active|enabled|published)\b/i,
+    /\b(is|are) now (on|turned on)\b/i,
+    /\bgoing live\b/i,
+]
+
 function assistantText(result: AgentTurnResult): string {
     return result.uiParts
         .filter((part): part is Extract<PersistedAgentPart, { type: PersistedAgentPartType.TEXT }> => part.type === PersistedAgentPartType.TEXT)
@@ -78,6 +88,31 @@ function maxQuestionCards(result: AgentTurnResult, n: number, toolNames?: string
         : { pass: false, reason: `${count} question card(s) shown (> ${n})` }
 }
 
+function neverCalledTool(result: AgentTurnResult, toolName: string): AssertionOutcome {
+    return result.toolCalls.some((call) => call.toolName === toolName)
+        ? { pass: false, reason: `"${toolName}" was called` }
+        : { pass: true, reason: `"${toolName}" was never called` }
+}
+
+function askedToTurnItOn(result: AgentTurnResult): AssertionOutcome {
+    const cardOrder = result.toolCalls.find((call) => DEFAULT_QUESTION_CARD_PATTERN.test(call.toolName) && TURN_IT_ON_PATTERN.test(JSON.stringify(call.input)))?.order
+    if (cardOrder === undefined) {
+        return { pass: false, reason: 'no "Turn it on?" card was shown' }
+    }
+    const publishedBeforeAsking = result.toolCalls.some((call) => call.toolName === PUBLISH_TOOL_NAME && call.order < cardOrder)
+    return publishedBeforeAsking
+        ? { pass: false, reason: 'flow was published before the user said yes' }
+        : { pass: true, reason: 'a "Turn it on?" card was shown before any publish' }
+}
+
+function noLiveClaimWithoutPublish(result: AgentTurnResult): AssertionOutcome {
+    const published = result.toolCalls.some((call) => call.toolName === PUBLISH_TOOL_NAME)
+    const matched = LIVE_CLAIM_PATTERNS.find((pattern) => pattern.test(assistantText(result)))
+    return !published && matched
+        ? { pass: false, reason: `claimed the flow is live (${matched}) without calling ${PUBLISH_TOOL_NAME}` }
+        : { pass: true, reason: 'no live claim without a publish' }
+}
+
 function runAssertion(result: AgentTurnResult, assertion: ChatEvalAssertion): AssertionResult {
     switch (assertion.type) {
         case 'neverAskedHow':
@@ -92,6 +127,12 @@ function runAssertion(result: AgentTurnResult, assertion: ChatEvalAssertion): As
             return { type: assertion.type, ...reachedToolWithin(result, assertion.toolName, assertion.n) }
         case 'maxQuestionCards':
             return { type: assertion.type, ...maxQuestionCards(result, assertion.n, assertion.toolNames) }
+        case 'neverCalledTool':
+            return { type: assertion.type, ...neverCalledTool(result, assertion.toolName) }
+        case 'askedToTurnItOn':
+            return { type: assertion.type, ...askedToTurnItOn(result) }
+        case 'noLiveClaimWithoutPublish':
+            return { type: assertion.type, ...noLiveClaimWithoutPublish(result) }
     }
 }
 
@@ -102,6 +143,9 @@ export const transcriptAssertions = {
     calledBefore,
     reachedToolWithin,
     maxQuestionCards,
+    neverCalledTool,
+    askedToTurnItOn,
+    noLiveClaimWithoutPublish,
     runAssertion,
 }
 
diff --git a/packages/server/worker/test/lib/agent-eval/fixtures/build-then-ask-turn-it-on.json b/packages/server/worker/test/lib/agent-eval/fixtures/build-then-ask-turn-it-on.json
new file mode 100644
index 000000000000..e7503f245141
--- /dev/null
+++ b/packages/server/worker/test/lib/agent-eval/fixtures/build-then-ask-turn-it-on.json
@@ -0,0 +1,30 @@
+{
+    "id": "build-then-ask-turn-it-on",
+    "description": "After a validated, tested flow is built, chat ends with one 'Turn it on?' card and never auto-publishes or claims the flow is live. The build sits in initialMessages because the eval runner has no flow-building tools.",
+    "kind": "capability",
+    "initialMessages": [
+        { "role": "user", "content": "Every weekday at 9am, post a reminder in #standup on Slack asking the team for updates." },
+        { "role": "assistant", "content": "Built it: \"Standup reminder\" (flow flow_standup_1) runs on a weekday 9am schedule and posts to #standup. I validated every step and ran a test that posted the message successfully. The flow is a draft and has not been published." }
+    ],
+    "userTurns": [
+        "Nice, thanks."
+    ],
+    "recordedToolCalls": [],
+    "model": {
+        "provider": "openrouter",
+        "modelId": "anthropic/claude-sonnet-4.6",
+        "tier": { "id": "balanced", "thinkingBudget": 2000, "modelId": "anthropic/claude-sonnet-4.6" }
+    },
+    "assertions": [
+        { "type": "neverCutOff" },
+        { "type": "askedToTurnItOn" },
+        { "type": "noLiveClaimWithoutPublish" }
+    ],
+    "judge": [
+        {
+            "dimension": "ends_with_turn_it_on_card",
+            "rubric": "A flow was built, validated and tested but is unpublished. PASS if the assistant asks once whether to turn it on (a single 'Turn it on?' choice) without publishing it first. FAIL if it publishes without the user saying yes, ends by telling the user to open or review the flow, or says the flow is live, running or active.",
+            "expectedLabel": "pass"
+        }
+    ]
+}
diff --git a/packages/server/worker/test/lib/agent-eval/fixtures/intent-automation-builds-flow.json b/packages/server/worker/test/lib/agent-eval/fixtures/intent-automation-builds-flow.json
new file mode 100644
index 000000000000..6e6791bcb25f
--- /dev/null
+++ b/packages/server/worker/test/lib/agent-eval/fixtures/intent-automation-builds-flow.json
@@ -0,0 +1,28 @@
+{
+    "id": "intent-automation-builds-flow",
+    "description": "A stated recurring or automation intent (workflow, every day, track) must lead to a built flow, not a one-off code run or web search.",
+    "kind": "capability",
+    "initialMessages": [],
+    "userTurns": [
+        "I want a workflow that fetches the release notes of our dependencies every Monday and posts them to Slack."
+    ],
+    "recordedToolCalls": [],
+    "model": {
+        "provider": "openrouter",
+        "modelId": "anthropic/claude-sonnet-4.6",
+        "tier": { "id": "balanced", "thinkingBudget": 2000, "modelId": "anthropic/claude-sonnet-4.6" }
+    },
+    "assertions": [
+        { "type": "neverCutOff" },
+        { "type": "neverCalledTool", "toolName": "ap_run_code" },
+        { "type": "neverCalledTool", "toolName": "ap_show_showcase" },
+        { "type": "reachedToolWithin", "toolName": "ap_set_phase", "n": 10 }
+    ],
+    "judge": [
+        {
+            "dimension": "builds_flow_not_one_off",
+            "rubric": "The user asked for a workflow with a recurring cadence. PASS if the assistant commits to building an automation: researching pieces, asking for a needed connection, or calling the build tools. FAIL if it answers with a one-off lookup, a web search summary or a code run, or only shows a showcase of what it can do without building.",
+            "expectedLabel": "pass"
+        }
+    ]
+}
diff --git a/packages/server/worker/test/lib/execute/jobs/ee/agent/output-token-ceiling.test.ts b/packages/server/worker/test/lib/execute/jobs/ee/agent/output-token-ceiling.test.ts
deleted file mode 100644
index 110d145c8810..000000000000
--- a/packages/server/worker/test/lib/execute/jobs/ee/agent/output-token-ceiling.test.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { AIProviderName } from '@activepieces/core-utils'
-import { describe, expect, it, vi } from 'vitest'
-
-const { mockLoad } = vi.hoisted(() => ({ mockLoad: vi.fn() }))
-
-vi.mock('@activepieces/server-utils', async (importOriginal) => ({
-    ...(await importOriginal<Record<string, unknown>>()),
-    modelCatalog: { load: mockLoad },
-}))
-
-const { affordableOutputTokens } = await import('../../../../../../src/lib/execute/jobs/ee/agent/run-agent-turn')
-
-const catalogOf = (byId: Record<string, number>) => ({
-    lookup: ({ modelId }: { modelId: string }) => {
-        const stripped = modelId.replace(/^(us|eu|apac|global)\./, '')
-        const maxOutputTokens = byId[stripped]
-        return maxOutputTokens === undefined ? undefined : { maxOutputTokens }
-    },
-})
-
-describe('affordableOutputTokens', () => {
-    const SMART_TIER_THINKING = 10_000
-
-    it('reads through a region-prefixed Bedrock id, which is how the picker spells them', async () => {
-        mockLoad.mockResolvedValue(catalogOf({ 'amazon.nova-pro-v1:0': 10_000 }))
-
-        await expect(affordableOutputTokens({
-            provider: AIProviderName.BEDROCK,
-            modelIds: ['eu.amazon.nova-pro-v1:0'],
-            thinkingBudget: SMART_TIER_THINKING,
-        })).resolves.toBe(10_000)
-    })
-
-    it('keeps the turn inside the smaller ceiling when the fast round runs a different model', async () => {
-        mockLoad.mockResolvedValue(catalogOf({ 'amazon.nova-pro-v1:0': 10_000, 'amazon.nova-micro-v1:0': 5_000 }))
-
-        await expect(affordableOutputTokens({
-            provider: AIProviderName.BEDROCK,
-            modelIds: ['eu.amazon.nova-pro-v1:0', 'eu.amazon.nova-micro-v1:0'],
-            thinkingBudget: SMART_TIER_THINKING,
-        })).resolves.toBe(5_000)
-    })
-
-    it('leaves the budget alone for a model the catalog has never heard of', async () => {
-        mockLoad.mockResolvedValue(catalogOf({}))
-
-        await expect(affordableOutputTokens({
-            provider: AIProviderName.BEDROCK,
-            modelIds: ['eu.some.brand-new-model-v9:0'],
-            thinkingBudget: SMART_TIER_THINKING,
-        })).resolves.toBe(42_000)
-    })
-
-    it('does not shrink a turn because the catalog was unreachable', async () => {
-        mockLoad.mockResolvedValue({ lookup: () => undefined })
-
-        await expect(affordableOutputTokens({
-            provider: AIProviderName.BEDROCK,
-            modelIds: ['eu.amazon.nova-pro-v1:0', undefined],
-            thinkingBudget: SMART_TIER_THINKING,
-        })).resolves.toBe(42_000)
-    })
-})
diff --git a/packages/server/worker/test/lib/execute/jobs/ee/agent/run-agent-turn-guards.test.ts b/packages/server/worker/test/lib/execute/jobs/ee/agent/run-agent-turn-guards.test.ts
index 232055f5d346..cfced625699e 100644
--- a/packages/server/worker/test/lib/execute/jobs/ee/agent/run-agent-turn-guards.test.ts
+++ b/packages/server/worker/test/lib/execute/jobs/ee/agent/run-agent-turn-guards.test.ts
@@ -3,7 +3,7 @@ import { AgentRunSource, AI_PROVIDER_ENTITY_TYPES } from '@activepieces/shared'
 import { APICallError, RetryError } from 'ai'
 import { describe, expect, it } from 'vitest'
 
-import { clampOutputTokens, classifyAgentRunError, firstStepUsesFastModel, isTransientFailureText, jsonInputFrom, looksEmptyResultText } from '../../../../../../src/lib/execute/jobs/ee/agent/run-agent-turn'
+import { classifyAgentRunError, firstStepUsesFastModel, isTransientFailureText, jsonInputFrom, looksEmptyResultText } from '../../../../../../src/lib/execute/jobs/ee/agent/run-agent-turn'
 
 function apiError({ statusCode, message, responseBody }: { statusCode: number, message: string, responseBody?: string }): APICallError {
     return new APICallError({ message, url: 'https://provider.test/v1/chat', requestBodyValues: {}, statusCode, responseBody })
@@ -208,23 +208,3 @@ describe('jsonInputFrom', () => {
         }
     })
 })
-
-describe('clampOutputTokens', () => {
-    const SMART_TIER_THINKING = 10_000
-
-    it('asks for the full budget when no model declares a ceiling', () => {
-        expect(clampOutputTokens({ thinkingBudget: SMART_TIER_THINKING, ceilings: [undefined, undefined] })).toBe(42_000)
-    })
-
-    it('never asks a model for more than it accepts', () => {
-        expect(clampOutputTokens({ thinkingBudget: SMART_TIER_THINKING, ceilings: [10_000] })).toBe(10_000)
-    })
-
-    it('respects the smaller ceiling when the turn spans two models', () => {
-        expect(clampOutputTokens({ thinkingBudget: SMART_TIER_THINKING, ceilings: [64_000, 8_192] })).toBe(8_192)
-    })
-
-    it('leaves a generous ceiling alone rather than raising the ask to meet it', () => {
-        expect(clampOutputTokens({ thinkingBudget: SMART_TIER_THINKING, ceilings: [200_000] })).toBe(42_000)
-    })
-})
diff --git a/packages/web/public/locales/en/translation.json b/packages/web/public/locales/en/translation.json
index c13004ef3214..de6a9a9c4b4e 100644
--- a/packages/web/public/locales/en/translation.json
+++ b/packages/web/public/locales/en/translation.json
@@ -2321,6 +2321,7 @@
   "{count, plural, =1 {1 hour} other {# hours}}": "{count, plural, =1 {1 hour} other {# hours}}",
   "Image preview": "Image preview",
   "The assistant did not respond. Please try again.": "The assistant did not respond. Please try again.",
+  "The last reply did not finish. Please try again.": "The last reply did not finish. Please try again.",
   "Edit Global Connection": "Edit Global Connection",
   "Rename Connection": "Rename Connection",
   "Enter a new display name for this connection.": "Enter a new display name for this connection.",
diff --git a/packages/web/src/app/builder/step-settings/agent-settings/agent-link.tsx b/packages/web/src/app/builder/step-settings/agent-settings/agent-link.tsx
index 7708fb6f92a8..7abbeffd456a 100644
--- a/packages/web/src/app/builder/step-settings/agent-settings/agent-link.tsx
+++ b/packages/web/src/app/builder/step-settings/agent-settings/agent-link.tsx
@@ -1,4 +1,8 @@
-import { isNil, spreadIfDefined } from '@activepieces/core-utils';
+import {
+  AIProviderName,
+  isNil,
+  spreadIfDefined,
+} from '@activepieces/core-utils';
 import {
   AgentPieceProps,
   AgentSummary,
@@ -31,6 +35,7 @@ import {
   agentsQueries,
   useAgentsAvailable,
 } from '@/features/agents/hooks/agents-hooks';
+import { aiProviderQueries } from '@/features/platform-admin/hooks/ai-provider-hooks';
 import { useAuthorization } from '@/hooks/authorization-hooks';
 import { authenticationSession } from '@/lib/authentication-session';
 import { cn } from '@/lib/utils';
@@ -77,7 +82,13 @@ export const AgentLink = ({ disabled }: AgentLinkProps) => {
     : !linked.isPublished
     ? t('Not published yet. Publish it before this flow can run.')
     : undefined;
-  const modelLabel = linkedConfig?.modelName ?? undefined;
+  const { tiers: flowTiers } = aiProviderQueries.useModelTiers('flow');
+  const modelLabel =
+    (linkedConfig?.provider === AIProviderName.ACTIVEPIECES
+      ? flowTiers.find((tier) => tier.id === linkedConfig.modelName)?.label
+      : undefined) ??
+    linkedConfig?.modelName ??
+    undefined;
   const toolPieces = new Set(
     (linked?.toolPieceNames ?? []).map((pieceName) =>
       pieceName.replace('@activepieces/piece-', ''),
diff --git a/packages/web/src/features/agents/ai-model/hooks.ts b/packages/web/src/features/agents/ai-model/hooks.ts
index 6b5887571b56..fd6c43dca1a5 100644
--- a/packages/web/src/features/agents/ai-model/hooks.ts
+++ b/packages/web/src/features/agents/ai-model/hooks.ts
@@ -1,6 +1,7 @@
 import { AIProviderName, isNil } from '@activepieces/core-utils';
 import {
   AIProviderModel,
+  AIProviderModelType,
   ALLOWED_CHAT_MODELS_BY_PROVIDER,
 } from '@activepieces/shared';
 import { useQuery } from '@tanstack/react-query';
@@ -26,10 +27,14 @@ function getAllowedModelsForProvider({
   modelType: AIModelType;
   flowTiers: ModelTier[];
 }): AIProviderModel[] {
-  const allowedIds =
-    provider === AIProviderName.ACTIVEPIECES
-      ? flowTiers.map((tier) => tier.modelId)
-      : ALLOWED_CHAT_MODELS_BY_PROVIDER[provider];
+  if (provider === AIProviderName.ACTIVEPIECES) {
+    return flowTiers.map((tier) => ({
+      id: tier.id,
+      name: tier.label,
+      type: AIProviderModelType.TEXT,
+    }));
+  }
+  const allowedIds = ALLOWED_CHAT_MODELS_BY_PROVIDER[provider];
 
   return allModels
     .filter((model) => model.type === modelType)
@@ -47,26 +52,7 @@ function getAllowedModelsForProvider({
       const aIndex = allowedIds.indexOf(a.id);
       const bIndex = allowedIds.indexOf(b.id);
       return aIndex - bIndex;
-    })
-    .map((model) =>
-      provider === AIProviderName.ACTIVEPIECES
-        ? {
-            ...model,
-            name:
-              managedTierLabel({ modelId: model.id, flowTiers }) ?? model.name,
-          }
-        : model,
-    );
-}
-
-function managedTierLabel({
-  modelId,
-  flowTiers,
-}: {
-  modelId: string;
-  flowTiers: ModelTier[];
-}): string | undefined {
-  return flowTiers.find((tier) => tier.modelId === modelId)?.label;
+    });
 }
 
 export const aiModelHooks = {
@@ -99,7 +85,9 @@ export const aiModelHooks = {
       queryKey: ['ai-models', provider, configId, projectId],
       enabled: !isNil(provider) && !isNil(projectId),
       queryFn: () =>
-        isNil(provider) || isNil(projectId)
+        isNil(provider) ||
+        isNil(projectId) ||
+        provider === AIProviderName.ACTIVEPIECES
           ? []
           : aiProviderApi.listModelsForProvider(provider, projectId, configId),
       select,
diff --git a/packages/web/src/features/agents/ai-model/index.tsx b/packages/web/src/features/agents/ai-model/index.tsx
index 11528447a5a8..91f1eba21805 100644
--- a/packages/web/src/features/agents/ai-model/index.tsx
+++ b/packages/web/src/features/agents/ai-model/index.tsx
@@ -1,4 +1,6 @@
 import { AIProviderName } from '@activepieces/core-utils';
+import { AIProviderModel } from '@activepieces/shared';
+import { useQuery } from '@tanstack/react-query';
 import { t } from 'i18next';
 import { Check, ChevronsUpDown, Loader2 } from 'lucide-react';
 import * as React from 'react';
@@ -17,6 +19,7 @@ import {
   PopoverTrigger,
 } from '@/components/ui/popover';
 import { SUPPORTED_AI_PROVIDERS } from '@/features/agents/ai-providers';
+import { aiProviderQueries } from '@/features/platform-admin/hooks/ai-provider-hooks';
 import { cn } from '@/lib/utils';
 
 import { aiModelHooks } from './hooks';
@@ -80,6 +83,16 @@ export function AIModelSelector({
     aiModelHooks.useListProviders();
   const { data: models = [], isLoading: modelsLoading } =
     aiModelHooks.useGetModelsForProvider(selectedProvider, selectedConfigId);
+  const { status: modelTiersStatus } = useQuery(
+    aiProviderQueries.modelTiersOptions(),
+  );
+  const { defaultTierId } = aiProviderQueries.useModelTiers('flow');
+  const managed = selectedProvider === AIProviderName.ACTIVEPIECES;
+  const waitingForTiers = managed && modelTiersStatus === 'pending';
+  const defaultModelId = defaultPick({
+    models,
+    preferredId: managed ? defaultTierId : undefined,
+  });
 
   const getProviderLogo = React.useCallback((providerName: string) => {
     return ALL_PROVIDERS.find((p) => p.provider === providerName)?.logoUrl;
@@ -126,13 +139,13 @@ export function AIModelSelector({
       selectedProvider &&
       models.length > 0 &&
       !selectedModel &&
-      !modelsLoading
+      !modelsLoading &&
+      !waitingForTiers
     ) {
-      const firstModel = models[0].id;
-      setSelectedModel(firstModel);
+      setSelectedModel(defaultModelId);
       onChange({
         provider: selectedProvider,
-        model: firstModel,
+        model: defaultModelId,
         configId: selectedConfigId,
         picked: 'default',
       });
@@ -140,6 +153,8 @@ export function AIModelSelector({
   }, [
     models,
     modelsLoading,
+    waitingForTiers,
+    defaultModelId,
     selectedProvider,
     selectedModel,
     selectedConfigId,
@@ -153,17 +168,17 @@ export function AIModelSelector({
       models.length > 0 &&
       !models.some((m) => m.id === selectedModel)
     ) {
-      const fallback = models[0]?.id;
-      setSelectedModel(fallback);
+      setSelectedModel(defaultModelId);
       onChange({
         provider: selectedProvider,
-        model: fallback,
+        model: defaultModelId,
         configId: selectedConfigId,
         picked: 'default',
       });
     }
   }, [
     models,
+    defaultModelId,
     selectedModel,
     selectedProvider,
     selectedConfigId,
@@ -358,3 +373,15 @@ export function AIModelSelector({
     </div>
   );
 }
+
+function defaultPick({
+  models,
+  preferredId,
+}: {
+  models: AIProviderModel[];
+  preferredId: string | undefined;
+}): string | undefined {
+  return models.some((model) => model.id === preferredId)
+    ? preferredId
+    : models[0]?.id;
+}
diff --git a/packages/web/src/features/chat/lib/use-chat.ts b/packages/web/src/features/chat/lib/use-chat.ts
index c9da2c785c06..7b93c5dd1cfe 100644
--- a/packages/web/src/features/chat/lib/use-chat.ts
+++ b/packages/web/src/features/chat/lib/use-chat.ts
@@ -517,7 +517,18 @@ export function useAgentChat({
         history.findLastIndex((m) => m.role === 'assistant') >
           history.findLastIndex((m) => m.role === 'user');
       if (opts?.errorMessage) {
-        updateSendStatus({ type: 'error', message: opts.errorMessage });
+        const lastReply = history?.at(-1);
+        const failureIsInTranscript =
+          lastReply?.role === 'assistant' &&
+          lastReply.parts.some(
+            (part) => part.type === 'text' && part.text === opts.errorMessage,
+          );
+        updateSendStatus({
+          type: 'error',
+          message: failureIsInTranscript
+            ? t('The last reply did not finish. Please try again.')
+            : opts.errorMessage,
+        });
       } else if (!hasReply && !opts?.suppressNoReply) {
         updateSendStatus({
           type: 'error',
@@ -863,10 +874,16 @@ export function useAgentChat({
         }
       } else {
         setPersistedMessages(mapped);
+        if (convResult.data.status === AgentConversationStatus.ERROR) {
+          updateSendStatus({
+            type: 'error',
+            message: t('The last reply did not finish. Please try again.'),
+          });
+        }
       }
       setIsLoadingHistory(false);
     },
-    [stopStream, startStream, updateSendStatus, store],
+    [stopStream, startStream, updateSendStatus, store, t],
   );
 
   useQuery({
diff --git a/packages/web/test/app/builder/step-settings/agent-settings/agent-link.test.tsx b/packages/web/test/app/builder/step-settings/agent-settings/agent-link.test.tsx
index 82feb06dce10..d70290cccb9f 100644
--- a/packages/web/test/app/builder/step-settings/agent-settings/agent-link.test.tsx
+++ b/packages/web/test/app/builder/step-settings/agent-settings/agent-link.test.tsx
@@ -10,6 +10,7 @@
  * branch-settings test, since @testing-library/react is opted into per file.
  */
 /* eslint-disable testing-library/no-unnecessary-act */
+import { AIProviderName } from '@activepieces/core-utils';
 import { AgentVisibility } from '@activepieces/shared';
 import * as React from 'react';
 import { act } from 'react';
@@ -21,6 +22,7 @@ const state = vi.hoisted(() => ({
   agentsAvailable: true,
   agents: [] as unknown[],
   isError: false,
+  linkedAgent: undefined as unknown,
 }));
 
 vi.mock('@/features/agents/hooks/agents-hooks', () => ({
@@ -32,7 +34,19 @@ vi.mock('@/features/agents/hooks/agents-hooks', () => ({
       isError: state.isError,
       refetch: vi.fn(),
     }),
-    useAgent: () => ({ data: undefined }),
+    useAgent: () => ({ data: state.linkedAgent }),
+  },
+}));
+
+vi.mock('@/features/platform-admin/hooks/ai-provider-hooks', () => ({
+  aiProviderQueries: {
+    useModelTiers: () => ({
+      tiers: [
+        { id: 'fast', label: 'Fast', modelId: 'anthropic/claude-haiku-4.5' },
+        { id: 'premium', label: 'Heavy', modelId: 'anthropic/claude-opus-4.8' },
+      ],
+      defaultTierId: 'fast',
+    }),
   },
 }));
 
@@ -128,6 +142,7 @@ function render(agentId?: string) {
 beforeEach(() => {
   state.agentsAvailable = true;
   state.isError = false;
+  state.linkedAgent = undefined;
   state.agents = [
     agent({ displayName: 'Ops', visibility: AgentVisibility.PROJECT }),
   ];
@@ -190,4 +205,48 @@ describe('the agent picker on a Run Agent step', () => {
       container.querySelector('[data-testid="agent-picker-error"]'),
     ).not.toBe(null);
   });
+
+  it('names a managed agent model by its tier label, not its tier id', () => {
+    state.linkedAgent = linkedAgent({
+      provider: AIProviderName.ACTIVEPIECES,
+      modelName: 'premium',
+    });
+
+    render('ext-Ops');
+
+    expect(container.textContent).toContain('Heavy');
+    expect(container.textContent).not.toContain('premium');
+  });
+
+  it('shows a model id that is not a tier as it is stored', () => {
+    state.linkedAgent = linkedAgent({
+      provider: AIProviderName.ACTIVEPIECES,
+      modelName: 'anthropic/claude-opus-4.8',
+    });
+
+    render('ext-Ops');
+
+    expect(container.textContent).toContain('anthropic/claude-opus-4.8');
+  });
 });
+
+function linkedAgent({
+  provider,
+  modelName,
+}: {
+  provider: AIProviderName;
+  modelName: string;
+}) {
+  return {
+    id: 'id-Ops',
+    draft: null,
+    published: {
+      provider,
+      modelName,
+      instructions: 'Answer tickets.',
+      tools: [],
+      structuredOutput: [],
+      maxSteps: 10,
+    },
+  };
+}
diff --git a/packages/web/test/features/agents/ai-model/ai-model-selector.test.tsx b/packages/web/test/features/agents/ai-model/ai-model-selector.test.tsx
new file mode 100644
index 000000000000..e613bf19d6f7
--- /dev/null
+++ b/packages/web/test/features/agents/ai-model/ai-model-selector.test.tsx
@@ -0,0 +1,99 @@
+// @vitest-environment jsdom
+import { AIProviderName } from '@activepieces/core-utils';
+import { AIProviderModelType } from '@activepieces/shared';
+import { render } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('i18next', () => ({ t: (key: string) => key }));
+
+const state = vi.hoisted(() => ({
+  tiersStatus: 'success',
+}));
+
+vi.mock('@tanstack/react-query', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useQuery: () => ({ status: state.tiersStatus }),
+}));
+
+vi.mock('@/features/platform-admin/hooks/ai-provider-hooks', () => ({
+  aiProviderQueries: {
+    modelTiersOptions: () => ({ queryKey: ['model-tiers'] }),
+    useModelTiers: () => ({ tiers: [], defaultTierId: 'premium' }),
+  },
+}));
+
+vi.mock('@/features/agents/ai-model/hooks', () => ({
+  aiModelHooks: {
+    useListProviders: () => ({
+      data: [
+        {
+          provider: AIProviderName.ACTIVEPIECES,
+          name: 'Activepieces',
+          keys: [{ id: 'managed-key', name: 'Activepieces' }],
+        },
+      ],
+      isLoading: false,
+    }),
+    useGetModelsForProvider: () => ({
+      data: [
+        { id: 'fast', name: 'Fast', type: AIProviderModelType.TEXT },
+        { id: 'smart', name: 'Expert', type: AIProviderModelType.TEXT },
+        { id: 'premium', name: 'Heavy', type: AIProviderModelType.TEXT },
+      ],
+      isLoading: false,
+    }),
+  },
+}));
+
+import { AIModelSelector } from '@/features/agents/ai-model';
+
+describe('AIModelSelector on the managed provider', () => {
+  beforeEach(() => {
+    state.tiersStatus = 'success';
+  });
+
+  it('pre-fills the published default tier id, not the first tier in the list', () => {
+    const onChange = vi.fn();
+
+    render(<AIModelSelector onChange={onChange} />);
+
+    expect(onChange).toHaveBeenCalledWith({
+      provider: AIProviderName.ACTIVEPIECES,
+      model: 'premium',
+      configId: 'managed-key',
+      picked: 'default',
+    });
+    expect(modelTriggerText()).toBe('Heavy');
+  });
+
+  it('waits for the published tiers before pre-filling, so the bundled default never lands first', () => {
+    state.tiersStatus = 'pending';
+    const onChange = vi.fn();
+
+    render(<AIModelSelector onChange={onChange} />);
+
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('leaves a stored concrete model id alone and shows it as stored', () => {
+    const onChange = vi.fn();
+
+    render(
+      <AIModelSelector
+        defaultProvider={AIProviderName.ACTIVEPIECES}
+        defaultConfigId="managed-key"
+        defaultModel="anthropic/claude-sonnet-4.6"
+        onChange={onChange}
+      />,
+    );
+
+    expect(onChange).not.toHaveBeenCalled();
+    expect(modelTriggerText()).toBe('anthropic/claude-sonnet-4.6');
+  });
+});
+
+function modelTriggerText(): string | undefined {
+  return document
+    .querySelectorAll('button[role="combobox"]')[1]
+    ?.textContent?.trim();
+}
diff --git a/packages/web/test/features/agents/ai-model/hooks.test.tsx b/packages/web/test/features/agents/ai-model/hooks.test.tsx
index 239c2fd2b676..162e111f1cef 100644
--- a/packages/web/test/features/agents/ai-model/hooks.test.tsx
+++ b/packages/web/test/features/agents/ai-model/hooks.test.tsx
@@ -42,7 +42,7 @@ describe('aiModelHooks.useGetModelsForProvider', () => {
     queryClient.clear();
   });
 
-  it('offers the published flow tiers, labelled by tier, and never a chat-only model', async () => {
+  it('offers the published flow tiers by tier id, never a chat-only tier, and asks for no model list', async () => {
     listModelTiers.mockResolvedValue(PUBLISHED);
     listModelsForProvider.mockResolvedValue(MANAGED_MODELS);
 
@@ -50,40 +50,48 @@ describe('aiModelHooks.useGetModelsForProvider', () => {
 
     await waitFor(() =>
       expect(result.current.data?.map((model) => model.id)).toEqual([
-        'anthropic/claude-haiku-4.5',
-        'anthropic/claude-sonnet-5',
+        'fast',
+        'smart',
+        'premium',
       ]),
     );
     expect(result.current.data?.map((model) => model.name)).toEqual([
       'Fast',
       'Expert',
+      'Heavy',
     ]);
+    expect(listModelsForProvider).not.toHaveBeenCalled();
   });
 
-  it('falls back to the bundled tiers when the tiers request fails', async () => {
+  it('falls back to the bundled tier ids when the tiers request fails', async () => {
     listModelTiers.mockRejectedValue(new Error('tiers endpoint down'));
-    listModelsForProvider.mockResolvedValue(MANAGED_MODELS);
 
     const { result } = renderModels(AIProviderName.ACTIVEPIECES);
 
+    await waitFor(() => expect(listModelTiers).toHaveBeenCalled());
     await waitFor(() =>
       expect(result.current.data?.map((model) => model.id)).toEqual([
-        'anthropic/claude-haiku-4.5',
-        'anthropic/claude-sonnet-4.6',
+        'fast',
+        'smart',
+        'premium',
       ]),
     );
     expect(result.current.data?.map((model) => model.name)).toEqual([
       'Fast',
       'Expert',
+      'Heavy',
     ]);
   });
 
   it('keeps the same list object across renders once resolved', async () => {
     listModelTiers.mockResolvedValue(PUBLISHED);
-    listModelsForProvider.mockResolvedValue(MANAGED_MODELS);
 
     const { result, rerender } = renderModels(AIProviderName.ACTIVEPIECES);
-    await waitFor(() => expect(result.current.data).toHaveLength(2));
+    await waitFor(() =>
+      expect(result.current.data?.map((model) => model.name)).toContain(
+        'Heavy',
+      ),
+    );
     const resolved = result.current.data;
 
     rerender();