Reactiv 如何用 Amazon Bedrock AgentCore 将移动电商自动化提速 80%

Reactiv offers a mobile commerce product that helps Shopify merchants launch and manage native mobile apps, where shoppers convert at 2–4 times the rate of web visitors. For these merchants, a stale homepage or a missed promotional window costs real revenue. Yet keeping an app fresh requires constant manual work: choosing which products to feature, rearranging sections, generating new assets, and publishing updates on time. Most merchants don’t have the bandwidth to do this every week. Reactiv used Amazon Bedrock AgentCore to automate these updates, reducing merchant configuration time by 80 percent and getting to production 33 percent faster.

Reactiv set out to solve this with an AI Scheduler that updates merchant apps autonomously on a schedule. A merchant describes what they want in natural language, such as “Refresh my homepage with best sellers every Monday at 9 AM,” and the system handles the rest. They built it as a three-agent system on Amazon Bedrock AgentCore with the Strands Agents SDK and had it in production within weeks. They then unified their interactive and scheduled agents onto a single stack, achieving shared memory across both modes.

In this post, we walk through the architecture behind those results, why Reactiv chose Amazon Bedrock AgentCore, and how their product has evolved since launch.

Reactiv builds native iOS and Android apps for Shopify merchants. Their tools include a low-code app builder, analytics dashboards, and AI-powered features. Before the AI Scheduler, Reactiv had already built a conversational AI builder. Merchants could chat with an AI assistant in the Reactiv dashboard to modify their app in real time.

That system worked for interactive use, but Reactiv’s merchants asked for something different: autonomous updates that happen on a schedule without any manual intervention. Building this required capabilities that the existing architecture didn’t support:

Reactiv needed a solution that could host multi-agent graphs, persist memory across sessions, connect to MCP servers natively, and isolate each merchant’s data automatically.

Amazon Bedrock AgentCore is a platform to build, connect, and optimize agents at scale with any framework or model. Reactiv used three of its capabilities to address all four requirements. AgentCore runtime, a capability of Amazon Bedrock AgentCore, handles managed agent execution. AgentCore memory, a capability of Amazon Bedrock AgentCore, provides persistent cross-session context. AgentCore Identity, a capability of Amazon Bedrock AgentCore, handles service-to-service authentication.

Managed agent runtime . AgentCore runs agents in Firecracker microVMs, the same isolation technology behind AWS Lambda. Reactiv packages their Strands agent graph as a Docker image, pushes it to Amazon Elastic Container Registry (Amazon ECR), and deploys it to AgentCore. Agents spin up when a schedule triggers and shut down when done. No Amazon ECS clusters, scaling policies, or idle compute.

“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.” — Adam Gibicar, Senior AI Developer, Reactiv

Built-in memory . AgentCore provides long-term memory that persists across agent sessions. Reactiv uses three strategies. A session summarizer condenses each job’s actions into context for future runs. A preference learner tracks which layouts a merchant approves or rejects over time. A semantic fact extractor stores knowledge about the merchant’s store, such as product categories, top sellers, and brand guidelines. Memory is scoped per merchant, keeping each merchant’s data private. No custom vector database or retrieval pipeline required.

Native MCP hosting . Reactiv hosted their Config MCP on Amazon Bedrock AgentCore runtime. The MCP runs as a stateful server that initializes the merchant’s current app configuration at session start. The Builder Agent performs mutations against this live state, validated against the schema on every call. With AgentCore Identity, Reactiv handles service-to-service authentication natively, removing the custom authentication layer and JSON-RPC handshake code they had previously built and maintained.

Multi-tenant isolation . Each merchant’s execution context, memory, and agent state runs in its own Firecracker microVM. Merchant A’s preferences remain isolated from Merchant B’s sessions. AgentCore handles tenant routing and isolation at the infrastructure level.

The following diagram shows the end-to-end flow of the AI Scheduler.

