Mapstone

User putting a prompt
Clarification Phase
Plan Result

Inspiration

Every great breakthrough starts as a messy, unstructured thought. College students, early professionals, and aspiring founders are highly ambitious, but they frequently encounter a critical barrier: the transition from a vague concept to a concrete first step. Modern tools offer a polarizing choice: they either oversimplify the problem into generic, static pros and cons lists, or they overwhelm the user with an absolute flood of unsorted information. There is a profound gap for an intelligent system that helps people reason through complexity rather than just generating text or retrieving documents.

We built Mapstone to serve as a dynamic "Second Brain" for execution. We were inspired by the challenge of transforming a high entropy, ambiguous human idea into an ordered, de-risked, and personalized multi-phase execution roadmap. A traditional rules engine is a deterministic mapping

$$f: X \rightarrow Y$$

over a fixed, closed set of pre-defined parameters $X$. That breaks down immediately for an unstructured project idea, where the initial uncertainty $H(I_0)$ is large and different for every single user. There is no fixed set of if-then rules that generalizes across a campus food rescue project, an AI tutoring startup, and a freelance portfolio. Mapstone instead leverages a multi-stage Large Language Model reasoning pipeline to perform a state transformation, systematically reducing ambiguity and increasing the likelihood that the user actually acts on the result. We model that likelihood as a function of calibrated clarity and quantified risk:

$$P(\text{Action}) = \frac{1}{1 + e^{-(\alpha \cdot \text{Clarity} - \beta \cdot \text{Risk})}}$$

Each agent in our pipeline exists to push Clarity up and Risk down before the user ever sees a plan, which is the actual design principle behind every architectural decision we made.

What it does

Mapstone transforms a highly ambiguous project concept into a personalized, de-risked 30-60-90 day execution roadmap.

Dynamic Elicitation. Instead of a long, static form, Mapstone analyzes the raw project concept in real time and surfaces three to four targeted questions specifically contextualized for that exact idea, narrowing down variables like budget, timeline, or expertise.

Intelligent Domain Classification. It automatically categorizes the project as a personal hobby, a university project, or a serious business project, and shifts its internal evaluation criteria depending on the track.

Risk and Assumption Identification. The system explicitly maps out hidden operational bottlenecks, structural assumptions, and potential failure points, each paired with a precise mitigation strategy. If each identified risk $r_i$ carries a severity weight $w_i \in {1, 2, 3}$ for low, medium, and high, the aggregate risk score the planning agent reasons over is

$$R = \sum_{i=1}^{n} w_i$$

Execution Pathways and Tradeoffs. It presents three distinct execution strategies, conservative, balanced, and aggressive, and isolates a single critical first step designed to trigger immediate action within 48 hours, bypassing analysis paralysis.

How we built it

Mapstone is built with a fully decoupled architectural pipeline, an asynchronous Python backend paired with an animated, responsive frontend client.

The Intelligence Core. Built using FastAPI to handle high performance asynchronous REST routing across two core endpoints, /api/clarify and /api/plan.

Multi-Agent Cascade Orchestration. Designed with an intentional orchestrator pattern in Python. State sequentially cascades through a fixed sequence of structural agents, Clarification, Discovery, Risk and Assumption Analyst, and Planning.

State Management and Type Safety. All inter-agent communication and output data models are validated against strict Pydantic models, IdeaState, forcing reliable and predictable serialization at every step.

LLM Engine. Powered by the Groq Cloud API running llama-3.3-70b-versatile, using structural prompt controls to ensure the model responds with clean, unencapsulated structured data.

The Frontend Client. Built with clean web primitives, HTML5, vanilla JavaScript ES6+, and CSS3. The interface transitions across three modular phases, idea input, clarification, and plan, using a unified warm, neutral design layout.

Challenges we ran into

JSON Conformity and Code Block Escaping. Generative models frequently wrap their output in conversational text or markdown code fences, which breaks strict JSON parsers. We built a text processing utility, clean_json_string, that scans raw model output, extracts the substring between the outermost curly braces, and pairs that with an automated retry that re-prompts the model using its own parsing error when the first attempt fails.

Downstream Parameter Alignment. Making sure a user's answers from the clarification step explicitly and reliably altered every downstream agent's output was harder than expected. We solved this with a centralized context injector function, _context_block, that formats the user's answers into a consistent block of text and threads it into the prompt of every downstream agent, keeping every stage aligned with the user's actual constraints.

Accomplishments that we're proud of

True structural reasoning over generation. We avoided building a standard text wrapper around a single prompt. Mapstone is a genuine logic pipeline, forcing an abstract human idea through an intentional sequence of clarification, risk modeling, and scheduling, where each stage measurably changes what the next stage produces.

Production response times. Leveraging Groq's high throughput inference alongside a lean backend payload let us cascade four sequential agent calls per request while keeping the client side loading states responsive enough for a live demo.

What we learned

Structured determinism in open LLMs. We learned how to write prompts that force a creative, open ended model into a strict structural contract, matching exact type and length requirements without stripping away its actual reasoning quality.

Responsible AI and human-in-the-loop safeguards. We realized that handing a user a fully automated roadmap risks over-reliance on the system's output. We addressed this with input filtering on the frontend, a visible confidence indicator, and explicit disclaimers in the interface stating that Mapstone is an assumption-testing engine, not a source of definitive answers, and that the user remains responsible for validating every assumption before committing time or money.

What's next for Mapstone

Real-time vector externalization. Integrating a retrieval-augmented storage layer to pull in real local market indicators, current developer API schemas, or relevant regulatory context based on the domain the Discovery Agent identifies.

Active progress hooking. Expanding the frontend so users can convert the generated 30-60-90 day plan directly into an interactive, persistable progress board that tracks execution over time.