fix(schedules): load upcoming runs with schedule lists

Avoid per-schedule detail requests so authenticated clients receive consistent live fields for upcoming and skip actions.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: jromualdez-scale

agentex-ui/components/scheduled-tasks/scheduled-tasks-page.tsx

@@ -27,7 +27,6 @@ import {
 import { useAgentByName } from '@/hooks/use-agent-by-name';
 import {
   SCHEDULE_LIST_LIMIT,
-  useAgentRunScheduleDetailsForItems,
   useAgentRunSchedules,
   useAgentRunSchedulesForAgents,
 } from '@/hooks/use-agent-run-schedules';
@@ -90,30 +89,27 @@ export function ScheduledTasksPage() {
 
   const baseItems =
     scheduleScope === ScheduleScope.ALL ? allItems : currentItems;
-  const detailQueries = useAgentRunScheduleDetailsForItems(
-    agentexClient,
-    baseItems
-  );
-  const schedulesWithLiveFields = useMemo(
+  const unavailableLiveDataCount = useMemo(
     () =>
-      baseItems.map((item, index) => ({
-        ...item,
-        schedule: detailQueries[index]?.data ?? item.schedule,
-      })),
-    [baseItems, detailQueries]
+      baseItems.filter(
+        item =>
+          !isSchedulePaused(item.schedule) &&
+          getNextRunTime(item.schedule) == null
+      ).length,
+    [baseItems]
   );
 
   const visibleItems = useMemo(() => {
     const scopedItems =
       scheduleView === 'upcoming'
-        ? schedulesWithLiveFields.filter(
+        ? baseItems.filter(
             item =>
               !isSchedulePaused(item.schedule) &&
               getNextRunTime(item.schedule) != null
           )
-        : schedulesWithLiveFields;
+        : baseItems;
     return sortScheduleItems(scopedItems, scheduleView);
-  }, [scheduleView, schedulesWithLiveFields]);
+  }, [baseItems, scheduleView]);
 
   const isLoading =
     scheduleScope === ScheduleScope.ALL
@@ -181,6 +177,17 @@ export function ScheduledTasksPage() {
               Currently showing up to {SCHEDULE_LIST_LIMIT} schedules per agent.
               Support for additional schedules is coming soon.
             </p>
+            {scheduleView === 'upcoming' && unavailableLiveDataCount > 0 && (
+              <p
+                className="border-border bg-muted/40 text-muted-foreground mx-auto w-full max-w-4xl rounded-lg border px-4 py-3 text-xs"
+                role="status"
+              >
+                Next-run data is temporarily unavailable for{' '}
+                {unavailableLiveDataCount}{' '}
+                {unavailableLiveDataCount === 1 ? 'schedule' : 'schedules'}.
+                Their definitions remain available under Schedules.
+              </p>
+            )}
             <ScheduleList
               agentexClient={agentexClient}
               items={visibleItems}

agentex-ui/hooks/use-agent-run-schedules.test.tsx

@@ -1,10 +1,14 @@
 import type { ReactNode } from 'react';
 
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { act, renderHook } from '@testing-library/react';
+import { act, renderHook, waitFor } from '@testing-library/react';
 import { describe, expect, it, vi } from 'vitest';
 
-import { scheduleKeys, useScheduleAction } from './use-agent-run-schedules';
+import {
+  scheduleKeys,
+  useAgentRunSchedules,
+  useScheduleAction,
+} from './use-agent-run-schedules';
 
 import type AgentexSDK from 'agentex';
 
@@ -16,6 +20,45 @@ function createWrapper(queryClient: QueryClient) {
   };
 }
 
+describe('useAgentRunSchedules', () => {
+  it('requests live fields with the bounded schedule list', async () => {
+    const listSchedules = vi.fn().mockResolvedValue({
+      run_schedules: [
+        {
+          id: 'schedule-1',
+          agent_id: 'agent-1',
+          name: 'daily-summary',
+          initial_input: { content: 'Summarize updates' },
+          initial_input_method: 'event/send',
+          next_action_times: ['2026-07-21T13:00:00Z'],
+        },
+      ],
+      total: 1,
+    });
+    const agentexClient = {
+      agents: { schedules: { list: listSchedules } },
+    } as unknown as AgentexSDK;
+    const queryClient = new QueryClient({
+      defaultOptions: { queries: { retry: false } },
+    });
+
+    const { result } = renderHook(
+      () => useAgentRunSchedules(agentexClient, 'agent-1'),
+      { wrapper: createWrapper(queryClient) }
+    );
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(listSchedules).toHaveBeenCalledWith('agent-1', {
+      limit: 50,
+      include_live: true,
+    });
+    expect(result.current.data?.[0]?.next_action_times).toEqual([
+      '2026-07-21T13:00:00Z',
+    ]);
+  });
+});
+
 describe('useScheduleAction', () => {
   it('removes a deleted schedule detail query instead of refetching it', async () => {
     const deleteSchedule = vi

agentex-ui/hooks/use-agent-run-schedules.ts

@@ -27,6 +27,10 @@ export const scheduleKeys = {
 };
 
 export const SCHEDULE_LIST_LIMIT = 50;
+const SCHEDULE_LIST_QUERY = {
+  limit: SCHEDULE_LIST_LIMIT,
+  include_live: true,
+};
 
 type ScheduleMutationContext = {
   agentexClient: AgentexSDK;
@@ -40,11 +44,6 @@ type ScheduleActionInput =
       scheduledTime: string;
     };
 
-export type AgentRunScheduleListItem = {
-  agentId: string;
-  schedule: AgentRunSchedule;
-};
-
 function errorMessage(error: unknown) {
   return error instanceof Error ? error.message : 'Please try again.';
 }
@@ -59,9 +58,10 @@ export function useAgentRunSchedules(
       if (!agentId) {
         return [];
       }
-      const response = await agentexClient.agents.schedules.list(agentId, {
-        limit: SCHEDULE_LIST_LIMIT,
-      });
+      const response = await agentexClient.agents.schedules.list(
+        agentId,
+        SCHEDULE_LIST_QUERY
+      );
       return response.run_schedules.map(normalizeAgentRunSchedule);
     },
     enabled: !!agentId,
@@ -77,34 +77,17 @@ export function useAgentRunSchedulesForAgents(
     queries: agents.map(agent => ({
       queryKey: scheduleKeys.byAgentId(agent.id),
       queryFn: async () => {
-        const response = await agentexClient.agents.schedules.list(agent.id, {
-          limit: SCHEDULE_LIST_LIMIT,
-        });
+        const response = await agentexClient.agents.schedules.list(
+          agent.id,
+          SCHEDULE_LIST_QUERY
+        );
         return response.run_schedules.map(normalizeAgentRunSchedule);
       },
       enabled,
     })),
   });
 }
 
-export function useAgentRunScheduleDetailsForItems(
-  agentexClient: AgentexSDK,
-  items: AgentRunScheduleListItem[]
-) {
-  return useQueries({
-    queries: items.map(({ agentId, schedule }) => ({
-      queryKey: scheduleKeys.detail(agentId, schedule.id),
-      queryFn: async () =>
-        normalizeAgentRunSchedule(
-          await agentexClient.agents.schedules.retrieve(schedule.id, {
-            agent_id: agentId,
-          })
-        ),
-      staleTime: 30_000,
-    })),
-  });
-}
-
 export function useCreateAgentRunSchedule({
   agentexClient,
   agentId,

agentex/openapi.yaml

@@ -3344,6 +3344,15 @@ paths:
           minimum: 1
           default: 100
           title: Limit
+      - name: include_live
+        in: query
+        required: false
+        schema:
+          type: boolean
+          description: Include live Temporal state and upcoming action times.
+          default: false
+          title: Include Live
+        description: Include live Temporal state and upcoming action times.
       responses:
         '200':
           description: Successful Response

agentex/src/api/routes/agent_run_schedules.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Annotated, Any
 
 from fastapi import APIRouter, Query, Request
 
@@ -106,7 +106,11 @@ async def list_run_schedules(
     agent_id: str,
     run_schedules_use_case: DAgentRunSchedulesUseCase,
     authorized_schedule_ids: DAuthorizedResourceIds(AgentexResourceType.schedule),
-    limit: int = Query(default=100, ge=1, le=1000),
+    limit: Annotated[int, Query(ge=1, le=1000)] = 100,
+    include_live: Annotated[
+        bool,
+        Query(description="Include live Temporal state and upcoming action times."),
+    ] = False,
 ) -> AgentRunScheduleListResponse:
     """List an agent's run schedules, filtered to those the caller owns.
 
@@ -117,6 +121,7 @@ async def list_run_schedules(
         agent_id,
         authorized_schedule_ids=authorized_schedule_ids,
         limit=limit,
+        include_live=include_live,
     )
 
 

agentex/src/domain/services/agent_run_schedule_service.py

@@ -1,3 +1,4 @@
+import asyncio
 from datetime import UTC, datetime
 from typing import Annotated, Any, cast
 from uuid import uuid4
@@ -38,6 +39,7 @@
 # these schedules within the shared Temporal namespace and keeps the id stable
 # and small (the row id is the only thing the workflow needs).
 RUN_SCHEDULE_TEMPORAL_ID_PREFIX = "agent-run-schedule"
+MAX_LIVE_ENRICHMENT_CONCURRENCY = 10
 
 # Registered (class) name of the workflow each fire starts. Referenced by name so
 # the API/service layer doesn't import the Temporal workflow definition.
@@ -160,6 +162,7 @@ async def list_schedules(
         agent_id: str,
         authorized_schedule_ids: list[str] | None = None,
         limit: int = 100,
+        include_live: bool = False,
     ) -> AgentRunScheduleListResponse:
         # Fetch without a DB limit so the authorization filter below runs against
         # the full set, then truncate to ``limit`` after filtering. Applying the
@@ -178,23 +181,39 @@ async def list_schedules(
             else None
         )
         agent = await self.agent_repository.get(id=agent_id)
-        items: list[AgentRunScheduleResponse] = []
+        visible_rows: list[AgentRunScheduleEntity] = []
         for row in rows:
-            if len(items) >= limit:
+            if len(visible_rows) >= limit:
                 break
             selector = build_run_schedule_authz_selector(agent_id, row.id)
             if authorized is not None and selector not in authorized:
                 continue
-            temporal_id = build_run_schedule_temporal_id(row.id)
-            # Serve the list from Postgres only — no per-row Temporal describe.
-            # Fanning out one RPC per row (up to the route's limit of 1000) makes
-            # list latency scale with Temporal round-trips; live fields are
-            # available on the single-schedule GET instead.
-            items.append(
+            visible_rows.append(row)
+
+        if not include_live:
+            items = [
                 await self._to_response(
-                    row, agent=agent, temporal_id=temporal_id, include_live=False
+                    row,
+                    agent=agent,
+                    temporal_id=build_run_schedule_temporal_id(row.id),
+                    include_live=False,
                 )
-            )
+                for row in visible_rows
+            ]
+            return AgentRunScheduleListResponse(run_schedules=items, total=len(items))
+
+        semaphore = asyncio.Semaphore(MAX_LIVE_ENRICHMENT_CONCURRENCY)
+
+        async def enrich(row: AgentRunScheduleEntity) -> AgentRunScheduleResponse:
+            async with semaphore:
+                return await self._to_response(
+                    row,
+                    agent=agent,
+                    temporal_id=build_run_schedule_temporal_id(row.id),
+                    include_live=True,
+                )
+
+        items = await asyncio.gather(*(enrich(row) for row in visible_rows))
         return AgentRunScheduleListResponse(run_schedules=items, total=len(items))
 
     async def get_schedule(

agentex/src/domain/use_cases/agent_run_schedules_use_case.py

@@ -42,11 +42,13 @@ async def list_schedules(
         agent_id: str,
         authorized_schedule_ids: list[str] | None = None,
         limit: int = 100,
+        include_live: bool = False,
     ) -> AgentRunScheduleListResponse:
         return await self.run_schedule_service.list_schedules(
             agent_id,
             authorized_schedule_ids=authorized_schedule_ids,
             limit=limit,
+            include_live=include_live,
         )
 
     async def get_schedule(

agentex/tests/unit/api/test_agent_run_schedules_authz.py

@@ -408,12 +408,14 @@ async def test_list_route_forwards_authorized_ids_and_limit(self):
             run_schedules_use_case=use_case,
             authorized_schedule_ids=[_authz_selector("agent-1", "schedule-1")],
             limit=5,
+            include_live=True,
         )
 
         use_case.list_schedules.assert_awaited_once_with(
             "agent-1",
             authorized_schedule_ids=[_authz_selector("agent-1", "schedule-1")],
             limit=5,
+            include_live=True,
         )
 
     async def test_authorized_resource_ids_dependency_lists_schedule_reads(self):