Merge branch 'dev' into ntindle/waitlist

test
feat(platform): add endedAt field and fix execution analytics timestamps (#11759 )
2026-01-19 12:08:46 -05:00 · 2026-01-19 01:12:14 -06:00 · 2026-01-18 15:32:10 -06:00 · 2026-01-16 21:44:24 +00:00 · 2026-01-16 21:18:12 +00:00 · 2026-01-16 20:33:47 +00:00
41 changed files with 3602 additions and 109 deletions
--- a/autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes.py
+++ b/autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes.py
@@ -28,6 +28,7 @@ from backend.executor.manager import get_db_async_client
 from backend.util.settings import Settings

 logger = logging.getLogger(__name__)
+settings = Settings()


 class ExecutionAnalyticsRequest(BaseModel):
@@ -63,6 +64,8 @@ class ExecutionAnalyticsResult(BaseModel):
    score: Optional[float]
    status: str  # "success", "failed", "skipped"
    error_message: Optional[str] = None
+    started_at: Optional[datetime] = None
+    ended_at: Optional[datetime] = None


 class ExecutionAnalyticsResponse(BaseModel):
@@ -224,11 +227,6 @@ async def generate_execution_analytics(
    )

    try:
-        # Validate model configuration
-        settings = Settings()
-        if not settings.secrets.openai_internal_api_key:
-            raise HTTPException(status_code=500, detail="OpenAI API key not configured")
-
        # Get database client
        db_client = get_db_async_client()

@@ -320,6 +318,8 @@ async def generate_execution_analytics(
                    ),
                    status="skipped",
                    error_message=None,  # Not an error - just already processed
+                    started_at=execution.started_at,
+                    ended_at=execution.ended_at,
                )
            )

@@ -349,6 +349,9 @@ async def _process_batch(
 ) -> list[ExecutionAnalyticsResult]:
    """Process a batch of executions concurrently."""

+    if not settings.secrets.openai_internal_api_key:
+        raise HTTPException(status_code=500, detail="OpenAI API key not configured")
+
    async def process_single_execution(execution) -> ExecutionAnalyticsResult:
        try:
            # Generate activity status and score using the specified model
@@ -387,6 +390,8 @@ async def _process_batch(
                    score=None,
                    status="skipped",
                    error_message="Activity generation returned None",
+                    started_at=execution.started_at,
+                    ended_at=execution.ended_at,
                )

            # Update the execution stats
@@ -416,6 +421,8 @@ async def _process_batch(
                summary_text=activity_response["activity_status"],
                score=activity_response["correctness_score"],
                status="success",
+                started_at=execution.started_at,
+                ended_at=execution.ended_at,
            )

        except Exception as e:
@@ -429,6 +436,8 @@ async def _process_batch(
                score=None,
                status="failed",
                error_message=str(e),
+                started_at=execution.started_at,
+                ended_at=execution.ended_at,
            )

    # Process all executions in the batch concurrently
--- a/autogpt_platform/backend/backend/api/features/admin/waitlist_admin_routes.py
+++ b/autogpt_platform/backend/backend/api/features/admin/waitlist_admin_routes.py
@@ -0,0 +1,251 @@
+import logging
+
+import autogpt_libs.auth
+import fastapi
+import fastapi.responses
+
+import backend.api.features.store.db as store_db
+import backend.api.features.store.model as store_model
+
+logger = logging.getLogger(__name__)
+
+router = fastapi.APIRouter(
+    prefix="/admin/waitlist",
+    tags=["store", "admin", "waitlist"],
+    dependencies=[fastapi.Security(autogpt_libs.auth.requires_admin_user)],
+)
+
+
+@router.post(
+    "",
+    summary="Create Waitlist",
+    response_model=store_model.WaitlistAdminResponse,
+)
+async def create_waitlist(
+    request: store_model.WaitlistCreateRequest,
+    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+):
+    """
+    Create a new waitlist (admin only).
+
+    Args:
+        request: Waitlist creation details
+        user_id: Authenticated admin user creating the waitlist
+
+    Returns:
+        WaitlistAdminResponse with the created waitlist details
+    """
+    try:
+        waitlist = await store_db.create_waitlist_admin(
+            admin_user_id=user_id,
+            data=request,
+        )
+        return waitlist
+    except Exception as e:
+        logger.exception("Error creating waitlist: %s", e)
+        return fastapi.responses.JSONResponse(
+            status_code=500,
+            content={"detail": "An error occurred while creating the waitlist"},
+        )
+
+
+@router.get(
+    "",
+    summary="List All Waitlists",
+    response_model=store_model.WaitlistAdminListResponse,
+)
+async def list_waitlists():
+    """
+    Get all waitlists with admin details (admin only).
+
+    Returns:
+        WaitlistAdminListResponse with all waitlists
+    """
+    try:
+        return await store_db.get_waitlists_admin()
+    except Exception as e:
+        logger.exception("Error listing waitlists: %s", e)
+        return fastapi.responses.JSONResponse(
+            status_code=500,
+            content={"detail": "An error occurred while fetching waitlists"},
+        )
+
+
+@router.get(
+    "/{waitlist_id}",
+    summary="Get Waitlist Details",
+    response_model=store_model.WaitlistAdminResponse,
+)
+async def get_waitlist(
+    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
+):
+    """
+    Get a single waitlist with admin details (admin only).
+
+    Args:
+        waitlist_id: ID of the waitlist to retrieve
+
+    Returns:
+        WaitlistAdminResponse with waitlist details
+    """
+    try:
+        return await store_db.get_waitlist_admin(waitlist_id)
+    except ValueError:
+        logger.warning("Waitlist not found: %s", waitlist_id)
+        return fastapi.responses.JSONResponse(
+            status_code=404,
+            content={"detail": "Waitlist not found"},
+        )
+    except Exception as e:
+        logger.exception("Error fetching waitlist: %s", e)
+        return fastapi.responses.JSONResponse(
+            status_code=500,
+            content={"detail": "An error occurred while fetching the waitlist"},
+        )
+
+
+@router.put(
+    "/{waitlist_id}",
+    summary="Update Waitlist",
+    response_model=store_model.WaitlistAdminResponse,
+)
+async def update_waitlist(
+    request: store_model.WaitlistUpdateRequest,
+    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
+):
+    """
+    Update a waitlist (admin only).
+
+    Args:
+        waitlist_id: ID of the waitlist to update
+        request: Fields to update
+
+    Returns:
+        WaitlistAdminResponse with updated waitlist details
+    """
+    try:
+        return await store_db.update_waitlist_admin(waitlist_id, request)
+    except ValueError:
+        logger.warning("Waitlist not found for update: %s", waitlist_id)
+        return fastapi.responses.JSONResponse(
+            status_code=404,
+            content={"detail": "Waitlist not found"},
+        )
+    except Exception as e:
+        logger.exception("Error updating waitlist: %s", e)
+        return fastapi.responses.JSONResponse(
+            status_code=500,
+            content={"detail": "An error occurred while updating the waitlist"},
+        )
+
+
+@router.delete(
+    "/{waitlist_id}",
+    summary="Delete Waitlist",
+)
+async def delete_waitlist(
+    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
+):
+    """
+    Soft delete a waitlist (admin only).
+
+    Args:
+        waitlist_id: ID of the waitlist to delete
+
+    Returns:
+        Success message
+    """
+    try:
+        await store_db.delete_waitlist_admin(waitlist_id)
+        return {"message": "Waitlist deleted successfully"}
+    except ValueError:
+        logger.warning(f"Waitlist not found for deletion: {waitlist_id}")
+        return fastapi.responses.JSONResponse(
+            status_code=404,
+            content={"detail": "Waitlist not found"},
+        )
+    except Exception as e:
+        logger.exception("Error deleting waitlist: %s", e)
+        return fastapi.responses.JSONResponse(
+            status_code=500,
+            content={"detail": "An error occurred while deleting the waitlist"},
+        )
+
+
+@router.get(
+    "/{waitlist_id}/signups",
+    summary="Get Waitlist Signups",
+    response_model=store_model.WaitlistSignupListResponse,
+)
+async def get_waitlist_signups(
+    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
+):
+    """
+    Get all signups for a waitlist (admin only).
+
+    Args:
+        waitlist_id: ID of the waitlist
+
+    Returns:
+        WaitlistSignupListResponse with all signups
+    """
+    try:
+        return await store_db.get_waitlist_signups_admin(waitlist_id)
+    except ValueError:
+        logger.warning("Waitlist not found for signups: %s", waitlist_id)
+        return fastapi.responses.JSONResponse(
+            status_code=404,
+            content={"detail": "Waitlist not found"},
+        )
+    except Exception as e:
+        logger.exception("Error fetching waitlist signups: %s", e)
+        return fastapi.responses.JSONResponse(
+            status_code=500,
+            content={"detail": "An error occurred while fetching waitlist signups"},
+        )
+
+
+@router.post(
+    "/{waitlist_id}/link",
+    summary="Link Waitlist to Store Listing",
+    response_model=store_model.WaitlistAdminResponse,
+)
+async def link_waitlist_to_listing(
+    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
+    store_listing_id: str = fastapi.Body(
+        ..., embed=True, description="The ID of the store listing"
+    ),
+):
+    """
+    Link a waitlist to a store listing (admin only).
+
+    When the linked store listing is approved/published, waitlist users
+    will be automatically notified.
+
+    Args:
+        waitlist_id: ID of the waitlist
+        store_listing_id: ID of the store listing to link
+
+    Returns:
+        WaitlistAdminResponse with updated waitlist details
+    """
+    try:
+        return await store_db.link_waitlist_to_listing_admin(
+            waitlist_id, store_listing_id
+        )
+    except ValueError:
+        logger.warning(
+            "Link failed - waitlist or listing not found: %s, %s",
+            waitlist_id,
+            store_listing_id,
+        )
+        return fastapi.responses.JSONResponse(
+            status_code=404,
+            content={"detail": "Waitlist or store listing not found"},
+        )
+    except Exception as e:
+        logger.exception("Error linking waitlist to listing: %s", e)
+        return fastapi.responses.JSONResponse(
+            status_code=500,
+            content={"detail": "An error occurred while linking the waitlist"},
+        )
--- a/autogpt_platform/backend/backend/api/features/store/db.py
+++ b/autogpt_platform/backend/backend/api/features/store/db.py
@@ -22,6 +22,7 @@ from backend.data.notifications import (
    AgentApprovalData,
    AgentRejectionData,
    NotificationEventModel,
+    WaitlistLaunchData,
 )
 from backend.notifications.notifications import queue_notification_async
 from backend.util.exceptions import DatabaseError
