ShelfReady

ShelfReady turns product evidence into publishable content and keeps every claim true as your product changes.

Comment

Inspiration

Product information rarely stays still. A supplier updates a specification, a certification expires, or a claim loses its supporting evidence, but product pages, marketplaces, distributor sheets, and internal records may continue repeating yesterday’s facts.

For small commerce teams, finding these changes is tedious. Deciding what is safe to publish is harder. Most AI tools can draft copy, but they do not continuously watch evidence, preserve provenance, enforce publishing rules, or know when a human decision is required.

We built ShelfReady around a simple idea:

Product content should stay aligned with evidence, even when nobody has the dashboard open.

What it does

ShelfReady is a background product-evidence agent built with the Strands Agents SDK.

It continuously watches an evidence pool for supplier-document updates. When a new object arrives, ShelfReady:

  1. Inspects the file and identifies whether it is relevant product evidence.
  2. Rejects unrelated notes, invoices, drafts, and invalid files.
  3. Uses ProDocuX to ingest and compare deterministic document evidence.
  4. Uses PDX Artifact Engine to create traceable execution plans, approval checkpoints, and publication receipts.
  5. Separates safe changes from claims that must remain blocked or require human review.
  6. Brings the merchant into a mobile-first decision inbox only when judgment is necessary.
  7. Publishes an approved, allowlisted update to a Shopify development store used only for the demo.
  8. Reads the result back and records what changed, why it changed, and who approved it.

The merchant does not need to keep the PWA open. Monitoring and processing continue on the server in the background.

The demo can exercise different evidence changes rather than one fixed scenario. Examples include a revised package size, removed support for a sensitive-skin statement, a new formulation or ingredient list, an expired certification, conflicting supplier documents, an unsupported marketing claim, or a file that does not belong to any product. ShelfReady handles each fact independently: safe changes can move forward, ambiguous claims can wait for a merchant, prohibited claims remain blocked, and irrelevant files are rejected without creating unnecessary work.

Shopify is a demo destination, not a requirement for the underlying evidence workflow. We chose a Shopify development store because it is a recognizable commerce system with real products, fields, APIs, and observable storefront results. It lets us demonstrate that ShelfReady does more than summarize a document or generate copy: after evidence checks and human approval, the agent can safely complete a real write-back, read the result from the destination, and produce an auditable receipt. The same architecture can support other commerce channels through additional adapters.

How we built it

ShelfReady combines agentic interpretation with deterministic publishing controls.

The background workflow uses:

  • Strands Agents SDK for agent orchestration and tool use.
  • Amazon Bedrock with Nova Micro for semantic inspection of incoming evidence.
  • Amazon S3 as the watched evidence pool.
  • Amazon SQS to wake the background worker when evidence arrives.
  • ProDocuX for deterministic document intake, normalized evidence, structured comparison, and verification.
  • PDX Artifact Engine for execution plans, checkpoints, approvals, artifact identity, and publication receipts.
  • FastAPI and Uvicorn for the durable application host.
  • SQLite for decisions, activity, receipts, and restart-safe demo state.
  • Shopify Admin API connected to a development store for controlled demo updates and read-back verification.
  • A mobile-first PWA for merchant review.
  • A separate evidence inbox that represents an external supplier feed.

The public demo runs as a persistent systemd service on an AWS virtual machine. The merchant PWA and evidence inbox are separate surfaces, while one durable host coordinates the background workflow. Shopify serves as the demo’s visible publication endpoint; it is deliberately kept behind the approval and policy boundary rather than treated as the source of truth.

We deliberately kept the model outside the final authority boundary. Strands can inspect evidence and propose actions, but deterministic policies decide what is allowlisted, what is blocked, and what requires approval.

Challenges we ran into

The hardest challenge was defining the boundary between useful autonomy and unsafe automation.

A product update may contain several independent facts. One field can be safe to publish while another needs review and a third must remain blocked. Treating the whole document as simply “approved” or “rejected” was not sufficient.

We also had to solve practical long-running workflow problems:

  • Preserving decisions when the browser closes or the service restarts.
  • Preventing duplicate processing of the same evidence.
  • Rejecting irrelevant files without creating unnecessary approval tasks.
  • Detecting stale Shopify snapshots before writing.
  • Making publication idempotent.
  • Rolling back when read-back verification fails.
  • Resetting Shopify, application state, S3 objects, and SQS wakeups as one coherent demo operation.
  • Preventing mobile browser and service-worker caches from showing stale decision states.
  • Keeping credentials, internal planning documents, and operational data out of the public repository.

The biggest design lesson was that “background agent” is not a user-interface feature. The watch loop must live independently of the PWA, and the PWA should interrupt the user only when there is a meaningful decision.

Accomplishments that we're proud of

We are proud that ShelfReady performs an end-to-end job instead of stopping at a chatbot response.

It can:

  • Watch a real S3 evidence pool in the background.
  • Wake through SQS and run a Strands agent.
  • Distinguish relevant evidence from unrelated or invalid documents.
  • Process evidence through real, pinned public ProDocuX and PDX Artifact Engine releases.
  • Preserve deterministic evidence and approval boundaries.
  • Keep unsupported claims blocked even when other fields are safe.
  • Resume a pending decision from another browser session.
  • Publish approved changes to a real Shopify development store used as the demo channel.
  • Verify the resulting store state and produce an auditable receipt.
  • Restore the entire demo to a clean starting point.
  • Present the human decision clearly on a phone-sized interface.

We are especially proud that closing the app does not stop the work. ShelfReady continues monitoring quietly and asks for attention only when human judgment adds value.

What we learned

We learned that trustworthy agents need more than good prompts.

A useful production pattern is:

Agents interpret, deterministic systems verify, policies constrain, and humans authorize consequential ambiguity.

We also learned that provenance must be carried through the entire workflow. It is not enough to know that a field changed; the system should retain which evidence caused the change, which policy allowed or blocked it, whether a person approved it, and what was ultimately observed in the destination channel.

Mobile-first design also changed how we thought about the product. Merchants do not need another complex compliance dashboard. They need a small, understandable decision inbox with enough evidence to act confidently.

Finally, background execution requires explicit operational design: durable state, idempotency, retry behavior, reset semantics, queue cleanup, external read-back, and clear failure states are as important as the agent itself.

What's next for ShelfReady

Next, we want to expand ShelfReady from a focused demonstration into a reusable product-content operations system.

Planned directions include:

  • Deploying the agent runtime with Amazon Bedrock AgentCore.
  • Replacing SQLite with PostgreSQL for multi-tenant durability.
  • Supporting authenticated Shopify installation across multiple stores.
  • Monitoring supplier portals, cloud drives, regulatory sources, and certification registries.
  • Adding scheduled re-verification when evidence expires.
  • Generating channel-specific product copy only from verified facts.
  • Supporting additional commerce channels and distributor documents.
  • Sending mobile notifications only when a decision is genuinely required.
  • Adding role-based approval, policy versioning, and richer audit exports.
  • Showing exactly which sentences and fields would change before publication.
  • Learning organization-specific approval policies without allowing the model to bypass hard safety rules.

Our long-term goal is for ShelfReady to become the quiet background operator that keeps product content accurate, explainable, and ready to publish as the underlying evidence changes.

Built With

Share this project:

Updates

Submission history