Mobile Apps That Move as Fast as Brands
Online stores change constantly. New arrivals drop, best sellers shift, flash sales go live. For most Shopify merchants, the gap between what’s happening in their store and what customers actually see in their app is costly. An outdated homepage buries your top performers. A stale banner misses the moment. A promotion that wasn’t swapped out on time undermines trust.
App shoppers convert at 2-4x the rate of web shoppers, so stale content on a mobile app hits harder than it does anywhere else.
Yet keeping an app fresh involves constant manual work: creating new assets, rearranging sections, managing layouts. These updates fall on whoever has time that week, which means they often don’t happen. Or they happen too late. Or they happen inconsistently across the busiest seasons, when it matters most.
Our brands told us the same thing, regardless of their size or category: “I know my app should be fresher, but I don’t have the bandwidth to update it every week.”
The cost isn’t just time. It’s relevance, and relevance drives revenue.
So we updated our Reactiv AI Agent to schedule changes in advance.
What Is the AI Scheduler?
The AI Scheduler lets merchants automate mobile app updates using natural language. Instead of manually configuring screens and sections, a merchant can say:
"Refresh my homepage with best sellers every Monday at 9am."
“Build a landing page optimized for AOV and run it weekly.”
“Swap my hero banner to feature new arrivals every Friday.”
Behind the scenes, the system does what a human would do. Faster, data-driven, and on schedule:
- Analyzes the merchant's store data and performance metrics
- Builds an updated app configuration based on what the data says
- Stores the result for merchant review before it goes live
- Learns from past interactions to get better over time
The merchant stays in control — every generated update is reviewable and approvable before it reaches their customers. But analyzing data, choosing what to feature, and building configurations? That runs autonomously.
Why We Chose AWS Bedrock AgentCore
When we set out to build the AI Scheduler, we had a clear set of requirements: multi-tenant isolation, managed infrastructure, persistent memory, and native integration with the foundation models we were already using on Bedrock. AgentCore covered all four.
Managed Agent Runtime
AgentCore runs our agents in Firecracker microVMs — the same isolation technology behind AWS Lambda. We don’t manage containers, orchestrators, or scaling policies. We package our agent code as a Docker image, deploy it to AgentCore, and it handles the rest. Agents spin up when a scheduled task triggers and shut down when they’re done. No idle compute costs.
Built-In Memory
The capability we lean on most is persistent memory. Our agents use three long-term memory strategies:
- Session summaries: what happened in each scheduled run
- Merchant preferences: learned patterns about how each merchant likes their app configured
- Semantic facts: extracted knowledge about the merchant's store and products
This means the AI Scheduler gets smarter over time. If a merchant consistently approves layouts that feature collection-based grids over product carousels, the agent learns that preference and applies it to future runs — without the merchant having to say it again.
Secure Multi-Tenancy
AgentCore provides secure multi-tenant isolation out of the box. Every merchant’s data — execution context, memory, and agent state — is fully isolated. Merchant A’s preferences never leak into Merchant B’s sessions. We didn’t have to build tenant routing or isolation middleware ourselves; AgentCore handles it at the infrastructure level.
Native Bedrock Integration
We use Claude as our foundation model through Bedrock. AgentCore’s native integration gives us guardrails, model management, and inference without building custom adapters. No middleware, no glue code.
Architecture at a Glance
The AI Scheduler is built as a multi-agent system using the Strands Agents framework, orchestrated as a directed graph on AgentCore.
It starts with the merchant. From the Reactiv dashboard, merchants create a scheduled task in two ways — through our CopilotKit-powered chatbot (“Refresh my homepage with best sellers every Monday at 9am”) or through a manual form UI where they pick a prompt, frequency, and time. Either way, the result is the same: a schedule record that fires at the specified time.
When a schedule triggers, the system pulls the merchant’s latest Reactiv mobile app configuration from the database and invokes the AgentCore runtime with the full context the agents need to do their work.
Inside AgentCore, a Strands multi-agent graph takes over:
- The Supervisor classifies the merchant's intent and routes to the right pipeline — analytics only, builder only, or analytics-then-builder
- The Analytics Agent queries merchant performance data to surface trends, top products, and actionable insights
- The Builder Agent takes those insights and translates them into concrete app configuration updates — adding sections, swapping products, generating images, and assembling layouts
The generated configuration is stored for the merchant to review and approve before it goes live.
The Config MCP: Teaching the Builder How to Build
A key piece of the architecture is our Reactiv Config MCP server, also hosted on AgentCore. The Config MCP exposes the full schema and validation rules for Reactiv mobile app configurations — screen types, section layouts, block structures, and the constraints that govern how they fit together. The Builder Agent connects to the Config MCP to understand what’s possible, validate its changes against the schema, and submit well-formed configuration updates.
Critically, the Config MCP is stateful — it initializes the merchant’s current app configuration at the start of each session, and the Builder Agent performs mutations on that live state throughout the run. This means the Builder Agent doesn’t just generate arbitrary JSON — it builds configurations that are structurally valid against our app’s rules. The Config MCP acts as the source of truth for what a valid Reactiv app looks like, and the Builder Agent uses it as both a reference and a guardrail.
Custom SDKs for Agent-Friendly Tool Calling
The Builder Agent also has access to custom SDKs we built specifically to be agent-friendly — a Shopify Storefront SDK for querying products, collections, and catalog data, and an Image Generation SDK powered by Nano-banana 2. We built these SDKs specifically for tool calling: clean input/output contracts, structured responses, and predictable error handling that LLMs can reason about reliably.
What’s Next
The Live AI Builder Is Already in Merchants’ Hands
Before the scheduler, we shipped a conversational AI builder powered by CopilotKit. Merchants can chat with an AI assistant directly in their dashboard to build and customize their mobile app in real time — describing what they want, seeing changes instantly, and iterating through conversation. It’s the interactive counterpart to the scheduler’s autonomous mode.
Unifying Interactive and Scheduled AI with AG-UI
Today, the live builder and the scheduler are separate systems. They don’t share memory. That’s changing.
Amazon Bedrock AgentCore now natively supports the AG-UI protocol — an open standard for connecting AI agent backends to frontend frameworks. We’re migrating our CopilotKit integration to AG-UI on AgentCore, which means our interactive builder will run on the same Strands agents and AgentCore Runtime as the scheduler — just with a different transport layer. This unlocks two things:
Shared memory across both modes. When a merchant chats with the live builder and expresses preferences — “I prefer grid layouts over carousels,” “always feature my seasonal collection first” — those preferences carry over to their scheduled tasks. When the scheduler learns what performs well for a merchant, that knowledge is available in the next interactive session. AgentCore Memory makes this possible by scoping all long-term memory to the same merchant identity, regardless of whether the session was interactive or scheduled.
Shared tools with dashboard-specific extensions. The interactive and scheduled agents will share the same core tool set — analytics, storefront queries, image generation, and Config MCP. But in the dashboard, we can layer on additional capabilities directly through CopilotKit: setting up schedules, sending push notifications, navigating the UI, and other dashboard-specific interactions that only make sense in a real-time context. The scheduled agent stays focused on autonomous building, while the interactive agent gets the full merchant experience.
Looking Ahead: Strands + CopilotKit + AgentCore
Strands Agents handles orchestration. CopilotKit handles the frontend. AgentCore handles infrastructure. Together, they give us a platform where AI runs through every part of the merchant experience. What’s next: generative UI, analytics-triggered automation, and agents that know each merchant’s store well enough to act without being asked.
We’re grateful to the AWS team for their partnership on AgentCore. We came in needing multi-tenant isolation, persistent memory, and managed infrastructure. AgentCore delivered all three, and we shipped faster because of it.
Reactiv is a mobile commerce platform for Shopify. We help merchants launch, manage, and optimize native mobile apps powered by AI. Learn more at reactiv.ai.
