landing page
persona selection

🧠 Årchetype — Testing Product Ideas at the Speed of Thought

🚀 Inspiration

Every product team faces the same paradox — before launching a new feature, you want to validate it with users, but you can’t test something that doesn’t exist yet.
We were inspired by how synthetic data is revolutionizing simulation in science and AI, and we asked ourselves:

Why can’t product teams simulate real users too?

From that question, Årchetype was born — a platform where AI-driven personas explore your prototype, mimic human behaviors, and surface adoption insights before you build.

🧩 What It Does

Årchetype lets early-stage founders and product managers run hundreds of realistic user tests — without real users.

You define your feature hypothesis and prototype links.
Årchetype generates synthetic personas from statistical distributions and behavioral dimensions.
Each persona runs through a goal-oriented, autonomous interaction loop using browser automation (e.g., Playwright + LLM reasoning).
The system analyzes adoption, friction points, and behavioral variance, then outputs a synthetic report showing what works — and what doesn’t.

Think of it as “Synthetic UX Testing” — where your product meets its users before launch.

🧠 How We Built It

We built Årchetype as a modular AI system with three main layers:

Frontend (React + Tailwind + Auth0-ready):
A dashboard for PMs to define tests, view persona analytics, and monitor live synthetic sessions.
Backend (Flask + MongoDB):
Handles routing, session orchestration, persona generation, and test storage.
Simulation Core:
- Planning: Each persona uses a large language model (via LLMClient) to plan interactions given a feature goal.
- Action Execution: Browser automation via Playwright mimics clicks, scrolls, and inputs.
- Observation & Replanning: The agent re-evaluates mid-test using updated DOM observations — just like a real user noticing new elements.
- Analysis: Aggregates persona outcomes and generates visualizations (radar charts, word clouds, behavioral summaries).

Mathematically, each persona’s decision policy can be modeled as:

$$ a_t = \pi_\theta(s_t) + \epsilon_t, $$

where (a_t) is the next browser action, (s_t) is the observed DOM state, and (\pi_\theta) is a language-conditioned policy learned through few-shot reasoning.

⚙️ Technical Stack

Layer	Tech
Frontend	React, TailwindCSS, Recharts, Auth0
Backend	Flask, Python 3.10, MongoDB, Playwright
AI Layer	OpenAI + OpenRouter LLM APIs, JSON schema validation
Infra	Docker, Vercel (frontend), Render/AWS (backend)

💡 What We Learned

Building synthetic agents that “feel” human requires balancing structure and autonomy — too heuristic, and it’s fake; too free, and it’s chaotic.
Browser-based interaction is surprisingly expressive — combining DOM state and LLM reasoning produced emergent behaviors like re-planning and adaptive navigation.
Product insight ≠ AI insight. The most valuable part wasn’t the model’s intelligence, but the data pipeline and visualization that PMs can actually use.

🧱 Challenges We Faced

Designing credible personas required deep statistical sampling — we built a full persona distribution engine from scratch.
Integrating real-time LLM reasoning with browser automation caused significant latency and required careful threading and timeout handling.
Ensuring data persistence and recovery (via checkpointing) between pages to mimic human “memory” was harder than expected.
Managing auth and CORS across Flask, MongoDB, and Vercel under one domain setup took a surprising amount of debugging time.

🌱 What’s Next

Pilot programs with early-stage founders and design teams.
Adding synthetic crowd variance (multiple personas debating a feature).
Integration with Linear, Notion, and Figma for direct feedback loops.
Researching multi-agent persona testing and vision-based contextual perception (CUA-like frameworks).