@@ -1717,6 +1718,29 @@ async def review_store_submission(
                # Don't fail the review process if email sending fails
                pass

+        # Notify waitlist users if this is an approval and has a linked waitlist
+        if is_approved and submission.StoreListing:
+            try:
+                frontend_base_url = (
+                    settings.config.frontend_base_url
+                    or settings.config.platform_base_url
+                )
+                store_agent = (
+                    await prisma.models.StoreAgent.prisma().find_first_or_raise(
+                        where={"storeListingVersionId": submission.id}
+                    )
+                )
+                creator_username = store_agent.creator_username or "unknown"
+                store_url = f"{frontend_base_url}/marketplace/agent/{creator_username}/{store_agent.slug}"
+                await notify_waitlist_users_on_launch(
+                    store_listing_id=submission.StoreListing.id,
+                    agent_name=submission.name,
+                    store_url=store_url,
+                )
+            except Exception as e:
+                logger.error(f"Failed to notify waitlist users on agent approval: {e}")
+                # Don't fail the approval process
+
        # Convert to Pydantic model for consistency
        return store_model.StoreSubmission(
            listing_id=(submission.StoreListing.id if submission.StoreListing else ""),
@@ -1964,3 +1988,552 @@ async def get_agent_as_admin(
        )

    return graph
+
+
+def _waitlist_to_store_entry(
+    waitlist: prisma.models.WaitlistEntry,
+) -> store_model.StoreWaitlistEntry:
+    """Convert a WaitlistEntry to StoreWaitlistEntry for public display."""
+    return store_model.StoreWaitlistEntry(
+        waitlistId=waitlist.id,
+        slug=waitlist.slug,
+        name=waitlist.name,
+        subHeading=waitlist.subHeading,
+        videoUrl=waitlist.videoUrl,
+        agentOutputDemoUrl=waitlist.agentOutputDemoUrl,
+        imageUrls=waitlist.imageUrls or [],
+        description=waitlist.description,
+        categories=waitlist.categories,
+    )
+
+
+async def get_waitlist() -> list[store_model.StoreWaitlistEntry]:
+    """Get all active waitlists for public display."""
+    try:
+        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
+            where=prisma.types.WaitlistEntryWhereInput(isDeleted=False),
+        )
+
+        # Filter out closed/done waitlists and sort by votes (descending)
+        excluded_statuses = {
+            prisma.enums.WaitlistExternalStatus.CANCELED,
+            prisma.enums.WaitlistExternalStatus.DONE,
+        }
+        active_waitlists = [w for w in waitlists if w.status not in excluded_statuses]
+        sorted_list = sorted(active_waitlists, key=lambda x: x.votes, reverse=True)
+
+        return [_waitlist_to_store_entry(w) for w in sorted_list]
+    except Exception as e:
+        logger.error(f"Error fetching waitlists: {e}")
+        raise DatabaseError("Failed to fetch waitlists") from e
+
+
+async def get_user_waitlist_memberships(user_id: str) -> list[str]:
+    """Get all waitlist IDs that a user has joined."""
+    try:
+        user = await prisma.models.User.prisma().find_unique(
+            where={"id": user_id},
+            include={"joinedWaitlists": True},
+        )
+        if not user or not user.joinedWaitlists:
+            return []
+        return [w.id for w in user.joinedWaitlists]
+    except Exception as e:
+        logger.error(f"Error fetching user waitlist memberships: {e}")
+        raise DatabaseError("Failed to fetch waitlist memberships") from e
+
+
+async def add_user_to_waitlist(
+    waitlist_id: str, user_id: str | None, email: str | None
+) -> store_model.StoreWaitlistEntry:
+    """
+    Add a user to a waitlist.
+
+    For logged-in users: connects via joinedUsers relation
+    For anonymous users: adds email to unaffiliatedEmailUsers array
+    """
+    if not user_id and not email:
+        raise ValueError("Either user_id or email must be provided")
+
+    try:
+        # Find the waitlist
+        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
+            where={"id": waitlist_id},
+            include={"joinedUsers": True},
+        )
+
+        if not waitlist:
+            raise ValueError(f"Waitlist {waitlist_id} not found")
+
+        if waitlist.isDeleted:
+            raise ValueError(f"Waitlist {waitlist_id} is no longer available")
+
+        if waitlist.status in [
+            prisma.enums.WaitlistExternalStatus.CANCELED,
+            prisma.enums.WaitlistExternalStatus.DONE,
+        ]:
+            raise ValueError(f"Waitlist {waitlist_id} is closed")
+
+        if user_id:
+            # Check if user already joined
+            joined_user_ids = [u.id for u in (waitlist.joinedUsers or [])]
+            if user_id in joined_user_ids:
+                # Already joined - return waitlist info
+                logger.debug(f"User {user_id} already joined waitlist {waitlist_id}")
+            else:
+                # Connect user to waitlist
+                await prisma.models.WaitlistEntry.prisma().update(
+                    where={"id": waitlist_id},
+                    data={"joinedUsers": {"connect": [{"id": user_id}]}},
+                )
+                logger.info(f"User {user_id} joined waitlist {waitlist_id}")
+
+            # If user was previously in email list, remove them
+            # Use transaction to prevent race conditions
+            if email:
+                async with transaction() as tx:
+                    current_waitlist = await tx.waitlistentry.find_unique(
+                        where={"id": waitlist_id}
+                    )
+                    if current_waitlist and email in (
+                        current_waitlist.unaffiliatedEmailUsers or []
+                    ):
+                        updated_emails: list[str] = [
+                            e
+                            for e in (current_waitlist.unaffiliatedEmailUsers or [])
+                            if e != email
+                        ]
+                        await tx.waitlistentry.update(
+                            where={"id": waitlist_id},
+                            data={"unaffiliatedEmailUsers": updated_emails},
+                        )
+        elif email:
+            # Add email to unaffiliated list if not already present
+            # Use transaction to prevent race conditions with concurrent signups
+            async with transaction() as tx:
+                # Re-fetch within transaction to get latest state
+                current_waitlist = await tx.waitlistentry.find_unique(
+                    where={"id": waitlist_id}
+                )
+                if current_waitlist:
+                    current_emails: list[str] = list(
+                        current_waitlist.unaffiliatedEmailUsers or []
+                    )
+                    if email not in current_emails:
+                        current_emails.append(email)
+                        await tx.waitlistentry.update(
+                            where={"id": waitlist_id},
+                            data={"unaffiliatedEmailUsers": current_emails},
+                        )
+                        logger.info(f"Email {email} added to waitlist {waitlist_id}")
+                    else:
+                        logger.debug(f"Email {email} already on waitlist {waitlist_id}")
+
+        # Re-fetch to return updated data
+        updated_waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
+            where={"id": waitlist_id}
+        )
+        return _waitlist_to_store_entry(updated_waitlist or waitlist)
+
+    except ValueError:
+        raise
+    except Exception as e:
+        logger.error(f"Error adding user to waitlist: {e}")
+        raise DatabaseError("Failed to add user to waitlist") from e
+
+
+# ============== Admin Waitlist Functions ==============
+
+
+def _waitlist_to_admin_response(
+    waitlist: prisma.models.WaitlistEntry,
+) -> store_model.WaitlistAdminResponse:
+    """Convert a WaitlistEntry to WaitlistAdminResponse."""
+    joined_count = len(waitlist.joinedUsers) if waitlist.joinedUsers else 0
+    email_count = (
+        len(waitlist.unaffiliatedEmailUsers) if waitlist.unaffiliatedEmailUsers else 0
+    )
+
+    return store_model.WaitlistAdminResponse(
+        id=waitlist.id,
+        createdAt=waitlist.createdAt.isoformat() if waitlist.createdAt else "",
+        updatedAt=waitlist.updatedAt.isoformat() if waitlist.updatedAt else "",
+        slug=waitlist.slug,
+        name=waitlist.name,
+        subHeading=waitlist.subHeading,
+        description=waitlist.description,
+        categories=waitlist.categories,
+        imageUrls=waitlist.imageUrls or [],
+        videoUrl=waitlist.videoUrl,
+        agentOutputDemoUrl=waitlist.agentOutputDemoUrl,
+        status=waitlist.status or prisma.enums.WaitlistExternalStatus.NOT_STARTED,
+        votes=waitlist.votes,
+        signupCount=joined_count + email_count,
+        storeListingId=waitlist.storeListingId,
+        owningUserId=waitlist.owningUserId,
+    )
+
+
+async def create_waitlist_admin(
+    admin_user_id: str,
+    data: store_model.WaitlistCreateRequest,
+) -> store_model.WaitlistAdminResponse:
+    """Create a new waitlist (admin only)."""
+    logger.info(f"Admin {admin_user_id} creating waitlist: {data.name}")
+
+    try:
+        waitlist = await prisma.models.WaitlistEntry.prisma().create(
+            data=prisma.types.WaitlistEntryCreateInput(
+                name=data.name,
+                slug=data.slug,
+                subHeading=data.subHeading,
+                description=data.description,
+                categories=data.categories,
+                imageUrls=data.imageUrls,
+                videoUrl=data.videoUrl,
+                agentOutputDemoUrl=data.agentOutputDemoUrl,
+                owningUserId=admin_user_id,
+                status=prisma.enums.WaitlistExternalStatus.NOT_STARTED,
+            ),
+            include={"joinedUsers": True},
+        )
+
+        return _waitlist_to_admin_response(waitlist)
+    except Exception as e:
+        logger.error(f"Error creating waitlist: {e}")
+        raise DatabaseError("Failed to create waitlist") from e
+
+
+async def get_waitlists_admin() -> store_model.WaitlistAdminListResponse:
+    """Get all waitlists with admin details."""
+    try:
+        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
+            where=prisma.types.WaitlistEntryWhereInput(isDeleted=False),
+            include={"joinedUsers": True},
+            order={"createdAt": "desc"},
+        )
+
+        return store_model.WaitlistAdminListResponse(
+            waitlists=[_waitlist_to_admin_response(w) for w in waitlists],
+            totalCount=len(waitlists),
+        )
+    except Exception as e:
+        logger.error(f"Error fetching waitlists for admin: {e}")
+        raise DatabaseError("Failed to fetch waitlists") from e
+
+
+async def get_waitlist_admin(
+    waitlist_id: str,
+) -> store_model.WaitlistAdminResponse:
+    """Get a single waitlist with admin details."""
+    try:
+        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
+            where={"id": waitlist_id},
+            include={"joinedUsers": True},
+        )
+
+        if not waitlist:
+            raise ValueError(f"Waitlist {waitlist_id} not found")
+
+        if waitlist.isDeleted:
+            raise ValueError(f"Waitlist {waitlist_id} has been deleted")
+
+        return _waitlist_to_admin_response(waitlist)
+    except ValueError:
+        raise
+    except Exception as e:
+        logger.error(f"Error fetching waitlist {waitlist_id}: {e}")
+        raise DatabaseError("Failed to fetch waitlist") from e
+
+
+async def update_waitlist_admin(
+    waitlist_id: str,
+    data: store_model.WaitlistUpdateRequest,
+) -> store_model.WaitlistAdminResponse:
+    """Update a waitlist (admin only)."""
+    logger.info(f"Updating waitlist {waitlist_id}")
+
+    try:
+        # Check if waitlist exists first
+        existing = await prisma.models.WaitlistEntry.prisma().find_unique(
+            where={"id": waitlist_id}
+        )
+
+        if not existing:
+            raise ValueError(f"Waitlist {waitlist_id} not found")
+
+        if existing.isDeleted:
+            raise ValueError(f"Waitlist {waitlist_id} has been deleted")
+
+        # Build update data from explicitly provided fields
+        # Use model_fields_set to allow clearing fields by setting them to None
+        field_mappings = {
+            "name": data.name,
+            "slug": data.slug,
+            "subHeading": data.subHeading,
+            "description": data.description,
+            "categories": data.categories,
+            "imageUrls": data.imageUrls,
+            "videoUrl": data.videoUrl,
+            "agentOutputDemoUrl": data.agentOutputDemoUrl,
+            "storeListingId": data.storeListingId,
+        }
+        update_data: dict[str, Any] = {
+            k: v for k, v in field_mappings.items() if k in data.model_fields_set
+        }
+
+        # Add status if provided (already validated as enum by Pydantic)
+        if "status" in data.model_fields_set and data.status is not None:
+            update_data["status"] = data.status
+
+        if not update_data:
+            # No updates, just return current data
+            return await get_waitlist_admin(waitlist_id)
+
+        waitlist = await prisma.models.WaitlistEntry.prisma().update(
+            where={"id": waitlist_id},
+            data=prisma.types.WaitlistEntryUpdateInput(**update_data),
+            include={"joinedUsers": True},
+        )
+
+        # We already verified existence above, so this should never be None
+        assert waitlist is not None
+        return _waitlist_to_admin_response(waitlist)
+    except ValueError:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating waitlist {waitlist_id}: {e}")
+        raise DatabaseError("Failed to update waitlist") from e
+
+
+async def delete_waitlist_admin(waitlist_id: str) -> None:
+    """Soft delete a waitlist (admin only)."""
+    logger.info(f"Soft deleting waitlist {waitlist_id}")
+
+    try:
+        # Check if waitlist exists first
+        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
+            where={"id": waitlist_id},
+        )
+
+        if not waitlist:
+            raise ValueError(f"Waitlist {waitlist_id} not found")
+
+        if waitlist.isDeleted:
+            raise ValueError(f"Waitlist {waitlist_id} has already been deleted")
+
+        await prisma.models.WaitlistEntry.prisma().update(
+            where={"id": waitlist_id},
+            data={"isDeleted": True},
+        )
+    except ValueError:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting waitlist {waitlist_id}: {e}")
+        raise DatabaseError("Failed to delete waitlist") from e
+
+
+async def get_waitlist_signups_admin(
+    waitlist_id: str,
+) -> store_model.WaitlistSignupListResponse:
+    """Get all signups for a waitlist (admin only)."""
+    try:
+        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
+            where={"id": waitlist_id},
+            include={"joinedUsers": True},
+        )
+
+        if not waitlist:
+            raise ValueError(f"Waitlist {waitlist_id} not found")
+
+        signups: list[store_model.WaitlistSignup] = []
+
+        # Add user signups
+        for user in waitlist.joinedUsers or []:
+            signups.append(
+                store_model.WaitlistSignup(
+                    type="user",
+                    userId=user.id,
+                    email=user.email,
+                    username=user.name,
+                )
+            )
+
+        # Add email signups
+        for email in waitlist.unaffiliatedEmailUsers or []:
+            signups.append(
+                store_model.WaitlistSignup(
+                    type="email",
+                    email=email,
+                )
+            )
+
+        return store_model.WaitlistSignupListResponse(
+            waitlistId=waitlist_id,
+            signups=signups,
+            totalCount=len(signups),
+        )
+    except ValueError:
+        raise
+    except Exception as e:
+        logger.error(f"Error fetching signups for waitlist {waitlist_id}: {e}")
+        raise DatabaseError("Failed to fetch waitlist signups") from e
+
+
+async def link_waitlist_to_listing_admin(
+    waitlist_id: str,
+    store_listing_id: str,
+) -> store_model.WaitlistAdminResponse:
+    """Link a waitlist to a store listing (admin only)."""
+    logger.info(f"Linking waitlist {waitlist_id} to listing {store_listing_id}")
+
+    try:
+        # Verify the waitlist exists
+        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
+            where={"id": waitlist_id}
+        )
+
+        if not waitlist:
+            raise ValueError(f"Waitlist {waitlist_id} not found")
+
+        if waitlist.isDeleted:
+            raise ValueError(f"Waitlist {waitlist_id} has been deleted")
+
+        # Verify the store listing exists
+        listing = await prisma.models.StoreListing.prisma().find_unique(
+            where={"id": store_listing_id}
+        )
+
+        if not listing:
+            raise ValueError(f"Store listing {store_listing_id} not found")
+
+        updated_waitlist = await prisma.models.WaitlistEntry.prisma().update(
+            where={"id": waitlist_id},
+            data={"StoreListing": {"connect": {"id": store_listing_id}}},
+            include={"joinedUsers": True},
+        )
+
+        # We already verified existence above, so this should never be None
+        assert updated_waitlist is not None
+        return _waitlist_to_admin_response(updated_waitlist)
+    except ValueError:
+        raise
+    except Exception as e:
+        logger.error(f"Error linking waitlist to listing: {e}")
+        raise DatabaseError("Failed to link waitlist to listing") from e
+
+
+async def notify_waitlist_users_on_launch(
+    store_listing_id: str,
+    agent_name: str,
+    store_url: str,
+) -> int:
+    """
+    Notify all users on waitlists linked to a store listing when the agent is launched.
+
+    Args:
+        store_listing_id: The ID of the store listing that was approved
+        agent_name: The name of the approved agent
+        store_url: The URL to the agent's store page
+
+    Returns:
+        The number of notifications sent
+    """
+    logger.info(f"Notifying waitlist users for store listing {store_listing_id}")
+
+    try:
+        # Find all active waitlists linked to this store listing
+        # Exclude DONE and CANCELED to prevent duplicate notifications on re-approval
+        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
+            where={
+                "storeListingId": store_listing_id,
+                "isDeleted": False,
+                "status": {
+                    "not_in": [
+                        prisma.enums.WaitlistExternalStatus.DONE,
+                        prisma.enums.WaitlistExternalStatus.CANCELED,
+                    ]
+                },
+            },
+            include={"joinedUsers": True},
+        )
+
+        if not waitlists:
+            logger.info(
+                f"No active waitlists found for store listing {store_listing_id}"
+            )
+            return 0
+
+        notification_count = 0
+        launched_at = datetime.now(tz=timezone.utc)
+
+        for waitlist in waitlists:
+            # Track notification results for this waitlist
+            users_to_notify = waitlist.joinedUsers or []
+            failed_user_ids: list[str] = []
+
+            # Notify registered users
+            for user in users_to_notify:
+                try:
+                    notification_data = WaitlistLaunchData(
+                        agent_name=agent_name,
+                        waitlist_name=waitlist.name,
+                        store_url=store_url,
+                        launched_at=launched_at,
+                    )
+
+                    notification_event = NotificationEventModel[WaitlistLaunchData](
+                        user_id=user.id,
+                        type=prisma.enums.NotificationType.WAITLIST_LAUNCH,
+                        data=notification_data,
+                    )
+
+                    await queue_notification_async(notification_event)
+                    notification_count += 1
+                except Exception as e:
+                    logger.error(
+                        f"Failed to send waitlist launch notification to user {user.id}: {e}"
+                    )
+                    failed_user_ids.append(user.id)
+
+            # Note: For unaffiliated email users, you would need to send emails directly
+            # since they don't have user IDs for the notification system.
+            # This could be done via a separate email service.
+            # For now, we log these for potential manual follow-up or future implementation.
+            has_pending_email_users = bool(waitlist.unaffiliatedEmailUsers)
+            if has_pending_email_users:
+                logger.info(
+                    f"Waitlist {waitlist.id} has {len(waitlist.unaffiliatedEmailUsers)} "
+                    f"unaffiliated email users that need email notifications"
+                )
+
+            # Only mark waitlist as DONE if all registered user notifications succeeded
+            # AND there are no unaffiliated email users still waiting for notifications
+            if not failed_user_ids and not has_pending_email_users:
+                await prisma.models.WaitlistEntry.prisma().update(
+                    where={"id": waitlist.id},
+                    data={"status": prisma.enums.WaitlistExternalStatus.DONE},
+                )
+                logger.info(f"Updated waitlist {waitlist.id} status to DONE")
+            elif failed_user_ids:
+                logger.warning(
+                    f"Waitlist {waitlist.id} not marked as DONE due to "
+                    f"{len(failed_user_ids)} failed notifications"
+                )
+            elif has_pending_email_users:
+                logger.warning(
+                    f"Waitlist {waitlist.id} not marked as DONE due to "
+                    f"{len(waitlist.unaffiliatedEmailUsers)} pending email-only users"
+                )
+
+        logger.info(
+            f"Sent {notification_count} waitlist launch notifications for store listing {store_listing_id}"
+        )
+        return notification_count
+
+    except Exception as e:
+        logger.error(
+            f"Error notifying waitlist users for store listing {store_listing_id}: {e}"
+        )
+        # Don't raise - we don't want to fail the approval process
+        return 0
--- a/autogpt_platform/backend/backend/api/features/store/model.py
+++ b/autogpt_platform/backend/backend/api/features/store/model.py
@@ -223,6 +223,102 @@ class ReviewSubmissionRequest(pydantic.BaseModel):
    internal_comments: str | None = None  # Private admin notes


+class StoreWaitlistEntry(pydantic.BaseModel):
+    """Public waitlist entry - no PII fields exposed."""
+
+    waitlistId: str
+    slug: str
+
+    # Content fields
+    name: str
+    subHeading: str
+    videoUrl: str | None = None
+    agentOutputDemoUrl: str | None = None
+    imageUrls: list[str]
+    description: str
+    categories: list[str]
+
+
+class StoreWaitlistsAllResponse(pydantic.BaseModel):
+    listings: list[StoreWaitlistEntry]
+
+
+# Admin Waitlist Models
+
+
+class WaitlistCreateRequest(pydantic.BaseModel):
+    """Request model for creating a new waitlist."""
+
+    name: str
+    slug: str
+    subHeading: str
+    description: str
+    categories: list[str] = []
+    imageUrls: list[str] = []
+    videoUrl: str | None = None
+    agentOutputDemoUrl: str | None = None
+
+
+class WaitlistUpdateRequest(pydantic.BaseModel):
+    """Request model for updating a waitlist."""
+
+    name: str | None = None
+    slug: str | None = None
+    subHeading: str | None = None
+    description: str | None = None
+    categories: list[str] | None = None
+    imageUrls: list[str] | None = None
+    videoUrl: str | None = None
+    agentOutputDemoUrl: str | None = None
+    status: prisma.enums.WaitlistExternalStatus | None = None
+    storeListingId: str | None = None  # Link to a store listing
+
+
+class WaitlistAdminResponse(pydantic.BaseModel):
+    """Admin response model with full waitlist details including internal data."""
+
+    id: str
+    createdAt: str
+    updatedAt: str
+    slug: str
+    name: str
+    subHeading: str
+    description: str
+    categories: list[str]
+    imageUrls: list[str]
+    videoUrl: str | None = None
+    agentOutputDemoUrl: str | None = None
+    status: prisma.enums.WaitlistExternalStatus
+    votes: int
+    signupCount: int  # Total count of joinedUsers + unaffiliatedEmailUsers
+    storeListingId: str | None = None
+    owningUserId: str
+
+
+class WaitlistSignup(pydantic.BaseModel):
+    """Individual signup entry for a waitlist."""
+
+    type: str  # "user" or "email"
+    userId: str | None = None
+    email: str | None = None
+    username: str | None = None  # For user signups
+
+
+class WaitlistSignupListResponse(pydantic.BaseModel):
+    """Response model for listing waitlist signups."""
+
+    waitlistId: str
+    signups: list[WaitlistSignup]
+    totalCount: int
+
+
+class WaitlistAdminListResponse(pydantic.BaseModel):
+    """Response model for listing all waitlists (admin view)."""
+
+    waitlists: list[WaitlistAdminResponse]
+    totalCount: int
+
+
 class UnifiedSearchResult(pydantic.BaseModel):
    """A single result from unified hybrid search across all content types."""

--- a/autogpt_platform/backend/backend/api/features/store/routes.py
+++ b/autogpt_platform/backend/backend/api/features/store/routes.py
@@ -8,6 +8,7 @@ import autogpt_libs.auth
 import fastapi
 import fastapi.responses
 import prisma.enums
+from autogpt_libs.auth.dependencies import get_optional_user_id

 import backend.data.graph
 import backend.util.json