Figure 1: End-to-end flow of the Reactiv AI Scheduler. Amazon EventBridge triggers a Lambda executor that invokes the AgentCore runtime, where three Strands agents coordinate across MCP tools, Lambda functions, AgentCore memory, and Amazon Bedrock to produce app configurations stored in Amazon DynamoDB for merchant approval

The following table summarizes the services in the solution:

The system starts with the merchant. From the Reactiv dashboard, merchants create a scheduled task through either a chatbot interface (“Refresh my homepage with best sellers every Monday at 9 AM”) or a form where they pick a prompt, frequency, and time. Both produce a schedule record backed by an Amazon EventBridge cron rule.

When the schedule triggers, the flow proceeds through five components:

Throughout execution, AgentCore memory reads and writes the merchant’s long-term memory in an isolated namespace. Every scheduled job builds on preferences and facts the agent accumulated in prior sessions for that specific merchant. The three agents access foundation models through Amazon Bedrock, which provides serverless inference and built-in guardrails without requiring Reactiv to manage model hosting or GPU infrastructure.

After launching the scheduler, Reactiv had two separate agent systems: the interactive dashboard agent (built with a custom UI adapter for Amazon Bedrock) and the scheduled agent (built on Strands with AgentCore). They did not share memory, tools, or infrastructure.

Reactiv unified them by migrating the interactive agent to the AG-UI protocol on Amazon Bedrock AgentCore. The dashboard agent now shares the same Strands framework, AgentCore-hosted MCP servers, and AgentCore memory instance as the scheduler. The result is one shared framework, runtime, memory layer, and UI protocol across both agents. The practical effect is bidirectional memory sharing. Preferences and facts learned during an interactive dashboard session feed directly into the next scheduled run, and vice versa. Scheduled jobs get smarter the more a merchant uses the front-end agent.

After moving to Amazon Bedrock AgentCore, Reactiv realized gains across development speed, runtime performance, and merchant experience. According to Reactiv’s internal measurements:

With the interactive and scheduled agents unified on a single stack, Reactiv is extending the authoring surface available to merchants. The through-line: merchants can customize their mobile apps through natural language, in progressively deeper ways.

The first step is making Reactiv’s existing design properties (colors, typography, spacing, component variants) available to the agent as a new MCP server hosted on Amazon Bedrock AgentCore. This mirrors the Config MCP approach: a shareable tool surface that the scheduler, the interactive builder, and eventually external integrations can all consume. Merchants can say “make my app match my brand” and the agent will apply changes within a governed design vocabulary rather than generating unconstrained output.

That design system also unlocks a rebuilt onboarding experience. When a new merchant provides their brand name and website, the agent analyzes their existing web presence and produces a strong starting point for the mobile app. Because the design system is in place, the agent can target real design properties and components rather than generating layouts from nothing.

Further out, Reactiv plans to let merchants request entirely new layout sections through natural language. The agent would generate a validated JSON representation of the requested layout, which the mobile app renders on the fly using Reactiv’s design system components. This extends the agent’s authoring capability beyond pre-built section types into merchant-defined layouts that still follow brand guidelines.

Reactiv started with a single agent on self-managed infrastructure and grew into a unified multi-agent system on Amazon Bedrock AgentCore. Today their production system runs three specialized agents, over 50 tools, and persistent memory shared across interactive and autonomous modes. Multiple MCP servers run on one managed runtime. They delivered it faster, with less infrastructure code, and with capabilities that would have required months of custom engineering otherwise.

The MCP-based architecture has proven especially reusable. Reactiv’s Config MCP pattern now extends to a design system MCP and, eventually, to external developer tooling. Each new capability starts with defining tools, hosting them on AgentCore, and sharing them across agents.

Adam is a Senior AI Developer at Reactiv, where he specializes in architecting AI-powered mobile commerce infrastructure and multi-agent systems. His recent work focuses on developing Model Context Protocol (MCP) servers and agentic workflows using AgentCore to power real-time agent orchestration across complex microservice environments.

Ryan is a Solutions Architect at AWS based in Toronto, Canada. He works with startups on AI and machine learning workloads, helping customers design and build production agentic AI systems on AWS.