Merge remote-tracking branch 'origin/dev' into feat/file-ref-structured-parsing-v2

2026-04-08 03:00:28 -04:00 · 2026-03-17 06:16:49 +07:00
parent 46acc2cfc1 9a41312769
commit 553e224caf
38 changed files with 716 additions and 337 deletions
--- a/.claude/skills/backend-check/SKILL.md
+++ b/.claude/skills/backend-check/SKILL.md
@@ -1,17 +0,0 @@
---
-name: backend-check
-description: Run the full backend formatting, linting, and test suite. Ensures code quality before commits and PRs. TRIGGER when backend Python code has been modified and needs validation.
-user-invocable: true
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
---
-
-# Backend Check
-
-## Steps
-
-1. **Format**: `poetry run format` — runs formatting AND linting. NEVER run ruff/black/isort individually
-2. **Fix** any remaining errors manually, re-run until clean
-3. **Test**: `poetry run test` (runs DB setup + pytest). For specific files: `poetry run pytest -s -vvv <test_files>`
-4. **Snapshots** (if needed): `poetry run pytest path/to/test.py --snapshot-update` — review with `git diff`
--- a/.claude/skills/code-style/SKILL.md
+++ b/.claude/skills/code-style/SKILL.md
@@ -1,35 +0,0 @@
---
-name: code-style
-description: Python code style preferences for the AutoGPT backend. Apply when writing or reviewing Python code. TRIGGER when writing new Python code, reviewing PRs, or refactoring backend code.
-user-invocable: false
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
---
-
-# Code Style
-
-## Imports
-
- **Top-level only** — no local/inner imports. Move all imports to the top of the file.
-
-## Typing
-
- **No duck typing** — avoid `hasattr`, `getattr`, `isinstance` for type dispatch. Use proper typed interfaces, unions, or protocols.
- **Pydantic models** over dataclass, namedtuple, or raw dict for structured data.
- **No linter suppressors** — avoid `# type: ignore`, `# noqa`, `# pyright: ignore` etc. 99% of the time the right fix is fixing the type/code, not silencing the tool.
-
-## Code Structure
-
- **List comprehensions** over manual loop-and-append.
- **Early return** — guard clauses first, avoid deep nesting.
- **Flatten inline** — prefer short, concise expressions. Reduce `if/else` chains with direct returns or ternaries when readable.
- **Modular functions** — break complex logic into small, focused functions rather than long blocks with nested conditionals.
-
-## Review Checklist
-
-Before finishing, always ask:
- Can any function be split into smaller pieces?
- Is there unnecessary nesting that an early return would eliminate?
- Can any loop be a comprehension?
- Is there a simpler way to express this logic?
--- a/.claude/skills/frontend-check/SKILL.md
+++ b/.claude/skills/frontend-check/SKILL.md
@@ -1,16 +0,0 @@
---
-name: frontend-check
-description: Run the full frontend formatting, linting, and type checking suite. Ensures code quality before commits and PRs. TRIGGER when frontend TypeScript/React code has been modified and needs validation.
-user-invocable: true
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
---
-
-# Frontend Check
-
-## Steps (in order)
-
-1. **Format**: `pnpm format` — NEVER run individual formatters
-2. **Lint**: `pnpm lint` — fix errors, re-run until clean
-3. **Types**: `pnpm types` — if it keeps failing after multiple attempts, stop and ask the user
--- a/.claude/skills/new-block/SKILL.md
+++ b/.claude/skills/new-block/SKILL.md
@@ -1,29 +0,0 @@
---
-name: new-block
-description: Create a new backend block following the Block SDK Guide. Guides through provider configuration, schema definition, authentication, and testing. TRIGGER when user asks to create a new block, add a new integration, or build a new node for the graph editor.
-user-invocable: true
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
---
-
-# New Block Creation
-
-Read `docs/platform/block-sdk-guide.md` first for the full guide.
-
-## Steps
-
-1. **Provider config** (if external service): create `_config.py` with `ProviderBuilder`
-2. **Block file** in `backend/blocks/` (from `autogpt_platform/backend/`):
-   - Generate a UUID once with `uuid.uuid4()`, then **hard-code that string** as `id` (IDs must be stable across imports)
-   - `Input(BlockSchema)` and `Output(BlockSchema)` classes
-   - `async def run` that `yield`s output fields
-3. **Files**: use `store_media_file()` with `"for_block_output"` for outputs
-4. **Test**: `poetry run pytest 'backend/blocks/test/test_block.py::test_available_blocks[MyBlock]' -xvs`
-5. **Format**: `poetry run format`
-
-## Rules
-
- Analyze interfaces: do inputs/outputs connect well with other blocks in a graph?
- Use top-level imports, avoid duck typing
- Always use `for_block_output` for block outputs
--- a/.claude/skills/openapi-regen/SKILL.md
+++ b/.claude/skills/openapi-regen/SKILL.md
@@ -1,28 +0,0 @@
---
-name: openapi-regen
-description: Regenerate the OpenAPI spec and frontend API client. Starts the backend REST server, fetches the spec, and regenerates the typed frontend hooks. TRIGGER when API routes change, new endpoints are added, or frontend API types are stale.
-user-invocable: true
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
---
-
-# OpenAPI Spec Regeneration
-
-## Steps
-
-1. **Run end-to-end** in a single shell block (so `REST_PID` persists):
-   ```bash
-   cd autogpt_platform/backend && poetry run rest &
-   REST_PID=$!
-   WAIT=0; until curl -sf http://localhost:8006/health > /dev/null 2>&1; do sleep 1; WAIT=$((WAIT+1)); [ $WAIT -ge 60 ] && echo "Timed out" && kill $REST_PID && exit 1; done
-   cd ../frontend && pnpm generate:api:force
-   kill $REST_PID
-   pnpm types && pnpm lint && pnpm format
-   ```
-
-## Rules
-
- Always use `pnpm generate:api:force` (not `pnpm generate:api`)
- Don't manually edit files in `src/app/api/__generated__/`
- Generated hooks follow: `use{Method}{Version}{OperationName}`
--- a/.claude/skills/pr-address/SKILL.md
+++ b/.claude/skills/pr-address/SKILL.md
@@ -0,0 +1,79 @@
+---
+name: pr-address
+description: Address PR review comments and loop until CI green and all comments resolved. TRIGGER when user asks to address comments, fix PR feedback, respond to reviewers, or babysit/monitor a PR.
+user-invocable: true
+args: "[PR number or URL] — if omitted, finds PR for current branch."
+metadata:
+  author: autogpt-team
+  version: "1.0.0"
+---
+
+# PR Address
+
+## Find the PR
+
+```bash
+gh pr list --head $(git branch --show-current) --repo Significant-Gravitas/AutoGPT
+gh pr view {N}
+```
+
+## Fetch comments (all sources)
+
+```bash
+gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews       # top-level reviews
+gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments      # inline review comments
+gh api repos/Significant-Gravitas/AutoGPT/issues/{N}/comments     # PR conversation comments
+```
+
+**Bots to watch for:**
+- `autogpt-reviewer` — posts "Blockers", "Should Fix", "Nice to Have". Address ALL of them.
+- `sentry[bot]` — bug predictions. Fix real bugs, explain false positives.
+- `coderabbitai[bot]` — automated review. Address actionable items.
+
+## For each unaddressed comment
+
+Address comments **one at a time**: fix → commit → push → inline reply → next.
+
+1. Read the referenced code, make the fix (or reply explaining why it's not needed)
+2. Commit and push the fix
+3. Reply **inline** (not as a new top-level comment) referencing the fixing commit — this is what resolves the conversation for bot reviewers (coderabbitai, sentry):
+
+| Comment type | How to reply |
+|---|---|
+| Inline review (`pulls/{N}/comments`) | `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments/{ID}/replies -f body="Fixed in <commit-sha>: <description>"` |
+| Conversation (`issues/{N}/comments`) | `gh api repos/Significant-Gravitas/AutoGPT/issues/{N}/comments -f body="Fixed in <commit-sha>: <description>"` |
+
+## Format and commit
+
+After fixing, format the changed code:
+
+- **Backend** (from `autogpt_platform/backend/`): `poetry run format`
+- **Frontend** (from `autogpt_platform/frontend/`): `pnpm format && pnpm lint && pnpm types`
+
+If API routes changed, regenerate the frontend client:
+```bash
+cd autogpt_platform/backend && poetry run rest &
+REST_PID=$!
+trap "kill $REST_PID 2>/dev/null" EXIT
+WAIT=0; until curl -sf http://localhost:8006/health > /dev/null 2>&1; do sleep 1; WAIT=$((WAIT+1)); [ $WAIT -ge 60 ] && echo "Timed out" && exit 1; done
+cd ../frontend && pnpm generate:api:force
+kill $REST_PID 2>/dev/null; trap - EXIT
+```
+Never manually edit files in `src/app/api/__generated__/`.
+
+Then commit and **push immediately** — never batch commits without pushing.
+
+For backend commits in worktrees: `poetry run git commit` (pre-commit hooks).
+
+## The loop
+
+```text
+address comments → format → commit → push
+→ re-check comments → fix new ones → push
+→ wait for CI → re-check comments after CI settles
+→ repeat until: all comments addressed AND CI green AND no new comments arriving
+```
+
+While CI runs, stay productive: run local tests, address remaining comments.
+
+**The loop ends when:** CI fully green + all comments addressed + no new comments since CI settled.
--- a/.claude/skills/pr-create/SKILL.md
+++ b/.claude/skills/pr-create/SKILL.md
@@ -1,31 +0,0 @@
---
-name: pr-create
-description: Create a pull request for the current branch. TRIGGER when user asks to create a PR, open a pull request, push changes for review, or submit work for merging.
-user-invocable: true
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
---
-
-# Create Pull Request
-
-## Steps
-
-1. **Check for existing PR**: `gh pr view --json url -q .url 2>/dev/null` — if a PR already exists, output its URL and stop
-2. **Understand changes**: `git status`, `git diff dev...HEAD`, `git log dev..HEAD --oneline`
-3. **Read PR template**: `.github/PULL_REQUEST_TEMPLATE.md`
-4. **Draft PR title**: Use conventional commits format (see CLAUDE.md for types and scopes)
-5. **Fill out PR template** as the body — be thorough in the Changes section
-6. **Format first** (if relevant changes exist):
-   - Backend: `cd autogpt_platform/backend && poetry run format`
-   - Frontend: `cd autogpt_platform/frontend && pnpm format`
-   - Fix any lint errors, then commit formatting changes before pushing
-7. **Push**: `git push -u origin HEAD`
-8. **Create PR**: `gh pr create --base dev`
-9. **Output** the PR URL
-
-## Rules
-
- Always target `dev` branch
- Do NOT run tests — CI will handle that
- Use the PR template from `.github/PULL_REQUEST_TEMPLATE.md`
--- a/.claude/skills/pr-review/SKILL.md
+++ b/.claude/skills/pr-review/SKILL.md
@@ -1,51 +1,74 @@
 ---
 name: pr-review
-description: Address all open PR review comments systematically. Fetches comments, addresses each one, reacts +1/-1, and replies when clarification is needed. Keeps iterating until all comments are addressed and CI is green. TRIGGER when user shares a PR URL, asks to address review comments, fix PR feedback, or respond to reviewer comments.
+description: Review a PR for correctness, security, code quality, and testing issues. TRIGGER when user asks to review a PR, check PR quality, or give feedback on a PR.
 user-invocable: true
+args: "[PR number or URL] — if omitted, finds PR for current branch."
 metadata:
  author: autogpt-team
  version: "1.0.0"
 ---

-# PR Review Comment Workflow
+# PR Review

-## Steps
+## Find the PR

-1. **Find PR**: `gh pr list --head $(git branch --show-current) --repo Significant-Gravitas/AutoGPT`
-2. **Fetch comments** (all three sources):
-   - `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews` (top-level reviews)
-   - `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments` (inline review comments)
-   - `gh api repos/Significant-Gravitas/AutoGPT/issues/{N}/comments` (PR conversation comments)
-3. **Skip** comments already reacted to by PR author
-4. **For each unreacted comment**:
-   - Read referenced code, make the fix (or reply if you disagree/need info)
-   - **Inline review comments** (`pulls/{N}/comments`):
-     - React: `gh api repos/.../pulls/comments/{ID}/reactions -f content="+1"` (or `-1`)
-     - Reply: `gh api repos/.../pulls/{N}/comments/{ID}/replies -f body="..."`
-   - **PR conversation comments** (`issues/{N}/comments`):
-     - React: `gh api repos/.../issues/comments/{ID}/reactions -f content="+1"` (or `-1`)
-     - No threaded replies — post a new issue comment if needed
-   - **Top-level reviews**: no reaction API — address in code, reply via issue comment if needed
-5. **Include autogpt-reviewer bot fixes** too
-6. **Format**: `cd autogpt_platform/backend && poetry run format`, `cd autogpt_platform/frontend && pnpm format`
-7. **Commit & push**
-8. **Re-fetch comments** immediately — address any new unreacted ones before waiting on CI
-9. **Stay productive while CI runs** — don't idle. In priority order:
-   - Run any pending local tests (`poetry run pytest`, e2e, etc.) and fix failures
-   - Address any remaining comments
-   - Only poll `gh pr checks {N}` as the last resort when there's truly nothing left to do
-10. **If CI fails** — fix, go back to step 6
-11. **Re-fetch comments again** after CI is green — address anything that appeared while CI was running
-12. **Done** only when: all comments reacted AND CI is green.
+```bash
+gh pr list --head $(git branch --show-current) --repo Significant-Gravitas/AutoGPT
+gh pr view {N}
+```

-## CRITICAL: Do Not Stop
+## Read the diff

-**Loop is: address → format → commit → push → re-check comments → run local tests → wait CI → re-check comments → repeat.**
+```bash
+gh pr diff {N}
+```

-Never idle. If CI is running and you have nothing to address, run local tests. Waiting on CI is the last resort.
+## Fetch existing review comments

-## Rules
+Before posting anything, fetch existing inline comments to avoid duplicates:

- One todo per comment
- For inline review comments: reply on existing threads. For PR conversation comments: post a new issue comment (API doesn't support threaded replies)
- React to every comment: +1 addressed, -1 disagreed (with explanation)
+```bash
+gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments
+gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews
+```
+
+## What to check
+
+**Correctness:** logic errors, off-by-one, missing edge cases, race conditions (TOCTOU in file access, credit charging), error handling gaps, async correctness (missing `await`, unclosed resources).
+
+**Security:** input validation at boundaries, no injection (command, XSS, SQL), secrets not logged, file paths sanitized (`os.path.basename()` in error messages).
+
+**Code quality:** apply rules from backend/frontend CLAUDE.md files.
+
+**Architecture:** DRY, single responsibility, modular functions. `Security()` vs `Depends()` for FastAPI auth. `data:` for SSE events, `: comment` for heartbeats. `transaction=True` for Redis pipelines.
+
+**Testing:** edge cases covered, colocated `*_test.py` (backend) / `__tests__/` (frontend), mocks target where symbol is **used** not defined, `AsyncMock` for async.
+
+## Output format
+
+Every comment **must** be prefixed with `🤖` and a criticality badge:
+
+| Tier | Badge | Meaning |
+|---|---|---|
+| Blocker | `🔴 **Blocker**` | Must fix before merge |
+| Should Fix | `🟠 **Should Fix**` | Important improvement |
+| Nice to Have | `🟡 **Nice to Have**` | Minor suggestion |
+| Nit | `🔵 **Nit**` | Style / wording |
+
+Example: `🤖 🔴 **Blocker**: Missing error handling for X — suggest wrapping in try/except.`
+
+## Post inline comments
+
+For each finding, post an inline comment on the PR (do not just write a local report):
+
+```bash
+# Get the latest commit SHA for the PR
+COMMIT_SHA=$(gh api repos/Significant-Gravitas/AutoGPT/pulls/{N} --jq '.head.sha')
+
+# Post an inline comment on a specific file/line
+gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments \
+  -f body="🤖 🔴 **Blocker**: <description>" \
+  -f commit_id="$COMMIT_SHA" \
+  -f path="<file path>" \
+  -F line=<line number>
+```
--- a/.claude/skills/worktree-setup/SKILL.md
+++ b/.claude/skills/worktree-setup/SKILL.md
@@ -1,45 +0,0 @@
---
-name: worktree-setup
-description: Set up a new git worktree for parallel development. Creates the worktree, copies .env files, installs dependencies, generates Prisma client, and optionally starts the app (with port conflict resolution) or runs tests. TRIGGER when user asks to set up a worktree, work on a branch in isolation, or needs a separate environment for a branch or PR.
-user-invocable: true
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
---
-
-# Worktree Setup
-
-## Preferred: Use Branchlet
-
-The repo has a `.branchlet.json` config — it handles env file copying, dependency installation, and Prisma generation automatically.
-
-```bash
-npm install -g branchlet                                      # install once
-branchlet create -n <name> -s <source-branch> -b <new-branch>
-branchlet list --json   # list all worktrees
-```
-
-## Manual Fallback
-
-If branchlet isn't available:
-
-1. `git worktree add ../<RepoName><N> <branch-name>`
-2. Copy `.env` files: `backend/.env`, `frontend/.env`, `autogpt_platform/.env`, `db/docker/.env`
-3. Install deps:
-   - `cd autogpt_platform/backend && poetry install && poetry run prisma generate`
-   - `cd autogpt_platform/frontend && pnpm install`
-
-## Running the App
-
-Free ports first — backend uses: 8001, 8002, 8003, 8005, 8006, 8007, 8008.
-
-```bash
-for port in 8001 8002 8003 8005 8006 8007 8008; do
-  lsof -ti :$port | xargs kill -9 2>/dev/null || true
-done
-cd <worktree>/autogpt_platform/backend && poetry run app
-```
-
-## CoPilot Testing Gotcha
-
-SDK mode spawns a Claude subprocess — **won't work inside Claude Code**. Set `CHAT_USE_CLAUDE_AGENT_SDK=false` in `backend/.env` to use baseline mode.
--- a/.claude/skills/worktree/SKILL.md
+++ b/.claude/skills/worktree/SKILL.md
@@ -0,0 +1,85 @@
+---
+name: worktree
+description: Set up a new git worktree for parallel development. Creates the worktree, copies .env files, installs dependencies, and generates Prisma client. TRIGGER when user asks to set up a worktree, work on a branch in isolation, or needs a separate environment for a branch or PR.
+user-invocable: true
+args: "[name] — optional worktree name (e.g., 'AutoGPT7'). If omitted, uses next available AutoGPT<N>."
+metadata:
+  author: autogpt-team
+  version: "3.0.0"
+---
+
+# Worktree Setup
+
+## Create the worktree
+
+Derive paths from the git toplevel. If a name is provided as argument, use it. Otherwise, check `git worktree list` and pick the next `AutoGPT<N>`.
+
+```bash
+ROOT=$(git rev-parse --show-toplevel)
+PARENT=$(dirname "$ROOT")
+
+# From an existing branch
+git worktree add "$PARENT/<NAME>" <branch-name>
+
+# From a new branch off dev
+git worktree add -b <new-branch> "$PARENT/<NAME>" dev
+```
+
+## Copy environment files
+
+Copy `.env` from the root worktree. Falls back to `.env.default` if `.env` doesn't exist.
+
+```bash
+ROOT=$(git rev-parse --show-toplevel)
+TARGET="$(dirname "$ROOT")/<NAME>"
+
+for envpath in autogpt_platform/backend autogpt_platform/frontend autogpt_platform; do
+  if [ -f "$ROOT/$envpath/.env" ]; then
+    cp "$ROOT/$envpath/.env" "$TARGET/$envpath/.env"
+  elif [ -f "$ROOT/$envpath/.env.default" ]; then
+    cp "$ROOT/$envpath/.env.default" "$TARGET/$envpath/.env"
+  fi
+done
+```
+
+## Install dependencies
+
+```bash
+TARGET="$(dirname "$(git rev-parse --show-toplevel)")/<NAME>"
+cd "$TARGET/autogpt_platform/autogpt_libs" && poetry install
+cd "$TARGET/autogpt_platform/backend" && poetry install && poetry run prisma generate
+cd "$TARGET/autogpt_platform/frontend" && pnpm install
+```
+
+Replace `<NAME>` with the actual worktree name (e.g., `AutoGPT7`).
+
+## Running the app (optional)
+
+Backend uses ports: 8001, 8002, 8003, 8005, 8006, 8007, 8008. Free them first if needed:
+
+```bash
+TARGET="$(dirname "$(git rev-parse --show-toplevel)")/<NAME>"
+for port in 8001 8002 8003 8005 8006 8007 8008; do
+  lsof -ti :$port | xargs kill -9 2>/dev/null || true
+done
+cd "$TARGET/autogpt_platform/backend" && poetry run app
+```
+
+## CoPilot testing
+
+SDK mode spawns a Claude subprocess — won't work inside Claude Code. Set `CHAT_USE_CLAUDE_AGENT_SDK=false` in `backend/.env` to use baseline mode.
+
+## Cleanup
+
+```bash
+# Replace <NAME> with the actual worktree name (e.g., AutoGPT7)
+git worktree remove "$(dirname "$(git rev-parse --show-toplevel)")/<NAME>"
+```
+
+## Alternative: Branchlet (optional)
+
+If [branchlet](https://www.npmjs.com/package/branchlet) is installed:
+
+```bash
+branchlet create -n <name> -s <source-branch> -b <new-branch>
+```
--- a/autogpt_platform/CLAUDE.md
+++ b/autogpt_platform/CLAUDE.md
@@ -60,9 +60,12 @@ AutoGPT Platform is a monorepo containing:

 ### Reviewing/Revising Pull Requests

- When the user runs /pr-comments or tries to fetch them, also run gh api /repos/Significant-Gravitas/AutoGPT/pulls/[issuenum]/reviews to get the reviews
- Use gh api /repos/Significant-Gravitas/AutoGPT/pulls/[issuenum]/reviews/[review_id]/comments to get the review contents
- Use gh api /repos/Significant-Gravitas/AutoGPT/issues/9924/comments to get the pr specific comments
+Use `/pr-review` to review a PR or `/pr-address` to address comments.
+
+When fetching comments manually:
+- `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews` — top-level reviews
+- `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments` — inline review comments
+- `gh api repos/Significant-Gravitas/AutoGPT/issues/{N}/comments` — PR conversation comments

 ### Conventional Commits

--- a/autogpt_platform/backend/CLAUDE.md
+++ b/autogpt_platform/backend/CLAUDE.md
@@ -58,10 +58,31 @@ poetry run pytest path/to/test.py --snapshot-update
 - **Authentication**: JWT-based with Supabase integration
 - **Security**: Cache protection middleware prevents sensitive data caching in browsers/proxies

+## Code Style
+
+- **Top-level imports only** — no local/inner imports (lazy imports only for heavy optional deps like `openpyxl`)
+- **No duck typing** — no `hasattr`/`getattr`/`isinstance` for type dispatch; use typed interfaces/unions/protocols
+- **Pydantic models** over dataclass/namedtuple/dict for structured data
+- **No linter suppressors** — no `# type: ignore`, `# noqa`, `# pyright: ignore`; fix the type/code
+- **List comprehensions** over manual loop-and-append
+- **Early return** — guard clauses first, avoid deep nesting
+- **Lazy `%s` logging** — `logger.info("Processing %s items", count)` not `logger.info(f"Processing {count} items")`
+- **Sanitize error paths** — `os.path.basename()` in error messages to avoid leaking directory structure
+- **TOCTOU awareness** — avoid check-then-act patterns for file access and credit charging
+- **`Security()` vs `Depends()`** — use `Security()` for auth deps to get proper OpenAPI security spec
+- **Redis pipelines** — `transaction=True` for atomicity on multi-step operations
+- **`max(0, value)` guards** — for computed values that should never be negative
+- **SSE protocol** — `data:` lines for frontend-parsed events (must match Zod schema), `: comment` lines for heartbeats/status
+- **File length** — keep files under ~300 lines; if a file grows beyond this, split by responsibility (e.g. extract helpers, models, or a sub-module into a new file). Never keep appending to a long file.
+- **Function length** — keep functions under ~40 lines; extract named helpers when a function grows longer. Long functions are a sign of mixed concerns, not complexity.
+
 ## Testing Approach

 - Uses pytest with snapshot testing for API responses
 - Test files are colocated with source files (`*_test.py`)
+- Mock at boundaries — mock where the symbol is **used**, not where it's **defined**
+- After refactoring, update mock targets to match new module paths
+- Use `AsyncMock` for async functions (`from unittest.mock import AsyncMock`)

 ## Database Schema

--- a/autogpt_platform/backend/backend/executor/manager.py
+++ b/autogpt_platform/backend/backend/executor/manager.py
@@ -61,7 +61,12 @@ from backend.util.decorator import (
    error_logged,
    time_measured,
 )
-from backend.util.exceptions import InsufficientBalanceError, ModerationError
+from backend.util.exceptions import (
+    GraphNotFoundError,
+    InsufficientBalanceError,
+    ModerationError,
+    NotFoundError,
+)
 from backend.util.file import clean_exec_files
 from backend.util.logging import TruncatedLogger, configure_logging
 from backend.util.metrics import DiscordChannel
@@ -375,9 +380,16 @@ async def execute_node(
            log_metadata.debug("Node produced output", **{output_name: output_data})
            yield output_name, output_data
    except Exception as ex:
-        # Capture exception WITH context still set before restoring scope
-        sentry_sdk.capture_exception(error=ex, scope=scope)
-        sentry_sdk.flush()  # Ensure it's sent before we restore scope
+        # Only capture unexpected errors to Sentry, not user-caused ones.
+        # Most ValueError subclasses here are expected (BlockExecutionError,
+        # InsufficientBalanceError, plain ValueError for auth/disabled blocks, etc.)
+        # but NotFoundError/GraphNotFoundError could indicate real platform issues.
+        is_expected = isinstance(ex, ValueError) and not isinstance(
+            ex, (NotFoundError, GraphNotFoundError)
+        )
+        if not is_expected:
+            sentry_sdk.capture_exception(error=ex, scope=scope)
+            sentry_sdk.flush()
        # Re-raise to maintain normal error flow
        raise
    finally:
@@ -1478,7 +1490,7 @@ class ExecutionProcessor:
                    alert_message, DiscordChannel.PRODUCT
                )
            except Exception as e:
-                logger.error(f"Failed to send low balance Discord alert: {e}")
+                logger.warning(f"Failed to send low balance Discord alert: {e}")


 class ExecutionManager(AppProcess):
@@ -1900,17 +1912,16 @@ class ExecutionManager(AppProcess):
            channel = client.get_channel()
            channel.connection.add_callback_threadsafe(lambda: channel.stop_consuming())

-            try:
-                thread.join(timeout=300)
-            except TimeoutError:
-                logger.error(
+            thread.join(timeout=300)
+            if thread.is_alive():
+                logger.warning(
                    f"{prefix} ⚠️ Run thread did not finish in time, forcing disconnect"
                )

            client.disconnect()
            logger.info(f"{prefix} ✅ Run client disconnected")
        except Exception as e:
-            logger.error(f"{prefix} ⚠️ Error disconnecting run client: {type(e)} {e}")
+            logger.warning(f"{prefix} ⚠️ Error disconnecting run client: {type(e)} {e}")

    def cleanup(self):
        """Override cleanup to implement graceful shutdown with active execution waiting."""
@@ -1926,7 +1937,9 @@ class ExecutionManager(AppProcess):
            )
            logger.info(f"{prefix} ✅ Exec consumer has been signaled to stop")
        except Exception as e:
-            logger.error(f"{prefix} ⚠️ Error signaling consumer to stop: {type(e)} {e}")
+            logger.warning(
+                f"{prefix} ⚠️ Error signaling consumer to stop: {type(e)} {e}"
+            )

        # Wait for active executions to complete
        if self.active_graph_runs:
@@ -1957,7 +1970,7 @@ class ExecutionManager(AppProcess):
                waited += wait_interval

            if self.active_graph_runs:
-                logger.error(
+                logger.warning(
                    f"{prefix} ⚠️ {len(self.active_graph_runs)} executions still running after {max_wait}s"
                )
            else:
@@ -1968,7 +1981,7 @@ class ExecutionManager(AppProcess):
            self.executor.shutdown(cancel_futures=True, wait=False)
            logger.info(f"{prefix} ✅ Executor shutdown completed")
        except Exception as e:
-            logger.error(f"{prefix} ⚠️ Error during executor shutdown: {type(e)} {e}")
+            logger.warning(f"{prefix} ⚠️ Error during executor shutdown: {type(e)} {e}")

        # Release remaining execution locks
        try:
--- a/autogpt_platform/backend/backend/executor/scheduler.py
+++ b/autogpt_platform/backend/backend/executor/scheduler.py
@@ -94,7 +94,7 @@ SCHEDULER_OPERATION_TIMEOUT_SECONDS = 300  # 5 minutes for scheduler operations
 def job_listener(event):
    """Logs job execution outcomes for better monitoring."""
    if event.exception:
-        logger.error(
+        logger.warning(
            f"Job {event.job_id} failed: {type(event.exception).__name__}: {event.exception}"
        )
    else:
@@ -137,7 +137,7 @@ def run_async(coro, timeout: float = SCHEDULER_OPERATION_TIMEOUT_SECONDS):
    try:
        return future.result(timeout=timeout)
    except Exception as e:
-        logger.error(f"Async operation failed: {type(e).__name__}: {e}")
+        logger.warning(f"Async operation failed: {type(e).__name__}: {e}")
        raise


@@ -186,7 +186,7 @@ async def _execute_graph(**kwargs):


 async def _handle_graph_validation_error(args: "GraphExecutionJobArgs") -> None:
-    logger.error(
+    logger.warning(
        f"Scheduled Graph {args.graph_id} failed validation. Unscheduling graph"
    )
    if args.schedule_id:
@@ -196,8 +196,9 @@ async def _handle_graph_validation_error(args: "GraphExecutionJobArgs") -> None:
            user_id=args.user_id,
        )
    else:
-        logger.error(
-            f"Unable to unschedule graph: {args.graph_id} as this is an old job with no associated schedule_id please remove manually"
+        logger.warning(
+            f"Unable to unschedule graph: {args.graph_id} as this is an old job "
+            f"with no associated schedule_id please remove manually"
        )


--- a/autogpt_platform/backend/backend/notifications/notifications.py
+++ b/autogpt_platform/backend/backend/notifications/notifications.py
@@ -303,9 +303,9 @@ class NotificationManager(AppService):
                    )

                    if not oldest_message:
-                        # this should never happen
-                        logger.error(
-                            f"Batch for user {batch.user_id} and type {notification_type} has no oldest message whichshould never happen!!!!!!!!!!!!!!!!"
+                        logger.warning(
+                            f"Batch for user {batch.user_id} and type {notification_type} "
+                            f"has no oldest message — batch may have been cleared concurrently"
                        )
                        continue

@@ -318,7 +318,7 @@ class NotificationManager(AppService):
                        ).get_user_email_by_id(batch.user_id)

                        if not recipient_email:
-                            logger.error(
+                            logger.warning(
                                f"User email not found for user {batch.user_id}"
                            )
                            continue
@@ -344,7 +344,7 @@ class NotificationManager(AppService):
                        ).get_user_notification_batch(batch.user_id, notification_type)

                        if not batch_data or not batch_data.notifications:
-                            logger.error(
+                            logger.warning(
                                f"Batch data not found for user {batch.user_id}"
                            )
                            # Clear the batch
@@ -372,7 +372,7 @@ class NotificationManager(AppService):
                                    )
                                )
                            except Exception as e:
-                                logger.error(
+                                logger.warning(
                                    f"Error parsing notification event: {e=}, {db_event=}"
                                )
                                continue
@@ -415,7 +415,10 @@ class NotificationManager(AppService):
    async def discord_system_alert(
        self, content: str, channel: DiscordChannel = DiscordChannel.PLATFORM
    ):
-        await discord_send_alert(content, channel)
+        try:
+            await discord_send_alert(content, channel)
+        except Exception as e:
+            logger.warning(f"Failed to send Discord system alert: {e}")

    async def _queue_scheduled_notification(self, event: SummaryParamsEventModel):
        """Queue a scheduled notification - exposed method for other services to call"""
@@ -516,7 +519,7 @@ class NotificationManager(AppService):
                raise ValueError("Invalid event type or params")

        except Exception as e:
-            logger.error(f"Failed to gather summary data: {e}")
+            logger.warning(f"Failed to gather summary data: {e}")
            # Return sensible defaults in case of error
            if event_type == NotificationType.DAILY_SUMMARY and isinstance(
                params, DailySummaryParams
@@ -562,8 +565,9 @@ class NotificationManager(AppService):
            should_retry=False
        ).get_user_notification_oldest_message_in_batch(user_id, event_type)
        if not oldest_message:
-            logger.error(
-                f"Batch for user {user_id} and type {event_type} has no oldest message whichshould never happen!!!!!!!!!!!!!!!!"
+            logger.warning(
+                f"Batch for user {user_id} and type {event_type} "
+                f"has no oldest message — batch may have been cleared concurrently"
            )
            return False
        oldest_age = oldest_message.created_at
@@ -585,7 +589,7 @@ class NotificationManager(AppService):
                get_notif_data_type(event.type)
            ].model_validate_json(message)
        except Exception as e:
-            logger.error(f"Error parsing message due to non matching schema {e}")
+            logger.warning(f"Error parsing message due to non matching schema {e}")
            return None

    async def _process_admin_message(self, message: str) -> bool:
@@ -614,7 +618,7 @@ class NotificationManager(AppService):
                should_retry=False
            ).get_user_email_by_id(event.user_id)
            if not recipient_email:
-                logger.error(f"User email not found for user {event.user_id}")
+                logger.warning(f"User email not found for user {event.user_id}")
                return False

            should_send = await self._should_email_user_based_on_preference(
@@ -651,7 +655,7 @@ class NotificationManager(AppService):
                should_retry=False
            ).get_user_email_by_id(event.user_id)
            if not recipient_email:
-                logger.error(f"User email not found for user {event.user_id}")
+                logger.warning(f"User email not found for user {event.user_id}")
                return False

            should_send = await self._should_email_user_based_on_preference(
@@ -672,7 +676,7 @@ class NotificationManager(AppService):
                should_retry=False
            ).get_user_notification_batch(event.user_id, event.type)
            if not batch or not batch.notifications:
-                logger.error(f"Batch not found for user {event.user_id}")
+                logger.warning(f"Batch not found for user {event.user_id}")
                return False
            unsub_link = generate_unsubscribe_link(event.user_id)

@@ -745,7 +749,7 @@ class NotificationManager(AppService):
                                        f"Removed {len(chunk_ids)} sent notifications from batch"
                                    )
                                except Exception as e:
-                                    logger.error(
+                                    logger.warning(
                                        f"Failed to remove sent notifications: {e}"
                                    )
                                    # Continue anyway - better to risk duplicates than lose emails
@@ -770,7 +774,7 @@ class NotificationManager(AppService):
                        else:
                            # Message is too large even after size reduction
                            if attempt_size == 1:
-                                logger.error(
+                                logger.warning(
                                    f"Failed to send notification at index {i}: "
                                    f"Single notification exceeds email size limit "
                                    f"({len(test_message):,} chars > {MAX_EMAIL_SIZE:,} chars). "
@@ -789,7 +793,7 @@ class NotificationManager(AppService):
                                            f"Removed oversized notification {chunk_ids[0]} from batch permanently"
                                        )
                                    except Exception as e:
-                                        logger.error(
+                                        logger.warning(
                                            f"Failed to remove oversized notification: {e}"
                                        )

@@ -823,7 +827,7 @@ class NotificationManager(AppService):
                                        f"Set email verification to false for user {event.user_id}"
                                    )
                                except Exception as deactivation_error:
-                                    logger.error(
+                                    logger.warning(
                                        f"Failed to deactivate email for user {event.user_id}: "
                                        f"{deactivation_error}"
                                    )
@@ -835,7 +839,7 @@ class NotificationManager(AppService):
                                        f"Disabled all notification preferences for user {event.user_id}"
                                    )
                                except Exception as disable_error:
-                                    logger.error(
+                                    logger.warning(
                                        f"Failed to disable notification preferences: {disable_error}"
                                    )

@@ -848,7 +852,7 @@ class NotificationManager(AppService):
                                        f"Cleared ALL notification batches for user {event.user_id}"
                                    )
                                except Exception as remove_error:
-                                    logger.error(
+                                    logger.warning(
                                        f"Failed to clear batches for inactive recipient: {remove_error}"
                                    )

@@ -859,7 +863,7 @@ class NotificationManager(AppService):
                                "422" in error_message
                                or "unprocessable" in error_message
                            ):
-                                logger.error(
+                                logger.warning(
                                    f"Failed to send notification at index {i}: "
                                    f"Malformed notification data rejected by Postmark. "
                                    f"Error: {e}. Removing from batch permanently."
@@ -877,7 +881,7 @@ class NotificationManager(AppService):
                                            "Removed malformed notification from batch permanently"
                                        )
                                    except Exception as remove_error:
-                                        logger.error(
+                                        logger.warning(
                                            f"Failed to remove malformed notification: {remove_error}"
                                        )
                            # Check if it's a ValueError for size limit
@@ -885,14 +889,14 @@ class NotificationManager(AppService):
                                isinstance(e, ValueError)
                                and "too large" in error_message
                            ):
-                                logger.error(
+                                logger.warning(
                                    f"Failed to send notification at index {i}: "
                                    f"Notification size exceeds email limit. "
                                    f"Error: {e}. Skipping this notification."
                                )
                            # Other API errors
                            else:
-                                logger.error(
+                                logger.warning(
                                    f"Failed to send notification at index {i}: "
                                    f"Email API error ({error_type}): {e}. "
                                    f"Skipping this notification."
@@ -907,7 +911,9 @@ class NotificationManager(AppService):

                if not chunk_sent:
                    # Should not reach here due to single notification handling
-                    logger.error(f"Failed to send notifications starting at index {i}")
+                    logger.warning(
+                        f"Failed to send notifications starting at index {i}"
+                    )
                    failed_indices.append(i)
                    i += 1

@@ -946,7 +952,7 @@ class NotificationManager(AppService):
                should_retry=False
            ).get_user_email_by_id(event.user_id)
            if not recipient_email:
-                logger.error(f"User email not found for user {event.user_id}")
+                logger.warning(f"User email not found for user {event.user_id}")
                return False
            should_send = await self._should_email_user_based_on_preference(
                event.user_id, event.type
@@ -1007,7 +1013,10 @@ class NotificationManager(AppService):
                        # Let message.process() handle the rejection
                        pass
                    except Exception as e:
-                        logger.error(f"Error processing message in {queue_name}: {e}")
+                        logger.warning(
+                            f"Error processing message in {queue_name}: {e}",
+                            exc_info=True,
+                        )
                        # Let message.process() handle the rejection
                        raise
        except asyncio.CancelledError:
--- a/autogpt_platform/backend/backend/notifications/test_notifications.py
+++ b/autogpt_platform/backend/backend/notifications/test_notifications.py
@@ -256,9 +256,9 @@ class TestNotificationErrorHandling:
            assert 2 not in successful_indices  # Index 2 failed

            # Verify 422 error was logged
-            error_calls = [call[0][0] for call in mock_logger.error.call_args_list]
+            warning_calls = [call[0][0] for call in mock_logger.warning.call_args_list]
            assert any(
-                "422" in call or "malformed" in call.lower() for call in error_calls
+                "422" in call or "malformed" in call.lower() for call in warning_calls
            )

            # Verify all notifications were removed (4 successful + 1 malformed)
@@ -371,10 +371,10 @@ class TestNotificationErrorHandling:
            assert 3 not in successful_indices  # Index 3 was not sent

            # Verify oversized error was logged
-            error_calls = [call[0][0] for call in mock_logger.error.call_args_list]
+            warning_calls = [call[0][0] for call in mock_logger.warning.call_args_list]
            assert any(
                "exceeds email size limit" in call or "oversized" in call.lower()
-                for call in error_calls
+                for call in warning_calls
            )

    @pytest.mark.asyncio
@@ -478,10 +478,10 @@ class TestNotificationErrorHandling:
            assert 1 in failed_indices  # Index 1 failed

            # Verify generic error was logged
-            error_calls = [call[0][0] for call in mock_logger.error.call_args_list]
+            warning_calls = [call[0][0] for call in mock_logger.warning.call_args_list]
            assert any(
                "api error" in call.lower() or "skipping" in call.lower()
-                for call in error_calls
+                for call in warning_calls
            )

            # Only successful ones should be removed from batch (failed one stays for retry)
--- a/autogpt_platform/backend/backend/util/cloud_storage.py
+++ b/autogpt_platform/backend/backend/util/cloud_storage.py
@@ -613,5 +613,5 @@ async def cleanup_expired_files_async() -> int:
            )
            return deleted_count
        except Exception as e:
-            logger.error(f"[CloudStorage] Error during cloud storage cleanup: {e}")
+            logger.warning(f"[CloudStorage] Error during cloud storage cleanup: {e}")
            return 0
--- a/autogpt_platform/backend/backend/util/metrics.py
+++ b/autogpt_platform/backend/backend/util/metrics.py
@@ -10,7 +10,7 @@ from sentry_sdk.integrations.launchdarkly import LaunchDarklyIntegration
 from sentry_sdk.integrations.logging import LoggingIntegration

 from backend.util import feature_flag
-from backend.util.settings import Settings
+from backend.util.settings import BehaveAs, Settings

 settings = Settings()
 logger = logging.getLogger(__name__)
@@ -21,6 +21,95 @@ class DiscordChannel(str, Enum):
    PRODUCT = "product"  # For product alerts (low balance, zero balance, etc.)


+def _before_send(event, hint):
+    """Filter out expected/transient errors from Sentry to reduce noise."""
+    if "exc_info" in hint:
+        exc_type, exc_value, _ = hint["exc_info"]
+        exc_msg = str(exc_value).lower() if exc_value else ""
+
+        # AMQP/RabbitMQ transient connection errors — expected during deploys
+        amqp_keywords = [
+            "amqpconnection",
+            "amqpconnector",
+            "connection_forced",
+            "channelinvalidstateerror",
+            "no active transport",
+        ]
+        if any(kw in exc_msg for kw in amqp_keywords):
+            return None
+
+        # "connection refused" only for AMQP-related exceptions (not other services)
+        if "connection refused" in exc_msg:
+            exc_module = getattr(exc_type, "__module__", "") or ""
+            exc_name = getattr(exc_type, "__name__", "") or ""
+            amqp_indicators = ["aio_pika", "aiormq", "amqp", "pika", "rabbitmq"]
+            if any(
+                ind in exc_module.lower() or ind in exc_name.lower()
+                for ind in amqp_indicators
+            ) or any(kw in exc_msg for kw in ["amqp", "pika", "rabbitmq"]):
+                return None
+
+        # User-caused credential/auth errors — not platform bugs
+        user_auth_keywords = [
+            "incorrect api key",
+            "invalid x-api-key",
+            "missing authentication header",
+            "invalid api token",
+            "authentication_error",
+        ]
+        if any(kw in exc_msg for kw in user_auth_keywords):
+            return None
+
+        # Expected business logic — insufficient balance
+        if "insufficient balance" in exc_msg or "no credits left" in exc_msg:
+            return None
+
+        # Expected security check — blocked IP access
+        if "access to blocked or private ip" in exc_msg:
+            return None
+
+        # Discord bot token misconfiguration — not a platform error
+        if "improper token has been passed" in exc_msg or (
+            exc_type and exc_type.__name__ == "Forbidden" and "50001" in exc_msg
+        ):
+            return None
+
+        # Google metadata DNS errors — expected in non-GCP environments
+        if (
+            "metadata.google.internal" in exc_msg
+            and settings.config.behave_as != BehaveAs.CLOUD
+        ):
+            return None
+
+        # Inactive email recipients — expected for bounced addresses
+        if "marked as inactive" in exc_msg or "inactive addresses" in exc_msg:
+            return None
+
+    # Also filter log-based events for known noisy messages.
+    # Sentry's LoggingIntegration stores log messages under "logentry", not "message".
+    logentry = event.get("logentry") or {}
+    log_msg = (
+        logentry.get("formatted") or logentry.get("message") or event.get("message")
+    )
+    if event.get("logger") and log_msg:
+        msg = log_msg.lower()
+        noisy_patterns = [
+            "amqpconnection",
+            "connection_forced",
+            "unclosed client session",
+            "unclosed connector",
+        ]
+        if any(p in msg for p in noisy_patterns):
+            return None
+        # "connection refused" in logs only when AMQP-related context is present
+        if "connection refused" in msg and any(
+            ind in msg for ind in ("amqp", "pika", "rabbitmq", "aio_pika", "aiormq")
+        ):
+            return None
+
+    return event
+
+
 def sentry_init():
    sentry_dsn = settings.secrets.sentry_dsn
    integrations = []
@@ -35,6 +124,7 @@ def sentry_init():
        profiles_sample_rate=1.0,
        environment=f"app:{settings.config.app_env.value}-behave:{settings.config.behave_as.value}",
        _experiments={"enable_logs": True},
+        before_send=_before_send,
        integrations=[
            AsyncioIntegration(),
            LoggingIntegration(sentry_logs_level=logging.INFO),
--- a/autogpt_platform/backend/backend/util/retry.py
+++ b/autogpt_platform/backend/backend/util/retry.py
@@ -64,7 +64,7 @@ def send_rate_limited_discord_alert(
        return True

    except Exception as alert_error:
-        logger.error(f"Failed to send Discord alert: {alert_error}")
+        logger.warning(f"Failed to send Discord alert: {alert_error}")
        return False


@@ -182,7 +182,8 @@ def conn_retry(
        func_name = getattr(retry_state.fn, "__name__", "unknown")

        if retry_state.outcome.failed and retry_state.next_action is None:
-            logger.error(f"{prefix} {action_name} failed after retries: {exception}")
+            # Final failure is logged by sync_wrapper/async_wrapper — skip here to avoid duplicates
+            pass
        else:
            if attempt_number == EXCESSIVE_RETRY_THRESHOLD:
                if send_rate_limited_discord_alert(
@@ -225,7 +226,7 @@ def conn_retry(
                logger.info(f"{prefix} {action_name} completed successfully.")
                return result
            except Exception as e:
-                logger.error(f"{prefix} {action_name} failed after retries: {e}")
+                logger.warning(f"{prefix} {action_name} failed after retries: {e}")
                raise

        @wraps(func)
@@ -237,7 +238,7 @@ def conn_retry(
                logger.info(f"{prefix} {action_name} completed successfully.")
                return result
            except Exception as e:
-                logger.error(f"{prefix} {action_name} failed after retries: {e}")
+                logger.warning(f"{prefix} {action_name} failed after retries: {e}")
                raise

        return async_wrapper if is_coroutine else sync_wrapper
--- a/autogpt_platform/frontend/CLAUDE.md
+++ b/autogpt_platform/frontend/CLAUDE.md
@@ -44,6 +44,12 @@ Do NOT skip these steps. If any command reports errors, fix them and re-run unti

 - Fully capitalize acronyms in symbols, e.g. `graphID`, `useBackendAPI`
 - Use function declarations (not arrow functions) for components/handlers
+- No `dark:` Tailwind classes — the design system handles dark mode
+- Use Next.js `<Link>` for internal navigation — never raw `<a>` tags
+- No `any` types unless the value genuinely can be anything
+- No linter suppressors (`// @ts-ignore`, `// eslint-disable`) — fix the actual issue
+- **File length** — keep files under ~200 lines; extract sub-components or hooks into their own files when a file grows beyond this
+- **Function/component length** — keep render functions and hooks under ~50 lines; extract named helpers or sub-components when they grow longer

 ## Architecture

--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/JobStatsBar/useWorkDoneCounters.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/JobStatsBar/useWorkDoneCounters.ts
@@ -5,7 +5,7 @@ const TOOL_TO_CATEGORY: Record<string, string> = {
  find_agent: "search",
  find_library_agent: "search",
  run_agent: "agent run",
-  run_block: "block run",
+  run_block: "action",
  create_agent: "agent created",
  edit_agent: "agent edited",
  schedule_agent: "agent scheduled",
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/styleguide/page.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/styleguide/page.tsx
@@ -706,8 +706,8 @@ export default function StyleguidePage() {
                    input: { block_id: "weather-block-123" },
                    output: {
                      type: ResponseType.error,
-                      message: "Failed to run the block.",
-                      error: "Block execution timed out after 30 seconds.",
+                      message: "Something went wrong while running this step.",
+                      error: "Execution timed out after 30 seconds.",
                      details: {
                        block_id: "weather-block-123",
                        timeout_ms: 30000,
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/FindBlocks/FindBlocks.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/FindBlocks/FindBlocks.tsx
@@ -61,7 +61,7 @@ export function FindBlocksTool({ part }: Props) {

  const query = (part.input as FindBlockInput | undefined)?.query?.trim();
  const accordionDescription = parsed
-    ? `Found ${parsed.count} block${parsed.count === 1 ? "" : "s"}${query ? ` for "${query}"` : ""}`
+    ? `Found ${parsed.count} action${parsed.count === 1 ? "" : "s"}${query ? ` for "${query}"` : ""}`
    : undefined;

  return (
@@ -77,7 +77,7 @@ export function FindBlocksTool({ part }: Props) {
      {hasBlocks && parsed && (
        <ToolAccordion
          icon={<AccordionIcon />}
-          title="Block results"
+          title="Results"
          description={accordionDescription}
        >
          <HorizontalScroll dependencyList={[parsed.blocks.length]}>
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/FindBlocks/helpers.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/FindBlocks/helpers.tsx
@@ -30,21 +30,21 @@ export function getAnimationText(part: FindBlockToolPart): string {
  switch (part.state) {
    case "input-streaming":
    case "input-available":
-      return `Searching for blocks${queryText}`;
+      return `Searching for actions${queryText}`;

    case "output-available": {
      const parsed = parseOutput(part.output);
      if (parsed) {
-        return `Found ${parsed.count} block${parsed.count === 1 ? "" : "s"}${queryText}`;
+        return `Found ${parsed.count} action${parsed.count === 1 ? "" : "s"}${queryText}`;
      }
-      return `Searching for blocks${queryText}`;
+      return `Searching for actions${queryText}`;
    }

    case "output-error":
-      return `Error finding blocks${queryText}`;
+      return `Search failed${query ? ` for "${query}"` : ""}`;

    default:
-      return "Searching for blocks";
+      return "Searching for actions";
  }
 }

--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/GenericTool/helpers.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/GenericTool/helpers.ts
@@ -144,6 +144,23 @@ export function truncate(text: string, maxLen: number): string {
  return text.slice(0, maxLen).trimEnd() + "\u2026";
 }

+const STRIPPABLE_EXTENSIONS =
+  /\.(md|csv|json|txt|yaml|yml|xml|html|js|ts|py|sh|toml|cfg|ini|log|pdf|png|jpg|jpeg|gif|svg|mp4|mp3|wav|zip|tar|gz)$/i;
+
+export function humanizeFileName(filePath: string): string {
+  const fileName = filePath.split("/").pop() ?? filePath;
+  const stem = fileName.replace(STRIPPABLE_EXTENSIONS, "");
+  const words = stem
+    .replace(/[_-]/g, " ")
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((w) => {
+      if (w === w.toUpperCase()) return w;
+      return w.charAt(0).toUpperCase() + w.slice(1).toLowerCase();
+    });
+  return `"${words.join(" ")}"`;
+}
+
 /* ------------------------------------------------------------------ */
 /*  Exit code helper                                                   */
 /* ------------------------------------------------------------------ */
@@ -191,16 +208,16 @@ export function getAnimationText(
            ? `Browsing ${shortSummary}`
            : "Interacting with browser\u2026";
        case "file-read":
-          return shortSummary
-            ? `Reading ${shortSummary}`
+          return summary
+            ? `Reading ${humanizeFileName(summary)}`
            : "Reading file\u2026";
        case "file-write":
-          return shortSummary
-            ? `Writing ${shortSummary}`
+          return summary
+            ? `Writing ${humanizeFileName(summary)}`
            : "Writing file\u2026";
        case "file-delete":
-          return shortSummary
-            ? `Deleting ${shortSummary}`
+          return summary
+            ? `Deleting ${humanizeFileName(summary)}`
            : "Deleting file\u2026";
        case "file-list":
          return shortSummary
@@ -211,8 +228,8 @@ export function getAnimationText(
            ? `Searching for "${shortSummary}"`
            : "Searching\u2026";
        case "edit":
-          return shortSummary
-            ? `Editing ${shortSummary}`
+          return summary
+            ? `Editing ${humanizeFileName(summary)}`
            : "Editing file\u2026";
        case "todo":
          return shortSummary ? `${shortSummary}` : "Updating task list\u2026";
@@ -246,11 +263,17 @@ export function getAnimationText(
            ? `Browsed ${shortSummary}`
            : "Browser action completed";
        case "file-read":
-          return shortSummary ? `Read ${shortSummary}` : "File read completed";
+          return summary
+            ? `Read ${humanizeFileName(summary)}`
+            : "File read completed";
        case "file-write":
-          return shortSummary ? `Wrote ${shortSummary}` : "File written";
+          return summary
+            ? `Wrote ${humanizeFileName(summary)}`
+            : "File written";
        case "file-delete":
-          return shortSummary ? `Deleted ${shortSummary}` : "File deleted";
+          return summary
+            ? `Deleted ${humanizeFileName(summary)}`
+            : "File deleted";
        case "file-list":
          return "Listed files";
        case "search":
@@ -258,7 +281,9 @@ export function getAnimationText(
            ? `Searched for "${shortSummary}"`
            : "Search completed";
        case "edit":
-          return shortSummary ? `Edited ${shortSummary}` : "Edit completed";
+          return summary
+            ? `Edited ${humanizeFileName(summary)}`
+            : "Edit completed";
        case "todo":
          return "Updated task list";
        case "compaction":
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunAgent/helpers.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunAgent/helpers.tsx
@@ -149,10 +149,10 @@ export function getAnimationText(part: {
      }
      if (isRunAgentNeedLoginOutput(output))
        return "Sign in required to run agent";
-      return "Error running agent";
+      return "Something went wrong";
    }
    case "output-error":
-      return "Error running agent";
+      return "Something went wrong";
    default:
      return actionPhrase;
  }
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/components/SetupRequirementsCard/SetupRequirementsCard.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/components/SetupRequirementsCard/SetupRequirementsCard.tsx
@@ -18,10 +18,10 @@ import {
 interface Props {
  output: SetupRequirementsResponse;
  /** Override the message sent to the chat when the user clicks Proceed after connecting credentials.
-   * Defaults to "Please re-run the block now." */
+   * Defaults to "Please re-run this step now." */
  retryInstruction?: string;
  /** Override the label shown above the credentials section.
-   * Defaults to "Block credentials". */
+   * Defaults to "Credentials". */
  credentialsLabel?: string;
 }

@@ -87,11 +87,9 @@ export function SetupRequirementsCard({
          ([, v]) => v !== undefined && v !== null && v !== "",
        ),
      );
-      parts.push(
-        `Run the block with these inputs: ${JSON.stringify(nonEmpty, null, 2)}`,
-      );
+      parts.push(`Run with these inputs: ${JSON.stringify(nonEmpty, null, 2)}`);
    } else {
-      parts.push(retryInstruction ?? "Please re-run the block now.");
+      parts.push(retryInstruction ?? "Please re-run this step now.");
    }

    onSend(parts.join(" "));
@@ -105,7 +103,7 @@ export function SetupRequirementsCard({
      {needsCredentials && (
        <div className="rounded-2xl border bg-background p-3">
          <Text variant="small" className="w-fit border-b text-zinc-500">
-            {credentialsLabel ?? "Block credentials"}
+            {credentialsLabel ?? "Credentials"}
          </Text>
          <div className="mt-6">
            <CredentialsGroupedView
@@ -122,7 +120,7 @@ export function SetupRequirementsCard({
      {inputSchema && (
        <div className="rounded-2xl border bg-background p-3 pt-4">
          <Text variant="small" className="w-fit border-b text-zinc-500">
-            Block inputs
+            Inputs
          </Text>
          <FormRenderer
            jsonSchema={inputSchema}
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/helpers.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/helpers.tsx
@@ -165,12 +165,12 @@ export function getAnimationText(part: {
      if (isRunBlockReviewRequiredOutput(output)) {
        return `Review needed for "${output.block_name}"`;
      }
-      return "Error running block";
+      return "Action failed";
    }
    case "output-error":
-      return "Error running block";
+      return "Action failed";
    default:
-      return "Running the block";
+      return "Running";
  }
 }

--- a/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/NewAgentLibraryView.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/NewAgentLibraryView.tsx
@@ -209,6 +209,7 @@ export function NewAgentLibraryView() {
              agent={agent}
              scheduleId={activeItem}
              onScheduleDeleted={handleScheduleDeleted}
+              onSelectRun={(id) => handleSelectRun(id, "runs")}
              banner={renderMarketplaceUpdateBanner()}
            />
          ) : activeTab === "templates" ? (
--- a/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/SelectedScheduleView/SelectedScheduleView.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/SelectedScheduleView/SelectedScheduleView.tsx
@@ -20,6 +20,7 @@ interface Props {
  agent: LibraryAgent;
  scheduleId: string;
  onScheduleDeleted?: (deletedScheduleId: string) => void;
+  onSelectRun?: (id: string) => void;
  banner?: React.ReactNode;
 }

@@ -27,6 +28,7 @@ export function SelectedScheduleView({
  agent,
  scheduleId,
  onScheduleDeleted,
+  onSelectRun,
  banner,
 }: Props) {
  const { schedule, isLoading, error } = useSelectedScheduleView(
@@ -89,7 +91,9 @@ export function SelectedScheduleView({
                  <SelectedScheduleActions
                    agent={agent}
                    scheduleId={schedule.id}
+                    schedule={schedule}
                    onDeleted={() => onScheduleDeleted?.(schedule.id)}
+                    onSelectRun={onSelectRun}
                  />
                </div>
              ) : null}
@@ -168,7 +172,9 @@ export function SelectedScheduleView({
          <SelectedScheduleActions
            agent={agent}
            scheduleId={schedule.id}
+            schedule={schedule}
            onDeleted={() => onScheduleDeleted?.(schedule.id)}
+            onSelectRun={onSelectRun}
          />
        </div>
      ) : null}
--- a/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/SelectedScheduleView/components/SelectedScheduleActions/SelectedScheduleActions.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/SelectedScheduleView/components/SelectedScheduleActions/SelectedScheduleActions.tsx
@@ -1,11 +1,12 @@
 "use client";

-import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
+import type { GraphExecutionJobInfo } from "@/app/api/__generated__/models/graphExecutionJobInfo";
+import type { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
 import { Button } from "@/components/atoms/Button/Button";
 import { LoadingSpinner } from "@/components/atoms/LoadingSpinner/LoadingSpinner";
 import { Text } from "@/components/atoms/Text/Text";
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import { EyeIcon, TrashIcon } from "@phosphor-icons/react";
+import { EyeIcon, Play, TrashIcon } from "@phosphor-icons/react";
 import { AgentActionsDropdown } from "../../../AgentActionsDropdown";
 import { SelectedActionsWrap } from "../../../SelectedActionsWrap";
 import { useSelectedScheduleActions } from "./useSelectedScheduleActions";
@@ -13,13 +14,17 @@ import { useSelectedScheduleActions } from "./useSelectedScheduleActions";
 type Props = {
  agent: LibraryAgent;
  scheduleId: string;
+  schedule?: GraphExecutionJobInfo;
  onDeleted?: () => void;
+  onSelectRun?: (id: string) => void;
 };

 export function SelectedScheduleActions({
  agent,
  scheduleId,
+  schedule,
  onDeleted,
+  onSelectRun,
 }: Props) {
  const {
    openInBuilderHref,
@@ -27,11 +32,32 @@ export function SelectedScheduleActions({
    setShowDeleteDialog,
    handleDelete,
    isDeleting,
-  } = useSelectedScheduleActions({ agent, scheduleId, onDeleted });
+    handleRunNow,
+    isRunning,
+  } = useSelectedScheduleActions({
+    agent,
+    scheduleId,
+    schedule,
+    onDeleted,
+    onSelectRun,
+  });

  return (
    <>
      <SelectedActionsWrap>
+        <Button
+          variant="icon"
+          size="icon"
+          aria-label="Run now"
+          onClick={handleRunNow}
+          disabled={isRunning || !schedule}
+        >
+          {isRunning ? (
+            <LoadingSpinner size="small" />
+          ) : (
+            <Play weight="bold" size={18} className="text-zinc-700" />
+          )}
+        </Button>
        {openInBuilderHref && (
          <Button
            variant="icon"
--- a/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/SelectedScheduleView/components/SelectedScheduleActions/useSelectedScheduleActions.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/SelectedScheduleView/components/SelectedScheduleActions/useSelectedScheduleActions.ts
@@ -1,10 +1,16 @@
 "use client";

+import {
+  getGetV1ListGraphExecutionsQueryKey,
+  usePostV1ExecuteGraphAgent,
+} from "@/app/api/__generated__/endpoints/graphs/graphs";
 import {
  getGetV1ListExecutionSchedulesForAGraphQueryOptions,
  useDeleteV1DeleteExecutionSchedule,
 } from "@/app/api/__generated__/endpoints/schedules/schedules";
-import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
+import type { GraphExecutionJobInfo } from "@/app/api/__generated__/models/graphExecutionJobInfo";
+import type { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
+import { okData } from "@/app/api/helpers";
 import { useToast } from "@/components/molecules/Toast/use-toast";
 import { useQueryClient } from "@tanstack/react-query";
 import { useState } from "react";
@@ -12,13 +18,17 @@ import { useState } from "react";
 interface UseSelectedScheduleActionsProps {
  agent: LibraryAgent;
  scheduleId: string;
+  schedule?: GraphExecutionJobInfo;
  onDeleted?: () => void;
+  onSelectRun?: (id: string) => void;
 }

 export function useSelectedScheduleActions({
  agent,
  scheduleId,
+  schedule,
  onDeleted,
+  onSelectRun,
 }: UseSelectedScheduleActionsProps) {
  const { toast } = useToast();
  const queryClient = useQueryClient();
@@ -50,11 +60,58 @@ export function useSelectedScheduleActions({
    },
  });

+  const { mutateAsync: executeAgent, isPending: isRunning } =
+    usePostV1ExecuteGraphAgent();
+
  function handleDelete() {
    if (!scheduleId) return;
    deleteMutation.mutate({ scheduleId });
  }

+  async function handleRunNow() {
+    if (!schedule) {
+      toast({
+        title: "Schedule not loaded",
+        description: "Please wait for the schedule to load.",
+        variant: "destructive",
+      });
+      return;
+    }
+
+    try {
+      toast({ title: "Run started" });
+
+      const res = await executeAgent({
+        graphId: schedule.graph_id,
+        graphVersion: schedule.graph_version,
+        data: {
+          inputs: schedule.input_data || {},
+          credentials_inputs: schedule.input_credentials || {},
+          source: "library",
+        },
+      });
+
+      const newRunID = okData(res)?.id;
+
+      await queryClient.invalidateQueries({
+        queryKey: getGetV1ListGraphExecutionsQueryKey(agent.graph_id),
+      });
+
+      if (newRunID && onSelectRun) {
+        onSelectRun(newRunID);
+      }
+    } catch (error: unknown) {
+      toast({
+        title: "Failed to start run",
+        description:
+          error instanceof Error
+            ? error.message
+            : "An unexpected error occurred.",
+        variant: "destructive",
+      });
+    }
+  }
+
  const openInBuilderHref = `/build?flowID=${agent.graph_id}&flowVersion=${agent.graph_version}`;

  return {
@@ -63,5 +120,7 @@ export function useSelectedScheduleActions({
    setShowDeleteDialog,
    handleDelete,
    isDeleting: deleteMutation.isPending,
+    handleRunNow,
+    isRunning,
  };
 }
--- a/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/sidebar/SidebarRunsList/SidebarRunsList.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/sidebar/SidebarRunsList/SidebarRunsList.tsx
@@ -186,6 +186,7 @@ export function SidebarRunsList({
                    selected={selectedRunId === s.id}
                    onClick={() => onSelectRun(s.id, "scheduled")}
                    onDeleted={() => onScheduleDeleted?.(s.id)}
+                    onRunCreated={(runID) => onSelectRun(runID, "runs")}
                  />
                </div>
              ))
--- a/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/sidebar/SidebarRunsList/components/ScheduleActionsDropdown.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/sidebar/SidebarRunsList/components/ScheduleActionsDropdown.tsx
@@ -1,11 +1,16 @@
 "use client";

+import {
+  getGetV1ListGraphExecutionsQueryKey,
+  usePostV1ExecuteGraphAgent,
+} from "@/app/api/__generated__/endpoints/graphs/graphs";
 import {
  getGetV1ListExecutionSchedulesForAGraphQueryOptions,
  useDeleteV1DeleteExecutionSchedule,
 } from "@/app/api/__generated__/endpoints/schedules/schedules";
 import type { GraphExecutionJobInfo } from "@/app/api/__generated__/models/graphExecutionJobInfo";
 import type { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
+import { okData } from "@/app/api/helpers";
 import { Button } from "@/components/atoms/Button/Button";
 import { Text } from "@/components/atoms/Text/Text";
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
@@ -13,6 +18,7 @@ import {
  DropdownMenu,
  DropdownMenuContent,
  DropdownMenuItem,
+  DropdownMenuSeparator,
  DropdownMenuTrigger,
 } from "@/components/molecules/DropdownMenu/DropdownMenu";
 import { useToast } from "@/components/molecules/Toast/use-toast";
@@ -24,9 +30,15 @@ interface Props {
  agent: LibraryAgent;
  schedule: GraphExecutionJobInfo;
  onDeleted?: () => void;
+  onRunCreated?: (runID: string) => void;
 }

-export function ScheduleActionsDropdown({ agent, schedule, onDeleted }: Props) {
+export function ScheduleActionsDropdown({
+  agent,
+  schedule,
+  onDeleted,
+  onRunCreated,
+}: Props) {
  const { toast } = useToast();
  const queryClient = useQueryClient();
  const [showDeleteDialog, setShowDeleteDialog] = useState(false);
@@ -34,6 +46,9 @@ export function ScheduleActionsDropdown({ agent, schedule, onDeleted }: Props) {
  const { mutateAsync: deleteSchedule, isPending: isDeleting } =
    useDeleteV1DeleteExecutionSchedule();

+  const { mutateAsync: executeAgent, isPending: isRunning } =
+    usePostV1ExecuteGraphAgent();
+
  async function handleDelete() {
    try {
      await deleteSchedule({ scheduleId: schedule.id });
@@ -60,6 +75,43 @@ export function ScheduleActionsDropdown({ agent, schedule, onDeleted }: Props) {
    }
  }

+  async function handleRunNow(e: React.MouseEvent) {
+    e.stopPropagation();
+
+    try {
+      toast({ title: "Run started" });
+
+      const res = await executeAgent({
+        graphId: schedule.graph_id,
+        graphVersion: schedule.graph_version,
+        data: {
+          inputs: schedule.input_data || {},
+          credentials_inputs: schedule.input_credentials || {},
+          source: "library",
+        },
+      });
+
+      const newRunID = okData(res)?.id;
+
+      await queryClient.invalidateQueries({
+        queryKey: getGetV1ListGraphExecutionsQueryKey(agent.graph_id),
+      });
+
+      if (newRunID) {
+        onRunCreated?.(newRunID);
+      }
+    } catch (error: unknown) {
+      toast({
+        title: "Failed to start run",
+        description:
+          error instanceof Error
+            ? error.message
+            : "An unexpected error occurred.",
+        variant: "destructive",
+      });
+    }
+  }
+
  return (
    <>
      <DropdownMenu>
@@ -73,6 +125,14 @@ export function ScheduleActionsDropdown({ agent, schedule, onDeleted }: Props) {
          </button>
        </DropdownMenuTrigger>
        <DropdownMenuContent align="end">
+          <DropdownMenuItem
+            onClick={handleRunNow}
+            disabled={isRunning}
+            className="flex items-center gap-2"
+          >
+            {isRunning ? "Running..." : "Run now"}
+          </DropdownMenuItem>
+          <DropdownMenuSeparator />
          <DropdownMenuItem
            onClick={(e) => {
              e.stopPropagation();
--- a/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/sidebar/SidebarRunsList/components/ScheduleListItem.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/sidebar/SidebarRunsList/components/ScheduleListItem.tsx
@@ -14,6 +14,7 @@ interface Props {
  selected?: boolean;
  onClick?: () => void;
  onDeleted?: () => void;
+  onRunCreated?: (runID: string) => void;
 }

 export function ScheduleListItem({
@@ -22,6 +23,7 @@ export function ScheduleListItem({
  selected,
  onClick,
  onDeleted,
+  onRunCreated,
 }: Props) {
  return (
    <SidebarItemCard
@@ -46,6 +48,7 @@ export function ScheduleListItem({
          agent={agent}
          schedule={schedule}
          onDeleted={onDeleted}
+          onRunCreated={onRunCreated}
        />
      }
    />
--- a/autogpt_platform/frontend/src/app/(platform)/library/components/JumpBackIn/JumpBackIn.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/library/components/JumpBackIn/JumpBackIn.tsx
@@ -0,0 +1,40 @@
+"use client";
+
+import { ArrowRight, Lightning } from "@phosphor-icons/react";
+import NextLink from "next/link";
+
+import { Button } from "@/components/atoms/Button/Button";
+import { Text } from "@/components/atoms/Text/Text";
+import { useJumpBackIn } from "./useJumpBackIn";
+
+export function JumpBackIn() {
+  const { agent, isLoading } = useJumpBackIn();
+
+  if (isLoading || !agent) {
+    return null;
+  }
+
+  return (
+    <div className="flex items-center justify-between rounded-large border border-zinc-200 bg-gradient-to-r from-zinc-50 to-white px-5 py-4">
+      <div className="flex items-center gap-3">
+        <div className="flex h-9 w-9 items-center justify-center rounded-full bg-zinc-900">
+          <Lightning size={18} weight="fill" className="text-white" />
+        </div>
+        <div className="flex flex-col">
+          <Text variant="small" className="text-zinc-500">
+            Continue where you left off
+          </Text>
+          <Text variant="body-medium" className="text-zinc-900">
+            {agent.name}
+          </Text>
+        </div>
+      </div>
+      <NextLink href={`/library/agents/${agent.id}`}>
+        <Button variant="primary" size="small" className="gap-1.5">
+          Jump Back In
+          <ArrowRight size={16} />
+        </Button>
+      </NextLink>
+    </div>
+  );
+}
--- a/autogpt_platform/frontend/src/app/(platform)/library/components/JumpBackIn/useJumpBackIn.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/library/components/JumpBackIn/useJumpBackIn.ts
@@ -0,0 +1,28 @@
+"use client";
+
+import { useGetV2ListLibraryAgents } from "@/app/api/__generated__/endpoints/library/library";
+import { okData } from "@/app/api/helpers";
+
+export function useJumpBackIn() {
+  const { data, isLoading } = useGetV2ListLibraryAgents(
+    {
+      page: 1,
+      page_size: 1,
+      sort_by: "updatedAt",
+    },
+    {
+      query: { select: okData },
+    },
+  );
+
+  // The API doesn't include execution data by default (include_executions is
+  // internal to the backend), so recent_executions is always empty here.
+  // We use the most recently updated agent as the "jump back in" candidate
+  // instead — updatedAt is the best available proxy for recent activity.
+  const agent = data?.agents[0] ?? null;
+
+  return {
+    agent,
+    isLoading,
+  };
+}
--- a/autogpt_platform/frontend/src/app/(platform)/library/page.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/library/page.tsx
@@ -2,6 +2,7 @@

 import { useEffect, useState, useCallback } from "react";
 import { HeartIcon, ListIcon } from "@phosphor-icons/react";
+import { JumpBackIn } from "./components/JumpBackIn/JumpBackIn";
 import { LibraryActionHeader } from "./components/LibraryActionHeader/LibraryActionHeader";
 import { LibraryAgentList } from "./components/LibraryAgentList/LibraryAgentList";
 import { Tab } from "./components/LibraryTabs/LibraryTabs";
@@ -38,6 +39,7 @@ export default function LibraryPage() {
      onAnimationComplete={handleFavoriteAnimationComplete}
    >
      <main className="pt-160 container min-h-screen space-y-4 pb-20 pt-16 sm:px-8 md:px-12">
+        <JumpBackIn />
        <LibraryActionHeader setSearchTerm={setSearchTerm} />
        <LibraryAgentList
          searchTerm={searchTerm}