How Reactiv automates mobile commerce 80% faster with Amazon Bedrock AgentCore

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.

The challenge: Content that doesn’t update itself

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:

• Multi-agent orchestration. The scheduled task needed a supervisor to classify intent, an analytics agent to query merchant data, and a builder agent to generate configurations. Reactiv needed a managed runtime purpose-built for directed graphs of specialized agents, which led them to Amazon Bedrock AgentCore.
• Persistent memory. Every session started from scratch. The agent had no way to remember what a merchant preferred across runs or learn from past approvals.
• Native Model Context Protocol (MCP) support. Reactiv’s configuration schema server (the Config MCP) ran on Amazon Elastic Container Service (Amazon ECS) with a custom Amazon Cognito authentication layer and manual JSON-RPC handshakes on every invocation.
• Tool definition overhead. Each tool required an OpenAPI specification, AWS Lambda wiring, and action-group mapping. Approximately 100 spec files were maintained across two locations.

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.

Why Amazon Bedrock AgentCore

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.

Architecture overview

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:

1. Amazon EventBridge triggers a Job Executor (AWS Lambda) that validates the merchant’s account, acquires a concurrency lock, and pulls the merchant’s current app configuration from the database.
2. The Lambda function invokes the AgentCore runtime with the full context the agents need: the merchant’s prompt, current app configuration, and session metadata.
3. Inside the runtime, a Strands multi-agent graph executes:
   • The Supervisor Agent classifies the merchant’s intent and routes to the correct pipeline (analytics only, builder only, or analytics-then-builder).
   • The Analytics Agent queries merchant performance data through text-to-SQL against Amazon Redshift, surfacing trends, top products, and actionable insights.
   • The Builder Agent takes those insights and produces updated app configurations. To do so, it calls over 50 tools. These include configuration mutations through the Config MCP, data queries through Lambda functions, product lookups from the Shopify Storefront SDK, and asset creation with an image generation SDK.
4. The Config MCP (hosted on AgentCore) validates every mutation the Builder Agent makes against Reactiv’s app schema. The Builder Agent cannot produce an invalid configuration because the MCP acts as both reference and guardrail.
5. The generated configuration is stored in Amazon DynamoDB for merchant review. Nothing goes live without explicit merchant approval.

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.

Unifying interactive and scheduled agents

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.

Results

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

• 80 percent reduction in merchant configuration time. Onboarding tasks that took 17 hours of manual work now complete in 3 hours, and post-launch changes happen in minutes instead of days.
• Simplified tooling and lower costs. The Strands SDK @tool decorator replaced approximately 100 OpenAPI spec files, AgentCore runtime and AgentCore Identity removed custom infrastructure, and the migration saves nearly $6,000 per year in compute costs alone.
• Persistent memory with zero custom infrastructure. Three long-term memory strategies per merchant, fully managed by AgentCore memory, with no vector database or retrieval pipeline to build or maintain.
• 33 percent faster time to production. A three-person team shipped the three-agent system in 10 weeks versus 15 weeks for the prior single-agent build. With AgentCore and Strands, the team focused engineering time on agent logic instead of infrastructure plumbing.
• 2x faster job execution. Scheduled jobs dropped from over 10 minutes to approximately 5 minutes using native streaming in AgentCore runtime, which replaced a four-step polling chain with a single real-time invocation.

What’s next

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.

Conclusion

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.

If you’re building agentic AI systems that need multi-tenant isolation, long-term memory, or managed MCP hosting, with Amazon Bedrock AgentCore, you can access these through AgentCore runtime, AgentCore memory, and AgentCore Identity. To get started, refer to the AgentCore documentation and the Strands Agents SDK.

About the authors