Auto E-Commerce

Inspiration

Microtrends are fleeting — a product can go viral on TikTok on Monday and be oversaturated by Friday. Traditional e-commerce requires days of manual research, supplier vetting, legal checks, and ad creation before a store is even live. We wanted to answer one question: what if the entire pipeline from trend signal to live storefront could run itself, faster than a human could open a spreadsheet? Auto E-Commerce was born from the idea that AI agents, coordinated correctly, can compress a week of founder work into minutes.

What it does

Auto E-Commerce is an autonomous multi-agent system that detects niche microtrends and launches a full e-commerce store end-to-end with no human required. A user enters a product name (or the system detects one automatically via Nimble trend data), clicks Trigger Agent Run, and watches a live pipeline fire across five specialized agents:

Research Agent — scores trend strength, search volume, social mentions, and competitor pricing
Buyer Agent — sources suppliers, estimates unit cost, margin, and shipping window
Legal / Risk Agent — screens for trademark conflicts, import restrictions, and ad platform risk
Advertising Agent — generates a brand name, tagline, ad copy, and hero image prompt
Store Creator — assembles a live storefront at a unique subdomain (product.fastaisolution.com)

Every agent decision is stored in ClickHouse, every run is observable in real time on a Next.js dashboard, and every metric flows to Datadog.

Sponsors used

Datadog
Nimble
ClickHouse

How we built it

We split ownership across four independent workstreams that integrated at the end:

Layer	Stack
Agents	Google ADK + Gemini (`gemini-2.5-flash`)
Orchestration	Temporal workflows + FastAPI
Frontend	Next.js 14, React, Tailwind CSS
Database	ClickHouse Cloud
Trend data	Nimble API
Observability	Datadog traces + metrics
Deployment	Render (API, frontend, worker, cron)

Each agent is a stateless ADK LlmAgent with a Pydantic output schema. Temporal wraps each agent call as a durable activity with retry policies — so a flaky Gemini response or a slow Nimble lookup doesn't fail the whole run. The frontend polls /api/runs/{run_id}/events every second to drive the live agent timeline. ClickHouse stores every run, event, agent decision, and trend signal, doubling as the system's long-term memory for future bias and scoring improvements.

Challenges we ran into

Multi-agent coordination without tight coupling. Four engineers owned four independent slices. Getting Research → Buyer → Legal → Advertising to pass structured, validated data without any agent knowing about the others required a strict shared contract (integration-guide.md) and Pydantic schemas at every boundary.

Temporal + async agents. ADK agents are async; Temporal activities need to be safe to retry and deterministic. Threading those two execution models together — especially ensuring agent state didn't leak across retries — required careful design.

Fixture-first development. We built the entire system to run without any real API keys (USE_AGENT_FIXTURES=true), which meant every component needed a credible mock. Writing fixtures that felt real enough to validate the full UI and pipeline logic took more iteration than expected.

ClickHouse as memory, not just storage. Moving from ClickHouse-as-a-log to ClickHouse-as-agent-memory — where historical launch outcomes feed back into agent prompts as grounding context — required schema decisions upfront that couldn't easily be changed later.

Accomplishments that we're proud of

A fully working end-to-end demo: one product name in → live store URL out, with every agent step visible in real time on the dashboard
All four agent modules independently triggerable without any API keys (USE_AGENT_FIXTURES=true uv run python -m backend.agents.runner research --product "...")
30 passing tests across all agents, output schemas, and the runner dispatcher
A clean A2A message protocol where no agent knows about any other — they only speak to the orchestrator via typed AgentMessage envelopes
Historical microtrend insights injected into agent prompts automatically, so the Legal agent knows that fitness products have a 41% health-claims flag rate before it even reads the product name
Zero hardcoded secrets in the codebase — full fixture/mock mode for safe local development and demo deployment

What we learned

Temporal is genuinely the right tool for multi-step AI pipelines. The retry semantics and durable execution handle LLM flakiness in a way that try/except blocks simply can't.
Structured output schemas are non-negotiable. Every agent using output_schema with Pydantic meant zero JSON parsing bugs across the entire pipeline — the model is forced to be correct.
Fixtures are a feature, not a shortcut. Building fixture mode first let all four engineers develop and test in parallel for days before a single real API key was needed. The demo is more reliable because of it.
ClickHouse shines when you treat it as a feedback loop. Storing every agent decision and outcome and querying it back into the next run's prompt context is a simple pattern with a large impact on output quality.

What's next for Auto E-Commerce

Live Nimble integration — move from manual triggers to automatic launches when Nimble detects a trend crossing a score threshold, with no human in the loop
Multimodal product images — pass scraped product images into Gemini Vision to extract features and generate richer, more specific ad copy
Autonomous reinvestment loop — once a store generates revenue, the system evaluates margin data in ClickHouse and decides whether to scale ad spend, pause, or pivot to the next trend
Supplier negotiation agent — a new ADK agent that contacts multiple suppliers, compares quotes, and selects the best terms automatically
Cross-store learning — use the ClickHouse knowledge graph (business_relationships) to identify which product categories, price points, and ad patterns consistently outperform, and bias future agent runs toward them
Full Temporal Cloud deployment — move from the local dev server to Temporal Cloud for production-grade durability and the Temporal UI for workflow observability in the live demo

We split ownership across four independent workstreams that integrated at the end.

Languages & Core Stack:

Languages: Python, TypeScript, JavaScript, SQL
Backend: FastAPI, Pydantic, Uvicorn
Frontend: Next.js, React, Tailwind CSS
Runtime Platforms: Python 3.12, Node.js
Package Tools: uv, pnpm, Corepack

Agents & AI:

Agents: Google ADK + Gemini (gemini-2.5-flash)
AI APIs: Google Gemini API, Google GenAI configuration
External Data: Nimble API for trend research

Orchestration & Data:

Workflow Orchestration: Temporal Python SDK, with local sync fallback
Database: ClickHouse Cloud with in-memory fallback for local/demo mode
Observability: Datadog traces and metrics

Security & Auth:

Authentication: Custom email/password auth, JWT-style bearer tokens, password hashing
Security/Config: Environment variables, .env.example, .gitignore, secret-safe Render config

Testing & Dev Tools:

Testing: Pytest, Vitest, React Testing Library
Dev Tools: Justfile, GitHub, Git, .env configuration
Build Systems: Next.js production build, uv Python dependency sync

Deployment:

Platform: Render (API service, frontend service, background worker, cron job)

Each agent is a stateless ADK LlmAgent with a Pydantic output schema. Temporal wraps each agent call as a durable activity with retry policies — so a flaky Gemini response or a slow Nimble lookup doesn't fail the whole run. The frontend polls /api/runs/{run_id}/events every second to drive the live agent timeline. ClickHouse stores every run, event, agent decision, and trend signal, doubling as the system's long-term memory for future bias and scoring improvements.