Atlas PM Agent is a single-tenant web app that turns raw product-discovery material into a backlog you could hand to engineers. It runs an opinionated, seven-stage PM pipeline — documents → synthesis → personas → PRD → epics → stories → tasks — where every stage is independently editable and a page-scoped chat assistant can propose structured edits the user has to explicitly Apply. Built solo end-to-end across product, design, and engineering, the goal was to enforce the shape of LLM outputs so a PM ends an hour with something shippable, not a wall of prose.
View Live ProjectA PM's most repetitive workload — summarizing calls, drafting PRD sections, slicing an epic into stories — is exactly what LLMs already do well. But raw model output is shapeless, untrustworthy on real PRDs, and dangerous to wire directly into your source of truth. The product had to make AI useful inside a PM's workflow without making it the PM.
PMs already use LLMs ad-hoc in ChatGPT — the work loses structure the moment it leaves the chat
Generic chatbots produce prose; teams ship from artifacts (PRDs, epics, stories with acceptance criteria)
Letting an agent write directly to a PRD is a non-starter for trust — a single bad edit kills adoption
Single-PM workflows don't justify multi-tenant complexity, but most AI PM tools force it anyway
Framed the product as a pipeline of artifacts (not a chatbot) so each output is structured, persistent, and editable
Identified that trust requires reversibility — every AI write needs a human Apply step and, where possible, version history
Realized the PM's value is in the propose step, not the typing step — so the agent proposes, the human approves
Output has no shape, nothing is queryable, and there's no clean handoff to engineers. PMs end up copy-pasting into a real tool anyway.
Forces structure on AI output, keeps the human in the write path, makes every artifact independently regenerable, and produces something a team can actually execute against.
Would have tripled scope before validating the core loop. Built single-tenant first; auth and per-user encryption are now staged as the next phase.
Chose JSON-in-TEXT columns over a normalized relational model — fast to iterate on schema, harder to query later
Versioning lives only on PRDs (the highest-stakes artifact) — backlog edits via chat are not reversible from the UI yet
Defaulted to a free OpenRouter model for cost — accepted that prompt content is logged by the provider, and committed to fixing the landing copy and adding a local-model path before claiming privacy
Designed and shipped seven artifact stages (synthesis, personas, PRD, epics, stories, tasks, competitor research), each with its own one-shot generator and stream
Built a single AI client wrapper over OpenRouter with model + key resolved from a settings table, so switching models is a one-row change with no redeploy
Implemented a 'full backlog' orchestrator that fans out epics → stories → tasks in one streamed pass, bounded (max 8/8/6) to keep prompts sane and with per-row try/catch so one bad story doesn't blow up the run
Designed the propose-then-apply pattern: the page-scoped chat can only emit proposal cards via tool calls; the user clicks Apply, and the apply route is the single write path — PRD applies snapshot prior content into a versions table first
Authored an audit of the privacy posture (egress to OpenRouter, plaintext docs at rest, no auth) and a staged plan: fix landing copy → add auth → envelope-encrypt documents → optional local-model provider
Would have written the privacy posture honestly in the landing copy from day one instead of fixing it after the fact — marketing claims are part of the product
JSON-in-TEXT was right for speed but I'd plan the migration path earlier; renaming columns on libSQL HTTP without proper migrations is painful
Would extend the version-snapshot pattern to backlog edits sooner — undo is the trust feature that lets users actually use the agent
Would default to a paid no-logging model (or local) before shipping anything resembling a privacy claim