@@ -81,6 +82,74 @@ async def update_or_create_profile(
    return updated_profile


+##############################################
+############## Waitlist Endpoints ############
+##############################################
+@router.get(
+    "/waitlist",
+    summary="Get the agent waitlist",
+    tags=["store", "public"],
+    response_model=store_model.StoreWaitlistsAllResponse,
+)
+async def get_waitlist():
+    """
+    Get all active waitlists for public display.
+    """
+    waitlists = await store_db.get_waitlist()
+    return store_model.StoreWaitlistsAllResponse(listings=waitlists)
+
+
+@router.get(
+    "/waitlist/my-memberships",
+    summary="Get waitlist IDs the current user has joined",
+    tags=["store", "private"],
+)
+async def get_my_waitlist_memberships(
+    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+) -> list[str]:
+    """Returns list of waitlist IDs the authenticated user has joined."""
+    return await store_db.get_user_waitlist_memberships(user_id)
+
+
+@router.post(
+    path="/waitlist/{waitlist_id}/join",
+    summary="Add self to the agent waitlist",
+    tags=["store", "public"],
+    response_model=store_model.StoreWaitlistEntry,
+)
+async def add_self_to_waitlist(
+    user_id: str | None = fastapi.Security(get_optional_user_id),
+    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist to join"),
+    email: str | None = fastapi.Body(
+        default=None, embed=True, description="Email address for unauthenticated users"
+    ),
+):
+    """
+    Add the current user to the agent waitlist.
+    """
+    if not user_id and not email:
+        raise fastapi.HTTPException(
+            status_code=400,
+            detail="Either user authentication or email address is required",
+        )
+
+    try:
+        waitlist_entry = await store_db.add_user_to_waitlist(
+            waitlist_id=waitlist_id, user_id=user_id, email=email
+        )
+        return waitlist_entry
+    except ValueError as e:
+        error_msg = str(e)
+        if "not found" in error_msg:
+            raise fastapi.HTTPException(status_code=404, detail="Waitlist not found")
+        # Waitlist exists but is closed or unavailable
+        raise fastapi.HTTPException(status_code=400, detail=error_msg)
+    except Exception:
+        raise fastapi.HTTPException(
+            status_code=500, detail="An error occurred while joining the waitlist"
+        )
+
+
 ##############################################
 ############### Agent Endpoints ##############
 ##############################################
--- a/autogpt_platform/backend/backend/api/rest_api.py
+++ b/autogpt_platform/backend/backend/api/rest_api.py
@@ -19,6 +19,7 @@ from prisma.errors import PrismaError
 import backend.api.features.admin.credit_admin_routes
 import backend.api.features.admin.execution_analytics_routes
 import backend.api.features.admin.store_admin_routes
+import backend.api.features.admin.waitlist_admin_routes
 import backend.api.features.builder
 import backend.api.features.builder.routes
 import backend.api.features.chat.routes as chat_routes
@@ -283,6 +284,11 @@ app.include_router(
    tags=["v2", "admin"],
    prefix="/api/store",
 )
+app.include_router(
+    backend.api.features.admin.waitlist_admin_routes.router,
+    tags=["v2", "admin"],
+    prefix="/api/store",
+)
 app.include_router(
    backend.api.features.admin.credit_admin_routes.router,
    tags=["v2", "admin"],
--- a/autogpt_platform/backend/backend/data/analytics.py
+++ b/autogpt_platform/backend/backend/data/analytics.py
@@ -104,7 +104,7 @@ async def get_accuracy_trends_and_alerts(
            AND e."executionStatus" IN ('COMPLETED', 'FAILED', 'TERMINATED')
            {user_filter}
        GROUP BY DATE(e."createdAt")
-        HAVING COUNT(*) >= 3  -- Need at least 3 executions per day
+        HAVING COUNT(*) >= 1  -- Include all days with at least 1 execution
    ),
    trends AS (
        SELECT 
--- a/autogpt_platform/backend/backend/data/execution.py
+++ b/autogpt_platform/backend/backend/data/execution.py
@@ -153,8 +153,14 @@ class GraphExecutionMeta(BaseDbModel):
    nodes_input_masks: Optional[dict[str, BlockInput]]
    preset_id: Optional[str]
    status: ExecutionStatus
-    started_at: datetime
-    ended_at: datetime
+    started_at: Optional[datetime] = Field(
+        None,
+        description="When execution started running. Null if not yet started (QUEUED).",
+    )
+    ended_at: Optional[datetime] = Field(
+        None,
+        description="When execution finished. Null if not yet completed (QUEUED, RUNNING, INCOMPLETE, REVIEW).",
+    )
    is_shared: bool = False
    share_token: Optional[str] = None

@@ -229,10 +235,8 @@ class GraphExecutionMeta(BaseDbModel):

    @staticmethod
    def from_db(_graph_exec: AgentGraphExecution):
-        now = datetime.now(timezone.utc)
-        # TODO: make started_at and ended_at optional
-        start_time = _graph_exec.startedAt or _graph_exec.createdAt
-        end_time = _graph_exec.updatedAt or now
+        start_time = _graph_exec.startedAt
+        end_time = _graph_exec.endedAt

        try:
            stats = GraphExecutionStats.model_validate(_graph_exec.stats)
@@ -902,6 +906,14 @@ async def update_graph_execution_stats(

    if status:
        update_data["executionStatus"] = status
+        # Set endedAt when execution reaches a terminal status
+        terminal_statuses = [
+            ExecutionStatus.COMPLETED,
+            ExecutionStatus.FAILED,
+            ExecutionStatus.TERMINATED,
+        ]
+        if status in terminal_statuses:
+            update_data["endedAt"] = datetime.now(tz=timezone.utc)

    where_clause: AgentGraphExecutionWhereInput = {"id": graph_exec_id}

--- a/autogpt_platform/backend/backend/data/notifications.py
+++ b/autogpt_platform/backend/backend/data/notifications.py
@@ -211,6 +211,22 @@ class AgentRejectionData(BaseNotificationData):
        return value


+class WaitlistLaunchData(BaseNotificationData):
+    """Notification data for when an agent from a waitlist is launched."""
+
+    agent_name: str
+    waitlist_name: str
+    store_url: str
+    launched_at: datetime
+
+    @field_validator("launched_at")
+    @classmethod
+    def validate_timezone(cls, value: datetime):
+        if value.tzinfo is None:
+            raise ValueError("datetime must have timezone information")
+        return value
+
+
 NotificationData = Annotated[
    Union[
        AgentRunData,
@@ -223,6 +239,7 @@ NotificationData = Annotated[
        DailySummaryData,
        RefundRequestData,
        BaseSummaryData,
+        WaitlistLaunchData,
    ],
    Field(discriminator="type"),
 ]
@@ -273,6 +290,7 @@ def get_notif_data_type(
        NotificationType.REFUND_PROCESSED: RefundRequestData,
        NotificationType.AGENT_APPROVED: AgentApprovalData,
        NotificationType.AGENT_REJECTED: AgentRejectionData,
+        NotificationType.WAITLIST_LAUNCH: WaitlistLaunchData,
    }[notification_type]


@@ -318,6 +336,7 @@ class NotificationTypeOverride:
            NotificationType.REFUND_PROCESSED: QueueType.ADMIN,
            NotificationType.AGENT_APPROVED: QueueType.IMMEDIATE,
            NotificationType.AGENT_REJECTED: QueueType.IMMEDIATE,
+            NotificationType.WAITLIST_LAUNCH: QueueType.IMMEDIATE,
        }
        return BATCHING_RULES.get(self.notification_type, QueueType.IMMEDIATE)

@@ -337,6 +356,7 @@ class NotificationTypeOverride:
            NotificationType.REFUND_PROCESSED: "refund_processed.html",
            NotificationType.AGENT_APPROVED: "agent_approved.html",
            NotificationType.AGENT_REJECTED: "agent_rejected.html",
+            NotificationType.WAITLIST_LAUNCH: "waitlist_launch.html",
        }[self.notification_type]

    @property
@@ -354,6 +374,7 @@ class NotificationTypeOverride:
            NotificationType.REFUND_PROCESSED: "Refund for ${{data.amount / 100}} to {{data.user_name}} has been processed",
            NotificationType.AGENT_APPROVED: "🎉 Your agent '{{data.agent_name}}' has been approved!",
            NotificationType.AGENT_REJECTED: "Your agent '{{data.agent_name}}' needs some updates",
+            NotificationType.WAITLIST_LAUNCH: "🚀 {{data.agent_name}} is now available!",
        }[self.notification_type]


--- a/autogpt_platform/backend/backend/integrations/credentials_store.py
+++ b/autogpt_platform/backend/backend/integrations/credentials_store.py
@@ -96,9 +96,9 @@ jina_credentials = APIKeyCredentials(
 )
 unreal_credentials = APIKeyCredentials(
    id="66f20754-1b81-48e4-91d0-f4f0dd82145f",
-    provider="unreal",
+    provider="unreal_speech",
    api_key=SecretStr(settings.secrets.unreal_speech_api_key),
-    title="Use Credits for Unreal",
+    title="Use Credits for Unreal Speech",
    expires_at=None,
 )
 open_router_credentials = APIKeyCredentials(
@@ -216,6 +216,14 @@ webshare_proxy_credentials = UserPasswordCredentials(
    title="Use Credits for Webshare Proxy",
 )

+openweathermap_credentials = APIKeyCredentials(
+    id="8b3d4e5f-6a7b-8c9d-0e1f-2a3b4c5d6e7f",
+    provider="openweathermap",
+    api_key=SecretStr(settings.secrets.openweathermap_api_key),
+    title="Use Credits for OpenWeatherMap",
+    expires_at=None,
+)
+
 DEFAULT_CREDENTIALS = [
    ollama_credentials,
    revid_credentials,
@@ -243,6 +251,7 @@ DEFAULT_CREDENTIALS = [
    llama_api_credentials,
    v0_credentials,
    webshare_proxy_credentials,
+    openweathermap_credentials,
 ]

 SYSTEM_CREDENTIAL_IDS = {cred.id for cred in DEFAULT_CREDENTIALS}
@@ -346,11 +355,17 @@ class IntegrationCredentialsStore:
            all_credentials.append(zerobounce_credentials)
        if settings.secrets.google_maps_api_key:
            all_credentials.append(google_maps_credentials)
+        if settings.secrets.llama_api_key:
+            all_credentials.append(llama_api_credentials)
+        if settings.secrets.v0_api_key:
+            all_credentials.append(v0_credentials)
        if (
            settings.secrets.webshare_proxy_username
            and settings.secrets.webshare_proxy_password
        ):
            all_credentials.append(webshare_proxy_credentials)
+        if settings.secrets.openweathermap_api_key:
+            all_credentials.append(openweathermap_credentials)
        return all_credentials

    async def get_creds_by_id(
--- a/autogpt_platform/backend/backend/monitoring/late_execution_monitor.py
+++ b/autogpt_platform/backend/backend/monitoring/late_execution_monitor.py
@@ -60,8 +60,10 @@ class LateExecutionMonitor:
        if not all_late_executions:
            return "No late executions detected."

-        # Sort by created time (oldest first)
-        all_late_executions.sort(key=lambda x: x.started_at)
+        # Sort by started time (oldest first), with None values (unstarted) first
+        all_late_executions.sort(
+            key=lambda x: x.started_at or datetime.min.replace(tzinfo=timezone.utc)
+        )

        num_total_late = len(all_late_executions)
        num_queued = len(queued_late_executions)
@@ -74,7 +76,7 @@ class LateExecutionMonitor:
        was_truncated = num_total_late > tuncate_size

        late_execution_details = [
-            f"* `Execution ID: {exec.id}, Graph ID: {exec.graph_id}v{exec.graph_version}, User ID: {exec.user_id}, Status: {exec.status}, Created At: {exec.started_at.isoformat()}`"
+            f"* `Execution ID: {exec.id}, Graph ID: {exec.graph_id}v{exec.graph_version}, User ID: {exec.user_id}, Status: {exec.status}, Started At: {exec.started_at.isoformat() if exec.started_at else 'Not started'}`"
            for exec in truncated_executions
        ]

--- a/autogpt_platform/backend/backend/notifications/templates/waitlist_launch.html.jinja2
+++ b/autogpt_platform/backend/backend/notifications/templates/waitlist_launch.html.jinja2
@@ -0,0 +1,59 @@
+{# Waitlist Launch Notification Email Template #}
+{#
+  Template variables:
+  data.agent_name: the name of the launched agent
+  data.waitlist_name: the name of the waitlist the user joined
+  data.store_url: URL to view the agent in the store
+  data.launched_at: when the agent was launched
+
+  Subject: {{ data.agent_name }} is now available!
+#}
+
+{% block content %}
+<h1 style="color: #7c3aed; font-size: 32px; font-weight: 700; margin: 0 0 24px 0; text-align: center;">
+  The wait is over!
+</h1>
+
+<p style="color: #586069; font-size: 18px; text-align: center; margin: 0 0 24px 0;">
+  <strong>'{{ data.agent_name }}'</strong> is now live in the AutoGPT Store!
+</p>
+
+<div style="height: 32px; background: transparent;"></div>
+
+<div style="background: #f3e8ff; border: 1px solid #d8b4fe; border-radius: 8px; padding: 20px; margin: 0;">
+  <h3 style="color: #6b21a8; font-size: 16px; font-weight: 600; margin: 0 0 12px 0;">
+    You're one of the first to know!
+  </h3>
+  <p style="color: #6b21a8; margin: 0; font-size: 16px; line-height: 1.5;">
+    You signed up for the <strong>{{ data.waitlist_name }}</strong> waitlist, and we're excited to let you know that this agent is now ready for you to use.
+  </p>
+</div>
+
+<div style="height: 32px; background: transparent;"></div>
+
+<div style="text-align: center; margin: 24px 0;">
+  <a href="{{ data.store_url }}" style="display: inline-block; background: linear-gradient(135deg, #7c3aed 0%, #5b21b6 100%); color: white; text-decoration: none; padding: 14px 28px; border-radius: 6px; font-weight: 600; font-size: 16px;">
+    Get {{ data.agent_name }} Now
+  </a>
+</div>
+
+<div style="height: 32px; background: transparent;"></div>
+
+<div style="background: #d1ecf1; border: 1px solid #bee5eb; border-radius: 8px; padding: 20px; margin: 0;">
+  <h3 style="color: #0c5460; font-size: 16px; font-weight: 600; margin: 0 0 12px 0;">
+    What can you do now?
+  </h3>
+  <ul style="color: #0c5460; margin: 0; padding-left: 18px; font-size: 16px; line-height: 1.6;">
+    <li>Visit the store to learn more about what this agent can do</li>
+    <li>Install and start using the agent right away</li>
+    <li>Share it with others who might find it useful</li>
+  </ul>
+</div>
+
+<div style="height: 32px; background: transparent;"></div>
+
+<p style="color: #6a737d; font-size: 14px; text-align: center; margin: 24px 0;">
+  Thank you for helping us prioritize what to build! Your interest made this happen.
+</p>
+
+{% endblock %}
--- a/autogpt_platform/backend/migrations/20260108032037_add_waitlist_launch_notification/migration.sql
+++ b/autogpt_platform/backend/migrations/20260108032037_add_waitlist_launch_notification/migration.sql
@@ -0,0 +1,53 @@
+-- CreateEnum
+CREATE TYPE "WaitlistExternalStatus" AS ENUM ('DONE', 'NOT_STARTED', 'CANCELED', 'WORK_IN_PROGRESS');
+
+-- AlterEnum
+ALTER TYPE "NotificationType" ADD VALUE 'WAITLIST_LAUNCH';
+
+-- CreateTable
+CREATE TABLE "WaitlistEntry" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "storeListingId" TEXT,
+    "owningUserId" TEXT NOT NULL,
+    "slug" TEXT NOT NULL,
+    "search" tsvector DEFAULT ''::tsvector,
+    "name" TEXT NOT NULL,
+    "subHeading" TEXT NOT NULL,
+    "videoUrl" TEXT,
+    "agentOutputDemoUrl" TEXT,
+    "imageUrls" TEXT[],
+    "description" TEXT NOT NULL,
+    "categories" TEXT[],
+    "status" "WaitlistExternalStatus" NOT NULL DEFAULT 'NOT_STARTED',
+    "votes" INTEGER NOT NULL DEFAULT 0,
+    "unaffiliatedEmailUsers" TEXT[] DEFAULT ARRAY[]::TEXT[],
+    "isDeleted" BOOLEAN NOT NULL DEFAULT false,
+
+    CONSTRAINT "WaitlistEntry_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "_joinedWaitlists" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "_joinedWaitlists_AB_unique" ON "_joinedWaitlists"("A", "B");
+
+-- CreateIndex
+CREATE INDEX "_joinedWaitlists_B_index" ON "_joinedWaitlists"("B");
+
+-- AddForeignKey
+ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_storeListingId_fkey" FOREIGN KEY ("storeListingId") REFERENCES "StoreListing"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_owningUserId_fkey" FOREIGN KEY ("owningUserId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "_joinedWaitlists" ADD CONSTRAINT "_joinedWaitlists_A_fkey" FOREIGN KEY ("A") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "_joinedWaitlists" ADD CONSTRAINT "_joinedWaitlists_B_fkey" FOREIGN KEY ("B") REFERENCES "WaitlistEntry"("id") ON DELETE CASCADE ON UPDATE CASCADE;
--- a/autogpt_platform/backend/migrations/20260113170839_add_ended_at_to_agent_graph_execution/migration.sql
+++ b/autogpt_platform/backend/migrations/20260113170839_add_ended_at_to_agent_graph_execution/migration.sql
@@ -0,0 +1,8 @@
+-- AlterTable
+ALTER TABLE "AgentGraphExecution" ADD COLUMN "endedAt" TIMESTAMP(3);
+
+-- Set endedAt to updatedAt for existing records with terminal status only
+UPDATE "AgentGraphExecution"
+SET "endedAt" = "updatedAt"
+WHERE "endedAt" IS NULL
+  AND "executionStatus" IN ('COMPLETED', 'FAILED', 'TERMINATED');
--- a/autogpt_platform/backend/schema.prisma
+++ b/autogpt_platform/backend/schema.prisma
@@ -69,6 +69,10 @@ model User {
  OAuthAuthorizationCodes OAuthAuthorizationCode[]
  OAuthAccessTokens       OAuthAccessToken[]
  OAuthRefreshTokens      OAuthRefreshToken[]
+
+  // Waitlist relations
+  waitlistEntries       WaitlistEntry[]
+  joinedWaitlists       WaitlistEntry[] @relation("joinedWaitlists")
 }

 enum OnboardingStep {
@@ -295,6 +299,7 @@ enum NotificationType {
  REFUND_PROCESSED
  AGENT_APPROVED
  AGENT_REJECTED
+  WAITLIST_LAUNCH
 }

 model NotificationEvent {
@@ -450,6 +455,7 @@ model AgentGraphExecution {
  createdAt DateTime  @default(now())
  updatedAt DateTime? @updatedAt
  startedAt DateTime?
+  endedAt   DateTime?

  isDeleted Boolean @default(false)

@@ -900,7 +906,8 @@ model StoreListing {
  OwningUser   User   @relation(fields: [owningUserId], references: [id])

  // Relations
-  Versions StoreListingVersion[] @relation("ListingVersions")
+  Versions        StoreListingVersion[] @relation("ListingVersions")
+  waitlistEntries WaitlistEntry[]

  // Unique index on agentId to ensure only one listing per agent, regardless of number of versions the agent has.
  @@unique([agentGraphId])
@@ -1032,6 +1039,47 @@ model StoreListingReview {
  @@index([reviewByUserId])
 }

+enum WaitlistExternalStatus {
+  DONE
+  NOT_STARTED
+  CANCELED
+  WORK_IN_PROGRESS
+}
+
+model WaitlistEntry {
+  id        String   @id @default(uuid())
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  storeListingId String?
+  StoreListing   StoreListing? @relation(fields: [storeListingId], references: [id], onDelete: SetNull)
+
+  owningUserId String
+  OwningUser   User   @relation(fields: [owningUserId], references: [id])
+
+  slug   String
+  search Unsupported("tsvector")? @default(dbgenerated("''::tsvector"))
+
+  // Content fields
+  name               String
+  subHeading         String
+  videoUrl           String?
+  agentOutputDemoUrl String?
+  imageUrls          String[]
+  description        String
+  categories         String[]
+
+  //Waitlist specific fields
+  status                 WaitlistExternalStatus @default(NOT_STARTED)
+  votes                  Int                    @default(0) // Hide from frontend api
+  joinedUsers            User[]                 @relation("joinedWaitlists")
+  // NOTE: DO NOT DOUBLE SEND TO THESE USERS, IF THEY HAVE SIGNED UP SINCE THEY MAY HAVE ALREADY RECEIVED AN EMAIL
+  // DOUBLE CHECK WHEN SENDING THAT THEY ARE NOT IN THE JOINED USERS LIST ALSO
+  unaffiliatedEmailUsers String[]               @default([])
+
+  isDeleted Boolean @default(false)
+}
+
 enum SubmissionStatus {
  DRAFT // Being prepared, not yet submitted
  PENDING // Submitted, awaiting review
--- a/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/AnalyticsResultsTable.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/AnalyticsResultsTable.tsx
@@ -51,6 +51,8 @@ export function AnalyticsResultsTable({ results }: Props) {
      "Execution ID",
      "Status",
      "Score",
+      "Started At",
+      "Ended At",
      "Summary Text",
      "Error Message",
    ];
@@ -62,6 +64,8 @@ export function AnalyticsResultsTable({ results }: Props) {
      result.exec_id,
      result.status,
      result.score?.toString() || "",
+      result.started_at ? new Date(result.started_at).toLocaleString() : "",
+      result.ended_at ? new Date(result.ended_at).toLocaleString() : "",
      `"${(result.summary_text || "").replace(/"/g, '""')}"`, // Escape quotes in summary
      `"${(result.error_message || "").replace(/"/g, '""')}"`, // Escape quotes in error
    ]);
@@ -248,15 +252,13 @@ export function AnalyticsResultsTable({ results }: Props) {
                        )}
                      </td>
                      <td className="px-4 py-3">
-                        {(result.summary_text || result.error_message) && (
-                          <Button
-                            variant="ghost"
-                            size="small"
-                            onClick={() => toggleRowExpansion(result.exec_id)}
-                          >
-                            <EyeIcon size={16} />
-                          </Button>
-                        )}
+                        <Button
+                          variant="ghost"
+                          size="small"
+                          onClick={() => toggleRowExpansion(result.exec_id)}
+                        >
+                          <EyeIcon size={16} />
+                        </Button>
                      </td>
                    </tr>

@@ -264,6 +266,44 @@ export function AnalyticsResultsTable({ results }: Props) {
                      <tr>
                        <td colSpan={7} className="bg-gray-50 px-4 py-3">
                          <div className="space-y-3">
+                            {/* Timestamps section */}
+                            <div className="grid grid-cols-2 gap-4 border-b border-gray-200 pb-3">
+                              <div>
+                                <Text
+                                  variant="body"
+                                  className="text-xs font-medium text-gray-600"
+                                >
+                                  Started At:
+                                </Text>
+                                <Text
+                                  variant="body"
+                                  className="text-sm text-gray-700"
+                                >
+                                  {result.started_at
+                                    ? new Date(
+                                        result.started_at,
+                                      ).toLocaleString()
+                                    : "—"}
+                                </Text>
+                              </div>
+                              <div>
+                                <Text
+                                  variant="body"
+                                  className="text-xs font-medium text-gray-600"
+                                >
+                                  Ended At:
+                                </Text>
+                                <Text
+                                  variant="body"
+                                  className="text-sm text-gray-700"
+                                >
+                                  {result.ended_at
+                                    ? new Date(result.ended_at).toLocaleString()
+                                    : "—"}
+                                </Text>
+                              </div>
+                            </div>
+
                            {result.summary_text && (
                              <div>
                                <Text
--- a/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/ExecutionAnalyticsForm.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/ExecutionAnalyticsForm.tsx
@@ -541,7 +541,19 @@ export function ExecutionAnalyticsForm() {
      {/* Accuracy Trends Display */}
      {trendsData && (
        <div className="space-y-4">
-          <h3 className="text-lg font-semibold">Execution Accuracy Trends</h3>
+          <div className="flex items-start justify-between">
+            <h3 className="text-lg font-semibold">Execution Accuracy Trends</h3>
+            <div className="rounded-md bg-blue-50 px-3 py-2 text-xs text-blue-700">
+              <p className="font-medium">
+                Chart Filters (matches monitoring system):
+              </p>
+              <ul className="mt-1 list-inside list-disc space-y-1">
+                <li>Only days with ≥1 execution with correctness score</li>
+                <li>Last 30 days</li>
+                <li>Averages calculated from scored executions only</li>
+              </ul>
+            </div>
+          </div>

          {/* Alert Section */}
          {trendsData.alert && (
--- a/autogpt_platform/frontend/src/app/(platform)/admin/layout.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/layout.tsx
@@ -1,5 +1,5 @@
 import { Sidebar } from "@/components/__legacy__/Sidebar";
-import { Users, DollarSign, UserSearch, FileText } from "lucide-react";
+import { Users, DollarSign, UserSearch, FileText, Clock } from "lucide-react";

 import { IconSliders } from "@/components/__legacy__/ui/icons";

@@ -11,6 +11,11 @@ const sidebarLinkGroups = [
        href: "/admin/marketplace",
        icon: <Users className="h-6 w-6" />,
      },
+      {
+        text: "Waitlist Management",
+        href: "/admin/waitlist",
+        icon: <Clock className="h-6 w-6" />,
+      },
      {
        text: "User Spending",
        href: "/admin/spending",
--- a/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/CreateWaitlistButton.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/CreateWaitlistButton.tsx
@@ -0,0 +1,217 @@
+"use client";
+
+import { useState } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { Button } from "@/components/atoms/Button/Button";
+import { Input } from "@/components/atoms/Input/Input";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import {
+  usePostV2CreateWaitlist,
+  getGetV2ListAllWaitlistsQueryKey,
+} from "@/app/api/__generated__/endpoints/admin/admin";
+import { useToast } from "@/components/molecules/Toast/use-toast";
+import { Plus } from "@phosphor-icons/react";
+
+export function CreateWaitlistButton() {
+  const [open, setOpen] = useState(false);
+  const { toast } = useToast();
+  const queryClient = useQueryClient();
+
+  const createWaitlistMutation = usePostV2CreateWaitlist({
+    mutation: {
+      onSuccess: (response) => {
+        if (response.status === 200) {
+          toast({
+            title: "Success",
+            description: "Waitlist created successfully",
+          });
+          setOpen(false);
+          setFormData({
+            name: "",
+            slug: "",
+            subHeading: "",
+            description: "",
+            categories: "",
+            imageUrls: "",
+            videoUrl: "",
+            agentOutputDemoUrl: "",
+          });
+          queryClient.invalidateQueries({
+            queryKey: getGetV2ListAllWaitlistsQueryKey(),
+          });
+        } else {
+          toast({
+            variant: "destructive",
+            title: "Error",
+            description: "Failed to create waitlist",
+          });
+        }
+      },
+      onError: (error) => {
+        console.error("Error creating waitlist:", error);
+        toast({
+          variant: "destructive",
+          title: "Error",
+          description: "Failed to create waitlist",
+        });
+      },
+    },
+  });
+
+  const [formData, setFormData] = useState({
+    name: "",
+    slug: "",
+    subHeading: "",
+    description: "",
+    categories: "",
+    imageUrls: "",
+    videoUrl: "",
+    agentOutputDemoUrl: "",
+  });
+
+  function handleInputChange(id: string, value: string) {
+    setFormData((prev) => ({
+      ...prev,
+      [id]: value,
+    }));
+  }
+
+  function generateSlug(name: string) {
+    return name
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, "");
+  }
+
+  function handleSubmit(e: React.FormEvent) {
+    e.preventDefault();
+
+    createWaitlistMutation.mutate({
+      data: {
+        name: formData.name,
+        slug: formData.slug || generateSlug(formData.name),
+        subHeading: formData.subHeading,
+        description: formData.description,
+        categories: formData.categories
+          ? formData.categories.split(",").map((c) => c.trim())
+          : [],
+        imageUrls: formData.imageUrls
+          ? formData.imageUrls.split(",").map((u) => u.trim())
+          : [],
+        videoUrl: formData.videoUrl || null,
+        agentOutputDemoUrl: formData.agentOutputDemoUrl || null,
+      },
+    });
+  }
+
+  return (
+    <>
+      <Button onClick={() => setOpen(true)}>
+        <Plus size={16} className="mr-2" />
+        Create Waitlist
+      </Button>
+
+      <Dialog
+        title="Create New Waitlist"
+        controlled={{
+          isOpen: open,
+          set: async (isOpen) => setOpen(isOpen),
+        }}
+        onClose={() => setOpen(false)}
+        styling={{ maxWidth: "600px" }}
+      >
+        <Dialog.Content>
+          <p className="mb-4 text-sm text-zinc-500">
+            Create a new waitlist for an upcoming agent. Users can sign up to be
+            notified when it launches.
+          </p>
+          <form onSubmit={handleSubmit} className="flex flex-col gap-2">
+            <Input
+              id="name"
+              label="Name"
+              value={formData.name}
+              onChange={(e) => handleInputChange("name", e.target.value)}
+              placeholder="SEO Analysis Agent"
+              required
+            />
+
+            <Input
+              id="slug"
+              label="Slug"
+              value={formData.slug}
+              onChange={(e) => handleInputChange("slug", e.target.value)}
+              placeholder="seo-analysis-agent (auto-generated if empty)"
+            />
+
+            <Input
+              id="subHeading"
+              label="Subheading"
+              value={formData.subHeading}
+              onChange={(e) => handleInputChange("subHeading", e.target.value)}
+              placeholder="Analyze your website's SEO in minutes"
+              required
+            />
+
+            <Input
+              id="description"
+              label="Description"
+              type="textarea"
+              value={formData.description}
+              onChange={(e) => handleInputChange("description", e.target.value)}
+              placeholder="Detailed description of what this agent does..."
+              rows={4}
+              required
+            />
+
+            <Input
+              id="categories"
+              label="Categories (comma-separated)"
+              value={formData.categories}
+              onChange={(e) => handleInputChange("categories", e.target.value)}
+              placeholder="SEO, Marketing, Analysis"
+            />
+
+            <Input
+              id="imageUrls"
+              label="Image URLs (comma-separated)"
+              value={formData.imageUrls}
+              onChange={(e) => handleInputChange("imageUrls", e.target.value)}
+              placeholder="https://example.com/image1.jpg, https://example.com/image2.jpg"
+            />
+
+            <Input
+              id="videoUrl"
+              label="Video URL (optional)"
+              value={formData.videoUrl}
+              onChange={(e) => handleInputChange("videoUrl", e.target.value)}
+              placeholder="https://youtube.com/watch?v=..."
+            />
+
+            <Input
+              id="agentOutputDemoUrl"
+              label="Output Demo URL (optional)"
+              value={formData.agentOutputDemoUrl}
+              onChange={(e) =>
+                handleInputChange("agentOutputDemoUrl", e.target.value)
+              }
+              placeholder="https://example.com/demo-output.mp4"
+            />
+
+            <Dialog.Footer>
+              <Button
+                type="button"
+                variant="secondary"
+                onClick={() => setOpen(false)}
+              >
+                Cancel
+              </Button>
+              <Button type="submit" loading={createWaitlistMutation.isPending}>
+                Create Waitlist
+              </Button>
+            </Dialog.Footer>
+          </form>
+        </Dialog.Content>
+      </Dialog>
+    </>
+  );
+}
--- a/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/EditWaitlistDialog.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/EditWaitlistDialog.tsx
@@ -0,0 +1,221 @@
+"use client";
+
+import { useState } from "react";
+import { Button } from "@/components/atoms/Button/Button";
+import { Input } from "@/components/atoms/Input/Input";
+import { Select } from "@/components/atoms/Select/Select";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { useToast } from "@/components/molecules/Toast/use-toast";
+import { usePutV2UpdateWaitlist } from "@/app/api/__generated__/endpoints/admin/admin";
+import type { WaitlistAdminResponse } from "@/app/api/__generated__/models/waitlistAdminResponse";
+import type { WaitlistUpdateRequest } from "@/app/api/__generated__/models/waitlistUpdateRequest";
+import { WaitlistExternalStatus } from "@/app/api/__generated__/models/waitlistExternalStatus";
+
+type EditWaitlistDialogProps = {
+  waitlist: WaitlistAdminResponse;
+  onClose: () => void;
+  onSave: () => void;
+};
+
+const STATUS_OPTIONS = [
+  { value: WaitlistExternalStatus.NOT_STARTED, label: "Not Started" },
+  { value: WaitlistExternalStatus.WORK_IN_PROGRESS, label: "Work In Progress" },
+  { value: WaitlistExternalStatus.DONE, label: "Done" },
+  { value: WaitlistExternalStatus.CANCELED, label: "Canceled" },
+];
+
+export function EditWaitlistDialog({
+  waitlist,
+  onClose,
+  onSave,
+}: EditWaitlistDialogProps) {
+  const { toast } = useToast();
+  const updateWaitlistMutation = usePutV2UpdateWaitlist();
+
+  const [formData, setFormData] = useState({
+    name: waitlist.name,
+    slug: waitlist.slug,
+    subHeading: waitlist.subHeading,
+    description: waitlist.description,
+    categories: waitlist.categories.join(", "),
+    imageUrls: waitlist.imageUrls.join(", "),
+    videoUrl: waitlist.videoUrl || "",
+    agentOutputDemoUrl: waitlist.agentOutputDemoUrl || "",
+    status: waitlist.status,
+    storeListingId: waitlist.storeListingId || "",
+  });
+
+  function handleInputChange(id: string, value: string) {
+    setFormData((prev) => ({
+      ...prev,
+      [id]: value,
+    }));
+  }
+
+  function handleStatusChange(value: string) {
+    setFormData((prev) => ({
+      ...prev,
+      status: value as WaitlistExternalStatus,
+    }));
+  }
+
+  async function handleSubmit(e: React.FormEvent) {
+    e.preventDefault();
+
+    const updateData: WaitlistUpdateRequest = {
+      name: formData.name,
+      slug: formData.slug,
+      subHeading: formData.subHeading,
+      description: formData.description,
+      categories: formData.categories
+        ? formData.categories.split(",").map((c) => c.trim())
+        : [],
+      imageUrls: formData.imageUrls
+        ? formData.imageUrls.split(",").map((u) => u.trim())
+        : [],
+      videoUrl: formData.videoUrl || null,
+      agentOutputDemoUrl: formData.agentOutputDemoUrl || null,
+      status: formData.status,
+      storeListingId: formData.storeListingId || null,
+    };
+
+    updateWaitlistMutation.mutate(
+      { waitlistId: waitlist.id, data: updateData },
+      {
+        onSuccess: (response) => {
+          if (response.status === 200) {
+            toast({
+              title: "Success",
+              description: "Waitlist updated successfully",
+            });
+            onSave();
+          } else {
+            toast({
+              variant: "destructive",
+              title: "Error",
+              description: "Failed to update waitlist",
+            });
+          }
+        },
+        onError: () => {
+          toast({
+            variant: "destructive",
+            title: "Error",
+            description: "Failed to update waitlist",
+          });
+        },
+      },
+    );
+  }
+
+  return (
+    <Dialog
+      title="Edit Waitlist"
+      controlled={{
+        isOpen: true,
+        set: async (open) => {
+          if (!open) onClose();
+        },
+      }}
+      onClose={onClose}
+      styling={{ maxWidth: "600px" }}
+    >
+      <Dialog.Content>
+        <p className="mb-4 text-sm text-zinc-500">
+          Update the waitlist details. Changes will be reflected immediately.
+        </p>
+        <form onSubmit={handleSubmit} className="flex flex-col gap-2">
+          <Input
+            id="name"
+            label="Name"
+            value={formData.name}
+            onChange={(e) => handleInputChange("name", e.target.value)}
+            required
+          />
+
+          <Input
+            id="slug"
+            label="Slug"
+            value={formData.slug}
+            onChange={(e) => handleInputChange("slug", e.target.value)}
+          />
+
+          <Input
+            id="subHeading"
+            label="Subheading"
+            value={formData.subHeading}
+            onChange={(e) => handleInputChange("subHeading", e.target.value)}
+            required
+          />
+
+          <Input
+            id="description"
+            label="Description"
+            type="textarea"
+            value={formData.description}
+            onChange={(e) => handleInputChange("description", e.target.value)}
+            rows={4}
+            required
+          />
+
+          <Select
+            id="status"
+            label="Status"
+            value={formData.status}
+            onValueChange={handleStatusChange}
+            options={STATUS_OPTIONS}
+          />
+
+          <Input
+            id="categories"
+            label="Categories (comma-separated)"
+            value={formData.categories}
+            onChange={(e) => handleInputChange("categories", e.target.value)}
+          />
+
+          <Input
+            id="imageUrls"
+            label="Image URLs (comma-separated)"
+            value={formData.imageUrls}
+            onChange={(e) => handleInputChange("imageUrls", e.target.value)}
+          />
+
+          <Input
+            id="videoUrl"
+            label="Video URL"
+            value={formData.videoUrl}
+            onChange={(e) => handleInputChange("videoUrl", e.target.value)}
+          />
+
+          <Input
+            id="agentOutputDemoUrl"
+            label="Output Demo URL"
+            value={formData.agentOutputDemoUrl}
+            onChange={(e) =>
+              handleInputChange("agentOutputDemoUrl", e.target.value)
+            }
+          />
+
+          <Input
+            id="storeListingId"
+            label="Store Listing ID (for linking)"
+            value={formData.storeListingId}
+            onChange={(e) =>
+              handleInputChange("storeListingId", e.target.value)
+            }
+            placeholder="Leave empty if not linked"
+          />
+
+          <Dialog.Footer>
+            <Button type="button" variant="secondary" onClick={onClose}>
+              Cancel
+            </Button>
+            <Button type="submit" loading={updateWaitlistMutation.isPending}>
+              Save Changes
+            </Button>
+          </Dialog.Footer>
+        </form>
+      </Dialog.Content>
+    </Dialog>
+  );
+}
--- a/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/WaitlistSignupsDialog.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/WaitlistSignupsDialog.tsx
@@ -0,0 +1,156 @@
+"use client";
+
+import { Button } from "@/components/atoms/Button/Button";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { User, Envelope, DownloadSimple } from "@phosphor-icons/react";
+import { useGetV2GetWaitlistSignups } from "@/app/api/__generated__/endpoints/admin/admin";
+
+type WaitlistSignupsDialogProps = {
+  waitlistId: string;
+  onClose: () => void;
+};
+
+export function WaitlistSignupsDialog({
+  waitlistId,
+  onClose,
+}: WaitlistSignupsDialogProps) {
+  const {
+    data: signupsResponse,
+    isLoading,
+    isError,
+  } = useGetV2GetWaitlistSignups(waitlistId);
+
+  const signups = signupsResponse?.status === 200 ? signupsResponse.data : null;
+
+  function exportToCSV() {
+    if (!signups) return;
+
+    const headers = ["Type", "Email", "User ID", "Username"];
+    const rows = signups.signups.map((signup) => [
+      signup.type,
+      signup.email || "",
+      signup.userId || "",
+      signup.username || "",
+    ]);
+
+    const escapeCell = (cell: string) => `"${cell.replace(/"/g, '""')}"`;
+
+    const csvContent = [
+      headers.join(","),
+      ...rows.map((row) => row.map(escapeCell).join(",")),
+    ].join("\n");
+
+    const blob = new Blob([csvContent], { type: "text/csv" });
+    const url = window.URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `waitlist-${waitlistId}-signups.csv`;
+    a.click();
+    window.URL.revokeObjectURL(url);
+  }
+
+  function renderContent() {
+    if (isLoading) {
+      return <div className="py-10 text-center">Loading signups...</div>;
+    }
+
+    if (isError) {
+      return (
+        <div className="py-10 text-center text-red-500">
+          Failed to load signups. Please try again.
+        </div>
+      );
+    }
+
+    if (!signups || signups.signups.length === 0) {
+      return (
+        <div className="py-10 text-center text-gray-500">
+          No signups yet for this waitlist.
+        </div>
+      );
+    }
+
+    return (
+      <>
+        <div className="flex justify-end">
+          <Button variant="secondary" size="small" onClick={exportToCSV}>
+            <DownloadSimple className="mr-2 h-4 w-4" size={16} />
+            Export CSV
+          </Button>
+        </div>
+        <div className="max-h-[400px] overflow-y-auto rounded-md border">
+          <table className="w-full">
+            <thead className="bg-gray-50 dark:bg-gray-800">
+              <tr>
+                <th className="px-4 py-3 text-left text-sm font-medium">
+                  Type
+                </th>
+                <th className="px-4 py-3 text-left text-sm font-medium">
+                  Email / Username
+                </th>
+                <th className="px-4 py-3 text-left text-sm font-medium">
+                  User ID
+                </th>
+              </tr>
+            </thead>
+            <tbody className="divide-y">
+              {signups.signups.map((signup, index) => (
+                <tr key={index}>
+                  <td className="px-4 py-3">
+                    {signup.type === "user" ? (
+                      <span className="flex items-center gap-1 text-blue-600">
+                        <User className="h-4 w-4" size={16} /> User
+                      </span>
+                    ) : (
+                      <span className="flex items-center gap-1 text-gray-600">
+                        <Envelope className="h-4 w-4" size={16} /> Email
+                      </span>
+                    )}
+                  </td>
+                  <td className="px-4 py-3">
+                    {signup.type === "user"
+                      ? signup.username || signup.email
+                      : signup.email}
+                  </td>
+                  <td className="px-4 py-3 font-mono text-sm">
+                    {signup.userId || "-"}
+                  </td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      </>
+    );
+  }
+
+  return (
+    <Dialog
+      title="Waitlist Signups"
+      controlled={{
+        isOpen: true,
+        set: async (open) => {
+          if (!open) onClose();
+        },
+      }}
+      onClose={onClose}
+      styling={{ maxWidth: "700px" }}
+    >
+      <Dialog.Content>
+        <p className="mb-4 text-sm text-zinc-500">
+          {signups
+            ? `${signups.totalCount} total signups`
+            : "Loading signups..."}
+        </p>
+
+        {renderContent()}
+
+        <Dialog.Footer>
+          <Button variant="secondary" onClick={onClose}>
+            Close
+          </Button>
+        </Dialog.Footer>
+      </Dialog.Content>
+    </Dialog>
+  );
+}
--- a/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/WaitlistTable.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/WaitlistTable.tsx
@@ -0,0 +1,206 @@
+"use client";
+
+import { useState } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/__legacy__/ui/table";
+import { Button } from "@/components/atoms/Button/Button";
+import {
+  useGetV2ListAllWaitlists,
+  useDeleteV2DeleteWaitlist,
+  getGetV2ListAllWaitlistsQueryKey,
+} from "@/app/api/__generated__/endpoints/admin/admin";
+import type { WaitlistAdminResponse } from "@/app/api/__generated__/models/waitlistAdminResponse";
+import { EditWaitlistDialog } from "./EditWaitlistDialog";
+import { WaitlistSignupsDialog } from "./WaitlistSignupsDialog";
+import { Trash, PencilSimple, Users, Link } from "@phosphor-icons/react";
+import { useToast } from "@/components/molecules/Toast/use-toast";
+
+export function WaitlistTable() {
+  const [editingWaitlist, setEditingWaitlist] =
+    useState<WaitlistAdminResponse | null>(null);
+  const [viewingSignups, setViewingSignups] = useState<string | null>(null);
+  const { toast } = useToast();
+  const queryClient = useQueryClient();
+
+  const { data: response, isLoading, error } = useGetV2ListAllWaitlists();
+
+  const deleteWaitlistMutation = useDeleteV2DeleteWaitlist({
+    mutation: {
+      onSuccess: () => {
+        toast({
+          title: "Success",
+          description: "Waitlist deleted successfully",
+        });
+        queryClient.invalidateQueries({
+          queryKey: getGetV2ListAllWaitlistsQueryKey(),
+        });
+      },
+      onError: (error) => {
+        console.error("Error deleting waitlist:", error);
+        toast({
+          variant: "destructive",
+          title: "Error",
+          description: "Failed to delete waitlist",
+        });
+      },
+    },
+  });
+
+  function handleDelete(waitlistId: string) {
+    if (!confirm("Are you sure you want to delete this waitlist?")) return;
+    deleteWaitlistMutation.mutate({ waitlistId });
+  }
+
+  function handleWaitlistSaved() {
+    setEditingWaitlist(null);
+    queryClient.invalidateQueries({
+      queryKey: getGetV2ListAllWaitlistsQueryKey(),
+    });
+  }
+
+  function formatStatus(status: string) {
+    const statusColors: Record<string, string> = {
+      NOT_STARTED: "bg-gray-100 text-gray-800",
+      WORK_IN_PROGRESS: "bg-blue-100 text-blue-800",
+      DONE: "bg-green-100 text-green-800",
+      CANCELED: "bg-red-100 text-red-800",
+    };
+
+    return (
+      <span
+        className={`rounded-full px-2 py-1 text-xs font-medium ${statusColors[status] || "bg-gray-100 text-gray-700"}`}
+      >
+        {status.replace(/_/g, " ")}
+      </span>
+    );
+  }
+
+  function formatDate(dateStr: string) {
+    if (!dateStr) return "-";
+    return new Intl.DateTimeFormat("en-US", {
+      month: "short",
+      day: "numeric",
+      year: "numeric",
+    }).format(new Date(dateStr));
+  }
+
+  if (isLoading) {
+    return <div className="py-10 text-center">Loading waitlists...</div>;
+  }
+
+  if (error) {
+    return (
+      <div className="py-10 text-center text-red-500">
+        Error loading waitlists. Please try again.
+      </div>
+    );
+  }
+
+  const waitlists = response?.status === 200 ? response.data.waitlists : [];
+
+  if (waitlists.length === 0) {
+    return (
+      <div className="py-10 text-center text-gray-500">
+        No waitlists found. Create one to get started!
+      </div>
+    );
+  }
+
+  return (
+    <>
+      <div className="rounded-md border bg-white">
+        <Table>
+          <TableHeader className="bg-gray-50">
+            <TableRow>
+              <TableHead className="font-medium">Name</TableHead>
+              <TableHead className="font-medium">Status</TableHead>
+              <TableHead className="font-medium">Signups</TableHead>
+              <TableHead className="font-medium">Votes</TableHead>
+              <TableHead className="font-medium">Created</TableHead>
+              <TableHead className="font-medium">Linked Agent</TableHead>
+              <TableHead className="font-medium">Actions</TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {waitlists.map((waitlist) => (
+              <TableRow key={waitlist.id}>
+                <TableCell>
+                  <div>
+                    <div className="font-medium">{waitlist.name}</div>
+                    <div className="text-sm text-gray-500">
+                      {waitlist.subHeading}
+                    </div>
+                  </div>
+                </TableCell>
+                <TableCell>{formatStatus(waitlist.status)}</TableCell>
+                <TableCell>{waitlist.signupCount}</TableCell>
+                <TableCell>{waitlist.votes}</TableCell>
+                <TableCell>{formatDate(waitlist.createdAt)}</TableCell>
+                <TableCell>
+                  {waitlist.storeListingId ? (
+                    <span className="text-green-600">
+                      <Link size={16} className="inline" /> Linked
+                    </span>
+                  ) : (
+                    <span className="text-gray-400">Not linked</span>
+                  )}
+                </TableCell>
+                <TableCell>
+                  <div className="flex gap-2">
+                    <Button
+                      variant="ghost"
+                      size="small"
+                      onClick={() => setViewingSignups(waitlist.id)}
+                      title="View signups"
+                    >
+                      <Users size={16} />
+                    </Button>
+                    <Button
+                      variant="ghost"
+                      size="small"
+                      onClick={() => setEditingWaitlist(waitlist)}
+                      title="Edit"
+                    >
+                      <PencilSimple size={16} />
+                    </Button>
+                    <Button
+                      variant="ghost"
+                      size="small"
+                      onClick={() => handleDelete(waitlist.id)}
+                      title="Delete"
+                      disabled={deleteWaitlistMutation.isPending}
+                    >
+                      <Trash size={16} className="text-red-500" />
+                    </Button>
+                  </div>
+                </TableCell>
+              </TableRow>
+            ))}
+          </TableBody>
+        </Table>
+      </div>
+
+      {editingWaitlist && (
+        <EditWaitlistDialog
+          waitlist={editingWaitlist}
+          onClose={() => setEditingWaitlist(null)}
+          onSave={handleWaitlistSaved}
+        />
+      )}
+
+      {viewingSignups && (
+        <WaitlistSignupsDialog
+          waitlistId={viewingSignups}
+          onClose={() => setViewingSignups(null)}
+        />
+      )}
+    </>
+  );
+}
--- a/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/page.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/page.tsx
@@ -0,0 +1,52 @@
+import { withRoleAccess } from "@/lib/withRoleAccess";
+import { Suspense } from "react";
+import { WaitlistTable } from "./components/WaitlistTable";
+import { CreateWaitlistButton } from "./components/CreateWaitlistButton";
+import { Warning } from "@phosphor-icons/react/dist/ssr";
+
+function WaitlistDashboard() {
+  return (
+    <div className="mx-auto p-6">
+      <div className="flex flex-col gap-4">
+        <div className="flex items-center justify-between">
+          <div>
+            <h1 className="text-3xl font-bold">Waitlist Management</h1>
+            <p className="text-gray-500">
+              Manage upcoming agent waitlists and track signups
+            </p>
+          </div>
+          <CreateWaitlistButton />
+        </div>
+
+        <div className="flex items-start gap-3 rounded-lg border border-amber-300 bg-amber-50 p-4 dark:border-amber-700 dark:bg-amber-950">
+          <Warning
+            className="mt-0.5 h-5 w-5 flex-shrink-0 text-amber-600 dark:text-amber-400"
+            weight="fill"
+          />
+          <div className="text-sm text-amber-800 dark:text-amber-200">
+            <p className="font-medium">TODO: Email-only signup notifications</p>
+            <p className="mt-1 text-amber-700 dark:text-amber-300">
+              Notifications for email-only signups (users who weren&apos;t
+              logged in) have not been implemented yet. Currently only
+              registered users will receive launch emails.
+            </p>
+          </div>
+        </div>
+
+        <Suspense
+          fallback={
+            <div className="py-10 text-center">Loading waitlists...</div>
+          }
+        >
+          <WaitlistTable />
+        </Suspense>
+      </div>
+    </div>
+  );
+}
+
+export default async function WaitlistDashboardPage() {
+  const withAdminAccess = await withRoleAccess(["admin"]);
+  const ProtectedWaitlistDashboard = await withAdminAccess(WaitlistDashboard);
+  return <ProtectedWaitlistDashboard />;
+}
--- a/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/OldAgentLibraryView.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/OldAgentLibraryView.tsx
@@ -173,8 +173,9 @@ export function OldAgentLibraryView() {
    if (agentRuns.length > 0) {
      // select latest run
      const latestRun = agentRuns.reduce((latest, current) => {
-        if (latest.started_at && !current.started_at) return current;
-        else if (!latest.started_at) return latest;
+        if (!latest.started_at && !current.started_at) return latest;
+        if (!latest.started_at) return current;
+        if (!current.started_at) return latest;
        return latest.started_at > current.started_at ? latest : current;
      }, agentRuns[0]);
      selectRun(latestRun.id as GraphExecutionID);
--- a/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/agent-runs-selector-list.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/agent-runs-selector-list.tsx
@@ -184,9 +184,11 @@ export function AgentRunsSelectorList({
                    ))}
                  {agentPresets.length > 0 && <Separator className="my-1" />}
                  {agentRuns
-                    .toSorted(
-                      (a, b) => b.started_at.getTime() - a.started_at.getTime(),
-                    )
+                    .toSorted((a, b) => {
+                      const aTime = a.started_at?.getTime() ?? 0;
+                      const bTime = b.started_at?.getTime() ?? 0;
+                      return bTime - aTime;
+                    })
                    .map((run) => (
                      <AgentRunSummaryCard
                        className={listItemClasses}
@@ -199,7 +201,7 @@ export function AgentRunsSelectorList({
                                ?.name
                            : null) ?? agent.name
                        }
-                        timestamp={run.started_at}
+                        timestamp={run.started_at ?? undefined}
                        selected={selectedView.id === run.id}
                        onClick={() => onSelectRun(run.id)}
                        onDelete={() => doDeleteRun(run as GraphExecutionMeta)}
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainMarketplacePage/MainMarketplacePage.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainMarketplacePage/MainMarketplacePage.tsx
@@ -8,6 +8,7 @@ import { useMainMarketplacePage } from "./useMainMarketplacePage";
 import { FeaturedCreators } from "../FeaturedCreators/FeaturedCreators";
 import { MainMarketplacePageLoading } from "../MainMarketplacePageLoading";
 import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
+import { WaitlistSection } from "../WaitlistSection/WaitlistSection";

 export const MainMarkeplacePage = () => {
  const { featuredAgents, topAgents, featuredCreators, isLoading, hasError } =
@@ -46,6 +47,10 @@ export const MainMarkeplacePage = () => {
        {/* 100px margin because our featured sections button are placed 40px below the container */}
        <Separator className="mb-6 mt-24" />

+        {/* Waitlist Section - "Help Shape What's Next" */}
+        <WaitlistSection />
+        <Separator className="mb-6 mt-12" />
+
        {topAgents && (
          <AgentsSection sectionTitle="Top Agents" agents={topAgents.agents} />
        )}
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistCard/WaitlistCard.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistCard/WaitlistCard.tsx
@@ -0,0 +1,105 @@
+"use client";
+
+import Image from "next/image";
+import { Button } from "@/components/atoms/Button/Button";
+import { Check } from "@phosphor-icons/react";
+
+interface WaitlistCardProps {
+  name: string;
+  subHeading: string;
+  description: string;
+  imageUrl: string | null;
+  isMember?: boolean;
+  onCardClick: () => void;
+  onJoinClick: (e: React.MouseEvent) => void;
+}
+
+export function WaitlistCard({
+  name,
+  subHeading,
+  description,
+  imageUrl,
+  isMember = false,
+  onCardClick,
+  onJoinClick,
+}: WaitlistCardProps) {
+  function handleJoinClick(e: React.MouseEvent) {
+    e.stopPropagation();
+    onJoinClick(e);
+  }
+
+  return (
+    <div
+      className="flex h-[24rem] w-full max-w-md cursor-pointer flex-col items-start rounded-3xl bg-white transition-all duration-300 hover:shadow-lg dark:bg-zinc-900 dark:hover:shadow-gray-700"
+      onClick={onCardClick}
+      data-testid="waitlist-card"
+      role="button"
+      tabIndex={0}
+      aria-label={`${name} waitlist card`}
+      onKeyDown={(e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          onCardClick();
+        }
+      }}
+    >
+      {/* Image Section */}
+      <div className="relative aspect-[2/1.2] w-full overflow-hidden rounded-large md:aspect-[2.17/1]">
+        {imageUrl ? (
+          <Image
+            src={imageUrl}
+            alt={`${name} preview image`}
+            fill
+            className="object-cover"
+          />
+        ) : (
+          <div className="flex h-full w-full items-center justify-center bg-gradient-to-br from-neutral-200 to-neutral-300 dark:from-neutral-700 dark:to-neutral-800">
+            <span className="text-4xl font-bold text-neutral-400 dark:text-neutral-500">
+              {name.charAt(0)}
+            </span>
+          </div>
+        )}
+      </div>
+
+      <div className="mt-3 flex w-full flex-1 flex-col px-4">
+        {/* Name and Subheading */}
+        <div className="flex w-full flex-col">
+          <h3 className="line-clamp-1 font-poppins text-xl font-semibold text-[#272727] dark:text-neutral-100">
+            {name}
+          </h3>
+          <p className="mt-1 line-clamp-1 text-sm text-neutral-500 dark:text-neutral-400">
+            {subHeading}
+          </p>
+        </div>
+
+        {/* Description */}
+        <div className="mt-2 flex w-full flex-col">
+          <p className="line-clamp-5 text-sm font-normal leading-relaxed text-neutral-600 dark:text-neutral-400">
+            {description}
+          </p>
+        </div>
+
+        <div className="flex-grow" />
+
+        {/* Join Waitlist Button */}
+        <div className="mt-4 w-full pb-4">
+          {isMember ? (
+            <Button
+              disabled
+              className="w-full rounded-full bg-green-600 text-white hover:bg-green-600 dark:bg-green-700 dark:hover:bg-green-700"
+            >
+              <Check className="mr-2" size={16} weight="bold" />
+              On the waitlist
+            </Button>
+          ) : (
+            <Button
+              onClick={handleJoinClick}
+              className="w-full rounded-full bg-zinc-800 text-white hover:bg-zinc-700 dark:bg-zinc-700 dark:hover:bg-zinc-600"
+            >
+              Join waitlist
+            </Button>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistDetailModal/WaitlistDetailModal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistDetailModal/WaitlistDetailModal.tsx
@@ -0,0 +1,356 @@
+"use client";
+
+import { useState } from "react";
+import Image from "next/image";
+import { Button } from "@/components/atoms/Button/Button";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { Input } from "@/components/atoms/Input/Input";
+import {
+  Carousel,
+  CarouselContent,
+  CarouselItem,
+  CarouselNext,
+  CarouselPrevious,
+} from "@/components/__legacy__/ui/carousel";
+import type { StoreWaitlistEntry } from "@/app/api/__generated__/models/storeWaitlistEntry";
+import { Check, Play } from "@phosphor-icons/react";
+import { useSupabaseStore } from "@/lib/supabase/hooks/useSupabaseStore";
+import { useToast } from "@/components/molecules/Toast/use-toast";
+import { usePostV2AddSelfToTheAgentWaitlist } from "@/app/api/__generated__/endpoints/store/store";
+
+interface MediaItem {
+  type: "image" | "video";
+  url: string;
+  label?: string;
+}
+
+// Extract YouTube video ID from various URL formats
+function getYouTubeVideoId(url: string): string | null {
+  const regExp =
+    /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#&?]*).*/;
+  const match = url.match(regExp);
+  return match && match[7].length === 11 ? match[7] : null;
+}
+
+// Validate video URL for security
+function isValidVideoUrl(url: string): boolean {
+  if (url.startsWith("data:video")) {
+    return true;
+  }
+  const videoExtensions = /\.(mp4|webm|ogg)$/i;
+  const youtubeRegex = /^(https?:\/\/)?(www\.)?(youtube\.com|youtu\.?be)\/.+$/;
+  const validUrl = /^(https?:\/\/)/i;
+  const cleanedUrl = url.split("?")[0];
+  return (
+    (validUrl.test(url) && videoExtensions.test(cleanedUrl)) ||
+    youtubeRegex.test(url)
+  );
+}
+
+// Video player with YouTube embed support
+function VideoPlayer({
+  url,
+  autoPlay = false,
+  className = "",
+}: {
+  url: string;
+  autoPlay?: boolean;
+  className?: string;
+}) {
+  const youtubeId = getYouTubeVideoId(url);
+
+  if (youtubeId) {
+    return (
+      <iframe
+        src={`https://www.youtube.com/embed/${youtubeId}${autoPlay ? "?autoplay=1" : ""}`}
+        title="YouTube video player"
+        className={className}
+        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+        sandbox="allow-same-origin allow-scripts allow-presentation"
+        allowFullScreen
+      />
+    );
+  }
+
+  if (!isValidVideoUrl(url)) {
+    return (
+      <div
+        className={`flex items-center justify-center bg-zinc-800 ${className}`}
+      >
+        <span className="text-sm text-zinc-400">Invalid video URL</span>
+      </div>
+    );
+  }
+
+  return <video src={url} controls autoPlay={autoPlay} className={className} />;
+}
+
+function MediaCarousel({ waitlist }: { waitlist: StoreWaitlistEntry }) {
+  const [activeVideo, setActiveVideo] = useState<string | null>(null);
+
+  // Build media items array: videos first, then images
+  const mediaItems: MediaItem[] = [
+    ...(waitlist.videoUrl
+      ? [{ type: "video" as const, url: waitlist.videoUrl, label: "Video" }]
+      : []),
+    ...(waitlist.agentOutputDemoUrl
+      ? [
+          {
+            type: "video" as const,
+            url: waitlist.agentOutputDemoUrl,
+            label: "Demo",
+          },
+        ]
+      : []),
+    ...waitlist.imageUrls.map((url) => ({ type: "image" as const, url })),
+  ];
+
+  if (mediaItems.length === 0) return null;
+
+  // Single item - no carousel needed
+  if (mediaItems.length === 1) {
+    const item = mediaItems[0];
+    return (
+      <div className="relative aspect-[350/196] w-full overflow-hidden rounded-large">
+        {item.type === "image" ? (
+          <Image
+            src={item.url}
+            alt={`${waitlist.name} preview`}
+            fill
+            className="object-cover"
+          />
+        ) : (
+          <VideoPlayer url={item.url} className="h-full w-full object-cover" />
+        )}
+      </div>
+    );
+  }
+
+  // Multiple items - use carousel
+  return (
+    <Carousel className="w-full">
+      <CarouselContent>
+        {mediaItems.map((item, index) => (
+          <CarouselItem key={index}>
+            <div className="relative aspect-[350/196] w-full overflow-hidden rounded-large">
+              {item.type === "image" ? (
+                <Image
+                  src={item.url}
+                  alt={`${waitlist.name} preview ${index + 1}`}
+                  fill
+                  className="object-cover"
+                />
+              ) : activeVideo === item.url ? (
+                <VideoPlayer
+                  url={item.url}
+                  autoPlay
+                  className="h-full w-full object-cover"
+                />
+              ) : (
+                <button
+                  onClick={() => setActiveVideo(item.url)}
+                  className="group relative h-full w-full bg-zinc-900"
+                >
+                  <div className="absolute inset-0 flex items-center justify-center">
+                    <div className="flex h-16 w-16 items-center justify-center rounded-full bg-white/90 transition-transform group-hover:scale-110">
+                      <Play size={32} weight="fill" className="text-zinc-800" />
+                    </div>
+                  </div>
+                  <span className="absolute bottom-3 left-3 text-sm text-white">
+                    {item.label}
+                  </span>
+                </button>
+              )}
+            </div>
+          </CarouselItem>
+        ))}
+      </CarouselContent>
+      <CarouselPrevious className="left-2 top-1/2 -translate-y-1/2" />
+      <CarouselNext className="right-2 top-1/2 -translate-y-1/2" />
+    </Carousel>
+  );
+}
+
+interface WaitlistDetailModalProps {
+  waitlist: StoreWaitlistEntry;
+  isMember?: boolean;
+  onClose: () => void;
+  onJoinSuccess?: (waitlistId: string) => void;
+}
+
+export function WaitlistDetailModal({
+  waitlist,
+  isMember = false,
+  onClose,
+  onJoinSuccess,
+}: WaitlistDetailModalProps) {
+  const { user } = useSupabaseStore();
+  const [email, setEmail] = useState("");
+  const [success, setSuccess] = useState(false);
+  const { toast } = useToast();
+  const joinWaitlistMutation = usePostV2AddSelfToTheAgentWaitlist();
+
+  function handleJoin() {
+    joinWaitlistMutation.mutate(
+      {
+        waitlistId: waitlist.waitlistId,
+        data: { email: user ? undefined : email },
+      },
+      {
+        onSuccess: (response) => {
+          if (response.status === 200) {
+            setSuccess(true);
+            toast({
+              title: "You're on the waitlist!",
+              description: `We'll notify you when ${waitlist.name} goes live.`,
+            });
+            onJoinSuccess?.(waitlist.waitlistId);
+          } else {
+            toast({
+              variant: "destructive",
+              title: "Error",
+              description: "Failed to join waitlist. Please try again.",
+            });
+          }
+        },
+        onError: () => {
+          toast({
+            variant: "destructive",
+            title: "Error",
+            description: "Failed to join waitlist. Please try again.",
+          });
+        },
+      },
+    );
+  }
+
+  // Success state
+  if (success) {
+    return (
+      <Dialog
+        title=""
+        controlled={{
+          isOpen: true,
+          set: async (open) => {
+            if (!open) onClose();
+          },
+        }}
+        onClose={onClose}
+        styling={{ maxWidth: "500px" }}
+      >
+        <Dialog.Content>
+          <div className="flex flex-col items-center justify-center py-4 text-center">
+            {/* Party emoji */}
+            <span className="mb-2 text-5xl">🎉</span>
+
+            {/* Title */}
+            <h2 className="mb-2 font-poppins text-[22px] font-medium leading-7 text-zinc-900 dark:text-zinc-100">
+              You&apos;re on the waitlist
+            </h2>
+
+            {/* Subtitle */}
+            <p className="text-base leading-[26px] text-zinc-600 dark:text-zinc-400">
+              Thanks for helping us prioritize which agents to build next.
+              We&apos;ll notify you when this agent goes live in the
+              marketplace.
+            </p>
+          </div>
+
+          {/* Close button */}
+          <Dialog.Footer className="flex justify-center pb-2 pt-4">
+            <Button
+              variant="secondary"
+              onClick={onClose}
+              className="rounded-full border border-zinc-700 bg-white px-4 py-3 text-zinc-900 hover:bg-zinc-100 dark:border-zinc-500 dark:bg-zinc-800 dark:text-zinc-100 dark:hover:bg-zinc-700"
+            >
+              Close
+            </Button>
+          </Dialog.Footer>
+        </Dialog.Content>
+      </Dialog>
+    );
+  }
+
+  // Main modal - handles both member and non-member states
+  return (
+    <Dialog
+      title="Join the waitlist"
+      controlled={{
+        isOpen: true,
+        set: async (open) => {
+          if (!open) onClose();
+        },
+      }}
+      onClose={onClose}
+      styling={{ maxWidth: "500px" }}
+    >
+      <Dialog.Content>
+        {/* Subtitle */}
+        <p className="mb-6 text-center text-base text-zinc-600 dark:text-zinc-400">
+          Help us decide what to build next — and get notified when this agent
+          is ready
+        </p>
+
+        {/* Media Carousel */}
+        <MediaCarousel waitlist={waitlist} />
+
+        {/* Agent Name */}
+        <h3 className="mt-4 font-poppins text-[22px] font-medium leading-7 text-zinc-800 dark:text-zinc-100">
+          {waitlist.name}
+        </h3>
+
+        {/* Agent Description */}
+        <p className="mt-2 line-clamp-5 text-sm leading-[22px] text-zinc-500 dark:text-zinc-400">
+          {waitlist.description}
+        </p>
+
+        {/* Email input for non-logged-in users who haven't joined */}
+        {!isMember && !user && (
+          <div className="mt-4 pr-1">
+            <Input
+              id="email"
+              label="Email address"
+              type="email"
+              placeholder="you@example.com"
+              value={email}
+              onChange={(e) => setEmail(e.target.value)}
+              required
+            />
+          </div>
+        )}
+
+        {/* Footer buttons */}
+        <Dialog.Footer className="sticky bottom-0 mt-6 flex justify-center gap-3 bg-white pb-2 pt-4 dark:bg-zinc-900">
+          {isMember ? (
+            <Button
+              disabled
+              className="rounded-full bg-green-600 px-4 py-3 text-white hover:bg-green-600 dark:bg-green-700 dark:hover:bg-green-700"
+            >
+              <Check size={16} className="mr-2" />
+              You&apos;re on the waitlist
+            </Button>
+          ) : (
+            <>
+              <Button
+                onClick={handleJoin}
+                loading={joinWaitlistMutation.isPending}
+                disabled={!user && !email}
+                className="rounded-full bg-zinc-800 px-4 py-3 text-white hover:bg-zinc-700 dark:bg-zinc-700 dark:hover:bg-zinc-600"
+              >
+                Join waitlist
+              </Button>
+              <Button
+                type="button"
+                variant="secondary"
+                onClick={onClose}
+                className="rounded-full bg-zinc-200 px-4 py-3 text-zinc-900 hover:bg-zinc-300 dark:bg-zinc-700 dark:text-zinc-100 dark:hover:bg-zinc-600"
+              >
+                Not now
+              </Button>
+            </>
+          )}
+        </Dialog.Footer>
+      </Dialog.Content>
+    </Dialog>
+  );
+}
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistSection/WaitlistSection.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistSection/WaitlistSection.tsx
@@ -0,0 +1,102 @@
+"use client";
+
+import { useState } from "react";
+import {
+  Carousel,
+  CarouselContent,
+  CarouselItem,
+} from "@/components/__legacy__/ui/carousel";
+import { WaitlistCard } from "../WaitlistCard/WaitlistCard";
+import { WaitlistDetailModal } from "../WaitlistDetailModal/WaitlistDetailModal";
+import type { StoreWaitlistEntry } from "@/app/api/__generated__/models/storeWaitlistEntry";
+import { useWaitlistSection } from "./useWaitlistSection";
+
+export function WaitlistSection() {
+  const { waitlists, joinedWaitlistIds, isLoading, hasError, markAsJoined } =
+    useWaitlistSection();
+  const [selectedWaitlist, setSelectedWaitlist] =
+    useState<StoreWaitlistEntry | null>(null);
+
+  function handleOpenModal(waitlist: StoreWaitlistEntry) {
+    setSelectedWaitlist(waitlist);
+  }
+
+  function handleJoinSuccess(waitlistId: string) {
+    markAsJoined(waitlistId);
+  }
+
+  // Don't render if loading, error, or no waitlists
+  if (isLoading || hasError || !waitlists || waitlists.length === 0) {
+    return null;
+  }
+
+  return (
+    <div className="flex flex-col items-center justify-center">
+      <div className="w-full max-w-[1360px]">
+        {/* Section Header */}
+        <div className="mb-6">
+          <h2 className="font-poppins text-2xl font-semibold text-[#282828] dark:text-neutral-200">
+            Help Shape What&apos;s Next
+          </h2>
+          <p className="mt-2 text-base text-neutral-600 dark:text-neutral-400">
+            These agents are in development. Your interest helps us prioritize
+            what gets built — and we&apos;ll notify you when they&apos;re ready.
+          </p>
+        </div>
+
+        {/* Mobile Carousel View */}
+        <Carousel
+          className="md:hidden"
+          opts={{
+            loop: true,
+          }}
+        >
+          <CarouselContent>
+            {waitlists.map((waitlist) => (
+              <CarouselItem
+                key={waitlist.waitlistId}
+                className="min-w-64 max-w-71"
+              >
+                <WaitlistCard
+                  name={waitlist.name}
+                  subHeading={waitlist.subHeading}
+                  description={waitlist.description}
+                  imageUrl={waitlist.imageUrls[0] || null}
+                  isMember={joinedWaitlistIds.has(waitlist.waitlistId)}
+                  onCardClick={() => handleOpenModal(waitlist)}
+                  onJoinClick={() => handleOpenModal(waitlist)}
+                />
+              </CarouselItem>
+            ))}
+          </CarouselContent>
+        </Carousel>
+
+        {/* Desktop Grid View */}
+        <div className="hidden grid-cols-1 place-items-center gap-6 md:grid md:grid-cols-2 lg:grid-cols-3">
+          {waitlists.map((waitlist) => (
+            <WaitlistCard
+              key={waitlist.waitlistId}
+              name={waitlist.name}
+              subHeading={waitlist.subHeading}
+              description={waitlist.description}
+              imageUrl={waitlist.imageUrls[0] || null}
+              isMember={joinedWaitlistIds.has(waitlist.waitlistId)}
+              onCardClick={() => handleOpenModal(waitlist)}
+              onJoinClick={() => handleOpenModal(waitlist)}
+            />
+          ))}
+        </div>
+      </div>
+
+      {/* Single Modal for both viewing and joining */}
+      {selectedWaitlist && (
+        <WaitlistDetailModal
+          waitlist={selectedWaitlist}
+          isMember={joinedWaitlistIds.has(selectedWaitlist.waitlistId)}
+          onClose={() => setSelectedWaitlist(null)}
+          onJoinSuccess={handleJoinSuccess}
+        />
+      )}
+    </div>
+  );
+}
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistSection/useWaitlistSection.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistSection/useWaitlistSection.ts
@@ -0,0 +1,58 @@
+"use client";
+
+import { useMemo } from "react";
+import { useSupabaseStore } from "@/lib/supabase/hooks/useSupabaseStore";
+import {
+  useGetV2GetTheAgentWaitlist,
+  useGetV2GetWaitlistIdsTheCurrentUserHasJoined,
+  getGetV2GetWaitlistIdsTheCurrentUserHasJoinedQueryKey,
+} from "@/app/api/__generated__/endpoints/store/store";
+import type { StoreWaitlistEntry } from "@/app/api/__generated__/models/storeWaitlistEntry";
+import { useQueryClient } from "@tanstack/react-query";
+
+export function useWaitlistSection() {
+  const { user } = useSupabaseStore();
+  const queryClient = useQueryClient();
+
+  // Fetch waitlists
+  const {
+    data: waitlistsResponse,
+    isLoading: waitlistsLoading,
+    isError: waitlistsError,
+  } = useGetV2GetTheAgentWaitlist();
+
+  // Fetch memberships if logged in
+  const { data: membershipsResponse, isLoading: membershipsLoading } =
+    useGetV2GetWaitlistIdsTheCurrentUserHasJoined({
+      query: {
+        enabled: !!user,
+      },
+    });
+
+  const waitlists: StoreWaitlistEntry[] = useMemo(() => {
+    if (waitlistsResponse?.status === 200) {
+      return waitlistsResponse.data.listings;
+    }
+    return [];
+  }, [waitlistsResponse]);
+
+  const joinedWaitlistIds: Set<string> = useMemo(() => {
+    if (membershipsResponse?.status === 200) {
+      return new Set(membershipsResponse.data);
+    }
+    return new Set();
+  }, [membershipsResponse]);
+
+  const isLoading = waitlistsLoading || (!!user && membershipsLoading);
+  const hasError = waitlistsError;
+
+  // Function to add a waitlist ID to joined set (called after successful join)
+  function markAsJoined(_waitlistId: string) {
+    // Invalidate the memberships query to refetch
+    queryClient.invalidateQueries({
+      queryKey: getGetV2GetWaitlistIdsTheCurrentUserHasJoinedQueryKey(),
+    });
+  }
+
+  return { waitlists, joinedWaitlistIds, isLoading, hasError, markAsJoined };
+}
--- a/autogpt_platform/frontend/src/app/(platform)/monitoring/components/AgentFlowList.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/monitoring/components/AgentFlowList.tsx
@@ -120,9 +120,11 @@ export const AgentFlowList = ({
                  lastRun =
                    runCount == 0
                      ? null
-                      : _flowRuns.reduce((a, c) =>
-                          a.started_at > c.started_at ? a : c,
-                        );
+                      : _flowRuns.reduce((a, c) => {
+                          const aTime = a.started_at?.getTime() ?? 0;
+                          const cTime = c.started_at?.getTime() ?? 0;
+                          return aTime > cTime ? a : c;
+                        });
                }
                return { flow, runCount, lastRun };
              })
@@ -130,10 +132,9 @@ export const AgentFlowList = ({
                if (!a.lastRun && !b.lastRun) return 0;
                if (!a.lastRun) return 1;
                if (!b.lastRun) return -1;
-                return (
-                  b.lastRun.started_at.getTime() -
-                  a.lastRun.started_at.getTime()
-                );
+                const bTime = b.lastRun.started_at?.getTime() ?? 0;
+                const aTime = a.lastRun.started_at?.getTime() ?? 0;
+                return bTime - aTime;
              })
              .map(({ flow, runCount, lastRun }) => (
                <TableRow
--- a/autogpt_platform/frontend/src/app/(platform)/monitoring/components/FlowRunsStatus.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/monitoring/components/FlowRunsStatus.tsx
@@ -29,7 +29,10 @@ export const FlowRunsStatus: React.FC<{
        : statsSince;
  const filteredFlowRuns =
    statsSinceTimestamp != null
-      ? executions.filter((fr) => fr.started_at.getTime() > statsSinceTimestamp)
+      ? executions.filter(
+          (fr) =>
+            fr.started_at && fr.started_at.getTime() > statsSinceTimestamp,
+        )
      : executions;

  return (
--- a/autogpt_platform/frontend/src/app/(platform)/monitoring/components/FlowRunsTimeline.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/monitoring/components/FlowRunsTimeline.tsx
@@ -98,40 +98,43 @@ export const FlowRunsTimeline = ({
        <Scatter
          key={flow.id}
          data={executions
-            .filter((e) => e.graph_id == flow.graph_id)
+            .filter((e) => e.graph_id == flow.graph_id && e.started_at)
            .map((e) => ({
              ...e,
              time:
-                e.started_at.getTime() + (e.stats?.node_exec_time ?? 0) * 1000,
+                (e.started_at?.getTime() ?? 0) +
+                (e.stats?.node_exec_time ?? 0) * 1000,
              _duration: e.stats?.node_exec_time ?? 0,
            }))}
          name={flow.name}
          fill={`hsl(${(hashString(flow.id) * 137.5) % 360}, 70%, 50%)`}
        />
      ))}
-      {executions.map((execution) => (
-        <Line
-          key={execution.id}
-          type="linear"
-          dataKey="_duration"
-          data={[
-            {
-              ...execution,
-              time: execution.started_at.getTime(),
-              _duration: 0,
-            },
-            {
-              ...execution,
-              time: execution.ended_at.getTime(),
-              _duration: execution.stats?.node_exec_time ?? 0,
-            },
-          ]}
-          stroke={`hsl(${(hashString(execution.graph_id) * 137.5) % 360}, 70%, 50%)`}
-          strokeWidth={2}
-          dot={false}
-          legendType="none"
-        />
-      ))}
+      {executions
+        .filter((e) => e.started_at && e.ended_at)
+        .map((execution) => (
+          <Line
+            key={execution.id}
+            type="linear"
+            dataKey="_duration"
+            data={[
+              {
+                ...execution,
+                time: execution.started_at!.getTime(),
+                _duration: 0,
+              },
+              {
+                ...execution,
+                time: execution.ended_at!.getTime(),
+                _duration: execution.stats?.node_exec_time ?? 0,
+              },
+            ]}
+            stroke={`hsl(${(hashString(execution.graph_id) * 137.5) % 360}, 70%, 50%)`}
+            strokeWidth={2}
+            dot={false}
+            legendType="none"
+          />
+        ))}
      <Legend
        content={<ScrollableLegend />}
        wrapperStyle={{
--- a/autogpt_platform/frontend/src/app/(platform)/monitoring/page.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/monitoring/page.tsx
@@ -98,7 +98,11 @@ const Monitor = () => {
          ...(selectedFlow
            ? executions.filter((v) => v.graph_id == selectedFlow.graph_id)
            : executions),
-        ].sort((a, b) => b.started_at.getTime() - a.started_at.getTime())}
+        ].sort((a, b) => {
+          const aTime = a.started_at?.getTime() ?? 0;
+          const bTime = b.started_at?.getTime() ?? 0;
+          return bTime - aTime;
+        })}
        selectedRun={selectedRun}
        onSelectRun={(r) => setSelectedRun(r.id == selectedRun?.id ? null : r)}
      />
--- a/autogpt_platform/frontend/src/app/(platform)/profile/(user)/integrations/page.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/profile/(user)/integrations/page.tsx
@@ -116,6 +116,9 @@ export default function UserIntegrationsPage() {
      "63a6e279-2dc2-448e-bf57-85776f7176dc", // ZeroBounce
      "9aa1bde0-4947-4a70-a20c-84daa3850d52", // Google Maps
      "d44045af-1c33-4833-9e19-752313214de2", // Llama API
+      "c4e6d1a0-3b5f-4789-a8e2-9b123456789f", // V0 by Vercel
+      "a5b3c7d9-2e4f-4a6b-8c1d-9e0f1a2b3c4d", // Webshare Proxy
+      "8b3d4e5f-6a7b-8c9d-0e1f-2a3b4c5d6e7f", // OpenWeatherMap
    ],
    [],
  );
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -5082,6 +5082,301 @@
        }
      }
    },
+    "/api/store/admin/waitlist": {
+      "get": {
+        "tags": ["v2", "admin", "store", "admin", "waitlist"],
+        "summary": "List All Waitlists",
+        "description": "Get all waitlists with admin details (admin only).\n\nReturns:\n    WaitlistAdminListResponse with all waitlists",
+        "operationId": "getV2List all waitlists",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/WaitlistAdminListResponse"
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+          }
+        },
+        "security": [{ "HTTPBearerJWT": [] }]
+      },
+      "post": {
+        "tags": ["v2", "admin", "store", "admin", "waitlist"],
+        "summary": "Create Waitlist",
+        "description": "Create a new waitlist (admin only).\n\nArgs:\n    request: Waitlist creation details\n    user_id: Authenticated admin user creating the waitlist\n\nReturns:\n    WaitlistAdminResponse with the created waitlist details",
+        "operationId": "postV2Create waitlist",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": { "$ref": "#/components/schemas/WaitlistCreateRequest" }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/WaitlistAdminResponse"
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+              }
+            }
+          }
+        },
+        "security": [{ "HTTPBearerJWT": [] }]
+      }
+    },
+    "/api/store/admin/waitlist/{waitlist_id}": {
+      "delete": {
+        "tags": ["v2", "admin", "store", "admin", "waitlist"],
+        "summary": "Delete Waitlist",
+        "description": "Soft delete a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to delete\n\nReturns:\n    Success message",
+        "operationId": "deleteV2Delete waitlist",
+        "security": [{ "HTTPBearerJWT": [] }],
+        "parameters": [
+          {
+            "name": "waitlist_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The ID of the waitlist",
+              "title": "Waitlist Id"
+            },
+            "description": "The ID of the waitlist"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": { "application/json": { "schema": {} } }
+          },
+          "401": {
+            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+              }
+            }
+          }
+        }
+      },
+      "get": {
+        "tags": ["v2", "admin", "store", "admin", "waitlist"],
+        "summary": "Get Waitlist Details",
+        "description": "Get a single waitlist with admin details (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to retrieve\n\nReturns:\n    WaitlistAdminResponse with waitlist details",
+        "operationId": "getV2Get waitlist details",
+        "security": [{ "HTTPBearerJWT": [] }],
+        "parameters": [
+          {
+            "name": "waitlist_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The ID of the waitlist",
+              "title": "Waitlist Id"
+            },
+            "description": "The ID of the waitlist"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/WaitlistAdminResponse"
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+              }
+            }
+          }
+        }
+      },
+      "put": {
+        "tags": ["v2", "admin", "store", "admin", "waitlist"],
+        "summary": "Update Waitlist",
+        "description": "Update a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to update\n    request: Fields to update\n\nReturns:\n    WaitlistAdminResponse with updated waitlist details",
+        "operationId": "putV2Update waitlist",
+        "security": [{ "HTTPBearerJWT": [] }],
+        "parameters": [
+          {
+            "name": "waitlist_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The ID of the waitlist",
+              "title": "Waitlist Id"
+            },
+            "description": "The ID of the waitlist"
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": { "$ref": "#/components/schemas/WaitlistUpdateRequest" }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/WaitlistAdminResponse"
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/store/admin/waitlist/{waitlist_id}/link": {
+      "post": {
+        "tags": ["v2", "admin", "store", "admin", "waitlist"],
+        "summary": "Link Waitlist to Store Listing",
+        "description": "Link a waitlist to a store listing (admin only).\n\nWhen the linked store listing is approved/published, waitlist users\nwill be automatically notified.\n\nArgs:\n    waitlist_id: ID of the waitlist\n    store_listing_id: ID of the store listing to link\n\nReturns:\n    WaitlistAdminResponse with updated waitlist details",
+        "operationId": "postV2Link waitlist to store listing",
+        "security": [{ "HTTPBearerJWT": [] }],
+        "parameters": [
+          {
+            "name": "waitlist_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The ID of the waitlist",
+              "title": "Waitlist Id"
+            },
+            "description": "The ID of the waitlist"
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/Body_postV2Link_waitlist_to_store_listing"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/WaitlistAdminResponse"
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/store/admin/waitlist/{waitlist_id}/signups": {
+      "get": {
+        "tags": ["v2", "admin", "store", "admin", "waitlist"],
+        "summary": "Get Waitlist Signups",
+        "description": "Get all signups for a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist\n\nReturns:\n    WaitlistSignupListResponse with all signups",
+        "operationId": "getV2Get waitlist signups",
+        "security": [{ "HTTPBearerJWT": [] }],
+        "parameters": [
+          {
+            "name": "waitlist_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The ID of the waitlist",
+              "title": "Waitlist Id"
+            },
+            "description": "The ID of the waitlist"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/WaitlistSignupListResponse"
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+              }
+            }
+          }
+        }
+      }
+    },
    "/api/store/agents": {
      "get": {
        "tags": ["v2", "store", "public"],
@@ -5927,6 +6222,101 @@
        }
      }
    },
+    "/api/store/waitlist": {
+      "get": {
+        "tags": ["v2", "store", "public"],
+        "summary": "Get the agent waitlist",
+        "description": "Get all active waitlists for public display.",
+        "operationId": "getV2Get the agent waitlist",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/StoreWaitlistsAllResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/store/waitlist/my-memberships": {
+      "get": {
+        "tags": ["v2", "store", "private"],
+        "summary": "Get waitlist IDs the current user has joined",
+        "description": "Returns list of waitlist IDs the authenticated user has joined.",
+        "operationId": "getV2Get waitlist ids the current user has joined",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "items": { "type": "string" },
+                  "type": "array",
+                  "title": "Response Getv2Get Waitlist Ids The Current User Has Joined"
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+          }
+        },
+        "security": [{ "HTTPBearerJWT": [] }]
+      }
+    },
+    "/api/store/waitlist/{waitlist_id}/join": {
+      "post": {
+        "tags": ["v2", "store", "public"],
+        "summary": "Add self to the agent waitlist",
+        "description": "Add the current user to the agent waitlist.",
+        "operationId": "postV2Add self to the agent waitlist",
+        "security": [{ "HTTPBearer": [] }],
+        "parameters": [
+          {
+            "name": "waitlist_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The ID of the waitlist to join",
+              "title": "Waitlist Id"
+            },
+            "description": "The ID of the waitlist to join"
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/Body_postV2Add_self_to_the_agent_waitlist"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/StoreWaitlistEntry" }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+              }
+            }
+          }
+        }
+      }
+    },
    "/health": {
      "get": {
        "tags": ["health"],
@@ -6674,6 +7064,17 @@
        "required": ["store_listing_version_id"],
        "title": "Body_postV2Add marketplace agent"
      },
+      "Body_postV2Add_self_to_the_agent_waitlist": {
+        "properties": {
+          "email": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Email",
+            "description": "Email address for unauthenticated users"
+          }
+        },
+        "type": "object",
+        "title": "Body_postV2Add self to the agent waitlist"
+      },
      "Body_postV2Execute_a_preset": {
        "properties": {
          "inputs": {
@@ -6692,6 +7093,18 @@
        "type": "object",
        "title": "Body_postV2Execute a preset"
      },
+      "Body_postV2Link_waitlist_to_store_listing": {
+        "properties": {
+          "store_listing_id": {
+            "type": "string",
+            "title": "Store Listing Id",
+            "description": "The ID of the store listing"
+          }
+        },
+        "type": "object",
+        "required": ["store_listing_id"],
+        "title": "Body_postV2Link waitlist to store listing"
+      },
      "Body_postV2Upload_submission_media": {
        "properties": {
          "file": { "type": "string", "format": "binary", "title": "File" }
@@ -7148,6 +7561,20 @@
          "error_message": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Error Message"
+          },
+          "started_at": {
+            "anyOf": [
+              { "type": "string", "format": "date-time" },
+              { "type": "null" }
+            ],
+            "title": "Started At"
+          },
+          "ended_at": {
+            "anyOf": [
+              { "type": "string", "format": "date-time" },
+              { "type": "null" }
+            ],
+            "title": "Ended At"
          }
        },
        "type": "object",
@@ -7254,14 +7681,20 @@
          },
          "status": { "$ref": "#/components/schemas/AgentExecutionStatus" },
          "started_at": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Started At"
+            "anyOf": [
+              { "type": "string", "format": "date-time" },
+              { "type": "null" }
+            ],
+            "title": "Started At",
+            "description": "When execution started running. Null if not yet started (QUEUED)."
          },
          "ended_at": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Ended At"
+            "anyOf": [
+              { "type": "string", "format": "date-time" },
+              { "type": "null" }
+            ],
+            "title": "Ended At",
+            "description": "When execution finished. Null if not yet completed (QUEUED, RUNNING, INCOMPLETE, REVIEW)."
          },
          "is_shared": {
            "type": "boolean",
@@ -7295,8 +7728,6 @@
          "nodes_input_masks",
          "preset_id",
          "status",
-          "started_at",
-          "ended_at",
          "stats",
          "outputs"
        ],
@@ -7395,14 +7826,20 @@
          },
          "status": { "$ref": "#/components/schemas/AgentExecutionStatus" },
          "started_at": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Started At"
+            "anyOf": [
+              { "type": "string", "format": "date-time" },
+              { "type": "null" }
+            ],
+            "title": "Started At",
+            "description": "When execution started running. Null if not yet started (QUEUED)."
          },
          "ended_at": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Ended At"
+            "anyOf": [
+              { "type": "string", "format": "date-time" },
+              { "type": "null" }
+            ],
+            "title": "Ended At",
+            "description": "When execution finished. Null if not yet completed (QUEUED, RUNNING, INCOMPLETE, REVIEW)."
          },
          "is_shared": {
            "type": "boolean",
@@ -7431,8 +7868,6 @@
          "nodes_input_masks",
          "preset_id",
          "status",
-          "started_at",
-          "ended_at",
          "stats"
        ],
        "title": "GraphExecutionMeta"
@@ -7479,14 +7914,20 @@
          },
          "status": { "$ref": "#/components/schemas/AgentExecutionStatus" },
          "started_at": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Started At"
+            "anyOf": [
+              { "type": "string", "format": "date-time" },
+              { "type": "null" }
+            ],
+            "title": "Started At",
+            "description": "When execution started running. Null if not yet started (QUEUED)."
          },
          "ended_at": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Ended At"
+            "anyOf": [
+              { "type": "string", "format": "date-time" },
+              { "type": "null" }
+            ],
+            "title": "Ended At",
+            "description": "When execution finished. Null if not yet completed (QUEUED, RUNNING, INCOMPLETE, REVIEW)."
          },
          "is_shared": {
            "type": "boolean",
@@ -7525,8 +7966,6 @@
          "nodes_input_masks",
          "preset_id",
          "status",
-          "started_at",
-          "ended_at",
          "stats",
          "outputs",
          "node_executions"
@@ -8545,7 +8984,8 @@
          "REFUND_REQUEST",
          "REFUND_PROCESSED",
          "AGENT_APPROVED",
-          "AGENT_REJECTED"
+          "AGENT_REJECTED",
+          "WAITLIST_LAUNCH"
        ],
        "title": "NotificationType"
      },
@@ -10108,6 +10548,57 @@
        "required": ["submissions", "pagination"],
        "title": "StoreSubmissionsResponse"
      },
+      "StoreWaitlistEntry": {
+        "properties": {
+          "waitlistId": { "type": "string", "title": "Waitlistid" },
+          "slug": { "type": "string", "title": "Slug" },
+          "name": { "type": "string", "title": "Name" },
+          "subHeading": { "type": "string", "title": "Subheading" },
+          "videoUrl": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Videourl"
+          },
+          "agentOutputDemoUrl": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Agentoutputdemourl"
+          },
+          "imageUrls": {
+            "items": { "type": "string" },
+            "type": "array",
+            "title": "Imageurls"
+          },
+          "description": { "type": "string", "title": "Description" },
+          "categories": {
+            "items": { "type": "string" },
+            "type": "array",
+            "title": "Categories"
+          }
+        },
+        "type": "object",
+        "required": [
+          "waitlistId",
+          "slug",
+          "name",
+          "subHeading",
+          "imageUrls",
+          "description",
+          "categories"
+        ],
+        "title": "StoreWaitlistEntry",
+        "description": "Public waitlist entry - no PII fields exposed."
+      },
+      "StoreWaitlistsAllResponse": {
+        "properties": {
+          "listings": {
+            "items": { "$ref": "#/components/schemas/StoreWaitlistEntry" },
+            "type": "array",
+            "title": "Listings"
+          }
+        },
+        "type": "object",
+        "required": ["listings"],
+        "title": "StoreWaitlistsAllResponse"
+      },
      "StreamChatRequest": {
        "properties": {
          "message": { "type": "string", "title": "Message" },
@@ -11927,6 +12418,203 @@
        "required": ["loc", "msg", "type"],
        "title": "ValidationError"
      },
+      "WaitlistAdminListResponse": {
+        "properties": {
+          "waitlists": {
+            "items": { "$ref": "#/components/schemas/WaitlistAdminResponse" },
+            "type": "array",
+            "title": "Waitlists"
+          },
+          "totalCount": { "type": "integer", "title": "Totalcount" }
+        },
+        "type": "object",
+        "required": ["waitlists", "totalCount"],
+        "title": "WaitlistAdminListResponse",
+        "description": "Response model for listing all waitlists (admin view)."
+      },
+      "WaitlistAdminResponse": {
+        "properties": {
+          "id": { "type": "string", "title": "Id" },
+          "createdAt": { "type": "string", "title": "Createdat" },
+          "updatedAt": { "type": "string", "title": "Updatedat" },
+          "slug": { "type": "string", "title": "Slug" },
+          "name": { "type": "string", "title": "Name" },
+          "subHeading": { "type": "string", "title": "Subheading" },
+          "description": { "type": "string", "title": "Description" },
+          "categories": {
+            "items": { "type": "string" },
+            "type": "array",
+            "title": "Categories"
+          },
+          "imageUrls": {
+            "items": { "type": "string" },
+            "type": "array",
+            "title": "Imageurls"
+          },
+          "videoUrl": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Videourl"
+          },
+          "agentOutputDemoUrl": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Agentoutputdemourl"
+          },
+          "status": { "$ref": "#/components/schemas/WaitlistExternalStatus" },
+          "votes": { "type": "integer", "title": "Votes" },
+          "signupCount": { "type": "integer", "title": "Signupcount" },
+          "storeListingId": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Storelistingid"
+          },
+          "owningUserId": { "type": "string", "title": "Owninguserid" }
+        },
+        "type": "object",
+        "required": [
+          "id",
+          "createdAt",
+          "updatedAt",
+          "slug",
+          "name",
+          "subHeading",
+          "description",
+          "categories",
+          "imageUrls",
+          "status",
+          "votes",
+          "signupCount",
+          "owningUserId"
+        ],
+        "title": "WaitlistAdminResponse",
+        "description": "Admin response model with full waitlist details including internal data."
+      },
+      "WaitlistCreateRequest": {
+        "properties": {
+          "name": { "type": "string", "title": "Name" },
+          "slug": { "type": "string", "title": "Slug" },
+          "subHeading": { "type": "string", "title": "Subheading" },
+          "description": { "type": "string", "title": "Description" },
+          "categories": {
+            "items": { "type": "string" },
+            "type": "array",
+            "title": "Categories",
+            "default": []
+          },
+          "imageUrls": {
+            "items": { "type": "string" },
+            "type": "array",
+            "title": "Imageurls",
+            "default": []
+          },
+          "videoUrl": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Videourl"
+          },
+          "agentOutputDemoUrl": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Agentoutputdemourl"
+          }
+        },
+        "type": "object",
+        "required": ["name", "slug", "subHeading", "description"],
+        "title": "WaitlistCreateRequest",
+        "description": "Request model for creating a new waitlist."
+      },
+      "WaitlistExternalStatus": {
+        "type": "string",
+        "enum": ["DONE", "NOT_STARTED", "CANCELED", "WORK_IN_PROGRESS"],
+        "title": "WaitlistExternalStatus"
+      },
+      "WaitlistSignup": {
+        "properties": {
+          "type": { "type": "string", "title": "Type" },
+          "userId": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Userid"
+          },
+          "email": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Email"
+          },
+          "username": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Username"
+          }
+        },
+        "type": "object",
+        "required": ["type"],
+        "title": "WaitlistSignup",
+        "description": "Individual signup entry for a waitlist."
+      },
+      "WaitlistSignupListResponse": {
+        "properties": {
+          "waitlistId": { "type": "string", "title": "Waitlistid" },
+          "signups": {
+            "items": { "$ref": "#/components/schemas/WaitlistSignup" },
+            "type": "array",
+            "title": "Signups"
+          },
+          "totalCount": { "type": "integer", "title": "Totalcount" }
+        },
+        "type": "object",
+        "required": ["waitlistId", "signups", "totalCount"],
+        "title": "WaitlistSignupListResponse",
+        "description": "Response model for listing waitlist signups."
+      },
+      "WaitlistUpdateRequest": {
+        "properties": {
+          "name": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Name"
+          },
+          "slug": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Slug"
+          },
+          "subHeading": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Subheading"
+          },
+          "description": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Description"
+          },
+          "categories": {
+            "anyOf": [
+              { "items": { "type": "string" }, "type": "array" },
+              { "type": "null" }
+            ],
+            "title": "Categories"
+          },
+          "imageUrls": {
+            "anyOf": [
+              { "items": { "type": "string" }, "type": "array" },
+              { "type": "null" }
+            ],
+            "title": "Imageurls"
+          },
+          "videoUrl": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Videourl"
+          },
+          "agentOutputDemoUrl": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Agentoutputdemourl"
+          },
+          "status": {
+            "anyOf": [
+              { "$ref": "#/components/schemas/WaitlistExternalStatus" },
+              { "type": "null" }
+            ]
+          },
+          "storeListingId": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Storelistingid"
+          }
+        },
+        "type": "object",
+        "title": "WaitlistUpdateRequest",
+        "description": "Request model for updating a waitlist."
+      },
      "Webhook": {
        "properties": {
          "id": { "type": "string", "title": "Id" },
--- a/autogpt_platform/frontend/src/components/layout/Navbar/components/AgentActivityDropdown/components/ActivityItem.tsx
+++ b/autogpt_platform/frontend/src/components/layout/Navbar/components/AgentActivityDropdown/components/ActivityItem.tsx
@@ -50,7 +50,9 @@ export function ActivityItem({ execution }: Props) {
      execution.status === AgentExecutionStatus.QUEUED;

    if (isActiveStatus) {
-      const timeAgo = formatTimeAgo(execution.started_at.toString());
+      const timeAgo = execution.started_at
+        ? formatTimeAgo(execution.started_at.toString())
+        : "recently";
      const statusText =
        execution.status === AgentExecutionStatus.QUEUED ? "queued" : "running";
      return [
@@ -61,7 +63,9 @@ export function ActivityItem({ execution }: Props) {
    // Handle all other statuses with time display
    const timeAgo = execution.ended_at
      ? formatTimeAgo(execution.ended_at.toString())
-      : formatTimeAgo(execution.started_at.toString());
+      : execution.started_at
+        ? formatTimeAgo(execution.started_at.toString())
+        : "recently";

    let statusText = "ended";
    switch (execution.status) {
--- a/autogpt_platform/frontend/src/lib/autogpt-server-api/types.ts
+++ b/autogpt_platform/frontend/src/lib/autogpt-server-api/types.ts
@@ -327,8 +327,8 @@ export type GraphExecutionMeta = {
    | "FAILED"
    | "INCOMPLETE"
    | "REVIEW";
-  started_at: Date;
-  ended_at: Date;
+  started_at: Date | null;
+  ended_at: Date | null;
  stats: {
    error: string | null;
    cost: number;
--- a/autogpt_platform/frontend/src/tests/agent-activity.spec.ts
+++ b/autogpt_platform/frontend/src/tests/agent-activity.spec.ts
@@ -39,10 +39,9 @@ test.beforeEach(async ({ page }) => {
  await page.waitForTimeout(1000);

  await page.goto("/library");
-  await LibraryPage.clickFirstAgent(page);
+  // Navigate to the specific agent we just created, not just the first one
+  await LibraryPage.navigateToAgentByName(page, "Test Agent");
  await LibraryPage.waitForAgentPageLoad(page);
-  const { getRole } = getSelectors(page);
-  await isVisible(getRole("heading", "Test Agent"), 8000);
 });

 test("shows badge with count when agent is running", async ({ page }) => {
--- a/autogpt_platform/frontend/src/tests/pages/library.page.ts
+++ b/autogpt_platform/frontend/src/tests/pages/library.page.ts
@@ -450,45 +450,72 @@ export async function navigateToAgentByName(
  agentName: string,
 ): Promise<void> {
  const agentCard = getAgentCards(page).filter({ hasText: agentName }).first();
+  // Wait for the agent card to be visible before clicking
+  // This handles async loading of agents after page navigation
+  await agentCard.waitFor({ state: "visible", timeout: 15000 });
  await agentCard.click();
 }

 export async function clickRunButton(page: Page): Promise<void> {
  const { getId } = getSelectors(page);

+  // Wait for page to stabilize and buttons to render
+  // The NewAgentLibraryView shows either "Setup your task" (empty state)
+  // or "New task" (with items) button
  const setupTaskButton = page.getByRole("button", {
    name: /Setup your task/i,
  });
+  const newTaskButton = page.getByRole("button", { name: /New task/i });
+  const runButton = getId("agent-run-button");
+  const runAgainButton = getId("run-again-button");

+  // Use Promise.race with waitFor to wait for any of the buttons to appear
+  // This handles the async rendering in CI environments
+  try {
+    await Promise.race([
+      setupTaskButton.waitFor({ state: "visible", timeout: 15000 }),
+      newTaskButton.waitFor({ state: "visible", timeout: 15000 }),
+      runButton.waitFor({ state: "visible", timeout: 15000 }),
+      runAgainButton.waitFor({ state: "visible", timeout: 15000 }),
+    ]);
+  } catch {
+    throw new Error(
+      "Could not find run/start task button - none of the expected buttons appeared",
+    );
+  }
+
+  // Now check which button is visible and click it
  if (await setupTaskButton.isVisible()) {
    await setupTaskButton.click();
    const startTaskButton = page
      .getByRole("button", { name: /Start Task/i })
      .first();
+    await startTaskButton.waitFor({ state: "visible", timeout: 10000 });
    await startTaskButton.click();
    return;
  }

-  const newTaskButton = page.getByRole("button", { name: /New task/i });
  if (await newTaskButton.isVisible()) {
    await newTaskButton.click();
    const startTaskButton = page
      .getByRole("button", { name: /Start Task/i })
      .first();
+    await startTaskButton.waitFor({ state: "visible", timeout: 10000 });
    await startTaskButton.click();
    return;
  }

-  const runButton = getId("agent-run-button");
-  const runAgainButton = getId("run-again-button");
-
  if (await runButton.isVisible()) {
    await runButton.click();
-  } else if (await runAgainButton.isVisible()) {
-    await runAgainButton.click();
-  } else {
-    throw new Error("Could not find run/start task button");
+    return;
  }
+
+  if (await runAgainButton.isVisible()) {
+    await runAgainButton.click();
+    return;
+  }
+
+  throw new Error("Could not find run/start task button");
 }

 export async function clickNewRunButton(page: Page): Promise<void> {
--- a/backend/blocks/video/init.py
+++ b/backend/blocks/video/init.py
@@ -0,0 +1 @@
+# Video editing blocks