Project Info

PromptToPath

Inspiration

Learning something new in 2026 means drowning in content. Ask a chatbot for "how to become an ML engineer" and you get generic advice and, worse, made-up or dead links. There's no trustworthy, structured, visual path and no real sense that anything more sophisticated than autocomplete is happening behind the scenes. I wanted to prove two things: (1) you can turn any learning intent into a realistic, resourced plan, and (2) a team of collaborating agents can do it far better than a single model and do it where users already are: inside an ASI:One conversation, with no app to install.

What it does

Tell PromptToPath what you want to learn "become an ML engineer in 6 months," "learn to cook Italian food," "I want to learn how to dance" and it returns, right inside an ASI:One chat: a visual Mermaid diagram of your learning path a phased, time-boxed roadmap with realistic milestones verified, clickable resources for each topic (YouTube videos, docs, courses) every link HTTP-validated, so nothing is dead or hallucinated How I built it A multi-agent system on Fetch.ai (uAgents), discoverable and usable through ASI:One: Orchestrator - the only public-facing agent. Implements the Agent Chat Protocol (so ASI:One can talk to it) and a sandboxed Payment Protocol. Coordinates the pipeline and delivers the final answer. Planner - runs a two-pass propose-critique-and-finalize debate to design a realistic roadmap, returned as structured JSON. Resource - fetches real links from live web search (Tavily) and HTTP-validates every URL concurrently within a strict time budget. Graph - renders the enriched roadmap as a Mermaid diagram plus a clean markdown outline. Challenges I ran into Mailbox auth was flaky for agent-to-agent messaging. Routing every internal hop through Agentverse mailboxes caused intermittent "Could not validate credentials" failures. I re-architected so only the orchestrator uses a mailbox (for ASI:One); the worker agents communicate over fast local HTTP endpoints. That single change made the pipeline reliable. ASI:One has a response window. A roadmap that arrived too late was silently dropped. I had to make the pipeline fast and stream heartbeats to hold the session open. What I learned The practical realities of building on Agentverse + ASI:One: when to use mailboxes vs. local transport, and how a chat front-end's timing constraints shape backend design. Reliability is a feature. Heartbeats, timeouts, and fallbacks were the difference between "demo that breaks" and "demo that works every time." ##

What's next

Real payments - flip the Payment Protocol out of sandbox into live Stripe checkout for premium deep-dive roadmaps. Personalization - adapt to the learner's current skill level, weekly time budget, and preferred formats; track progress across sessions. Richer resources & interactivity - more sources, and the ability to refine any phase ("go deeper on transformers," "make it 3 months instead")

PromptToPath 🚀

A better way of learning in the age of AI.

PromptToPath is a multi-agent system on Fetch.ai that turns any learning intent — "become an ML engineer in 6 months", "learn to cook Italian food in 4 weeks", "understand transformers" — into a personalized, time-boxed roadmap with a visual diagram and real, validated learning resources (YouTube videos, docs, courses). The entire experience happens inside an ASI:One conversation — no custom frontend required.

It's not another chatbot. Specialized agents debate, research, and draw:

a Planner that runs an internal Proposer → Critic → Synthesizer debate (cross-model: ASI:One + Claude) so the roadmap is realistic, not generic;
a Resource agent that fetches real links from the YouTube Data API and web search, then HTTP-validates every URL so nothing is hallucinated or dead;
a Graph agent that renders the roadmap as a Mermaid diagram + outline in chat;
an Orchestrator that coordinates them, recovers from failures, and (optionally) gates a "premium" roadmap behind a sandboxed Payment Protocol.

Problem · target user · outcome

Problem: Learners are drowning in content. Generic AI answers give vague advice and often invent links. There's no trustworthy, structured, visual path with verified resources.
Target user: Anyone learning anything self-directed — career switchers, students, hobbyists.
Outcome: One ASI:One message in → a phased, realistic roadmap + a visual map + a set of verified resources per topic, out.

Architecture

The Orchestrator is the only agent ASI:One talks to. A SharedAgentState object flows through a forward pipeline and returns to the Orchestrator for delivery (minimizes mailbox hops):

ASI:One user
    │  ChatMessage (Agent Chat Protocol)
    ▼
Orchestrator ──SharedAgentState──▶ Planner ──▶ Resource ──▶ Graph ──┐
    ▲                                                                │
    └──────────────── SharedAgentState (complete) ◀──────────────────┘
    │  ChatMessage: Mermaid diagram + outline + validated links
    ▼
ASI:One user

Agent	Role	Key tech
Orchestrator	Chat Protocol surface; pipeline coordination; timeout fallback; sandboxed Payment Protocol	`chat_protocol_spec`, `payment_protocol_spec`
Planner	Internal multi-persona debate → structured roadmap	ASI:One + Claude (cross-model critic)
Resource	Real links + HTTP validation (drops dead/hallucinated URLs)	YouTube Data API, Tavily
Graph	Roadmap → Mermaid flowchart + markdown outline	pure Python

Reliability by design: every cross-agent hop has a fallback. If a sub-agent fails or the pipeline times out, the Orchestrator generates a roadmap directly via ASI:One — the conversation never hard-fails. (See agents/services/fallback_service.py.)

Project layout

agents/
  config.py                       # .env loading (accepts ASI_ONE_API_KEY or ASI:ONE_API_KEY)
  chat_common.py                  # Agent Chat Protocol helpers
  models/models.py                # SharedAgentState + Roadmap/Phase/Topic/Resource
  services/
    asi_client.py                 # ASI:One (+ optional Claude) LLM calls
    planner_service.py            # Proposer -> Critic -> Synthesizer debate
    resource_service.py           # YouTube + Tavily + link validation
    graph_service.py              # Mermaid + outline rendering
    fallback_service.py           # single-call resilient roadmap
    state_service.py              # in-memory session state
  orchestrator/                   # orchestrator_agent.py, chat_protocol.py, payment_protocol.py, sessions.py
  planner/planner_agent.py
  resource/resource_agent.py
  graph/graph_agent.py
scripts/
  print_addresses.py              # derive agent addresses from seeds
  test_pipeline.py                # local brain test (no mailbox)

Setup

Requires Python 3.11+.

python -m venv .venv
# Windows:  .venv\Scripts\activate     | macOS/Linux:  source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env        # then fill in the values

Environment (`.env`)

Variable	Required	Where to get it
`ASI_ONE_API_KEY`	✅	https://asi1.ai
`ANTHROPIC_API_KEY`	optional	https://console.anthropic.com (cross-model debate critic)
`YOUTUBE_API_KEY`	for real video links	Google Cloud → enable YouTube Data API v3 → API key (free)
`TAVILY_API_KEY`	for docs/courses	https://tavily.com (free tier)
`*_SEED`	✅	any unique random strings (no spaces)
`*_ADDRESS`	✅	run `python -m scripts.print_addresses` and paste in
`PAYMENT_SANDBOX`	default `true`	keep `true` — no real charges, no card capture

Without the resource keys the system still works — it just attaches fewer links (graceful degradation).

Run

Compute agent addresses and paste them into .env:
```
python -m scripts.print_addresses
```

Quick brain test (no mailbox needed):

python -m scripts.test_pipeline "Give me a roadmap to become an ML engineer in 6 months"

Start all four agents, each in its own terminal:

make orchestrator      # or: python -m agents.orchestrator.orchestrator_agent
make planner           #     python -m agents.planner.planner_agent
make resource          #     python -m agents.resource.resource_agent
make graph             #     python -m agents.graph.graph_agent

On Windows without make, use the python -m ... commands directly.

Connect each agent's mailbox: open the Agent Inspector URL each agent prints on startup (or find it on agentverse.ai), and click Connect → Mailbox.
Use it in ASI:One: open asi1.ai, find the Orchestrator agent, and send:

Give me a roadmap to become an ML engineer in 6 months.

Testing / demo checklist

scripts/test_pipeline.py prints a Mermaid diagram + outline.
All four agents register on Agentverse (mailbox connected).
A roadmap request in ASI:One returns diagram + outline + validated links.
Resilience: kill the Resource agent mid-run → still get a roadmap (fewer links), never an error.
Non-technical prompt ("learn to cook Italian food in 4 weeks") also works.

Challenge alignment (ASI:One Agent Challenge)

✅ Multiple agents registered on Agentverse, discoverable + usable via ASI:One
✅ Agent Chat Protocol implemented
✅ Real tool execution (YouTube/web APIs + validation) and agent-to-agent orchestration
✅ Full workflow completes with no custom frontend
🎁 Bonus: multi-agent debate, real-time data, reliability/recovery, sandboxed Payment Protocol

Monetization (sandboxed Payment Protocol)

PromptToPath has a credible, built-in monetization model: roadmaps are free; a $1 "premium" deep-dive roadmap (expanded resources and detail) is gated behind Fetch.ai's Payment Protocol. The Orchestrator implements the seller role and publishes the AgentPaymentProtocol manifest.

For the hackathon this runs in sandbox mode (PAYMENT_SANDBOX=true) — no cards are collected and no real money moves. The seller verifies and settles the transaction automatically so the full CommitPayment → CompletePayment handshake is demonstrable end-to-end.

Demo it against a running orchestrator (no changes to the live agents):

python -m scripts.payment_demo
# Buyer commits a $1 sandbox payment → Orchestrator auto-completes → "PAYMENT COMPLETE ✅"

Swapping in real Stripe checkout is a config change (set PAYMENT_SANDBOX=false and provide Stripe test keys); it's intentionally disabled here.

License

MIT (or your choice).

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

AnthropicIn code
HTMLIn code
OpenAIIn code
PythonIn code

4 of 4 appear in the indexed code.

AI coding agents

Claude CodeCommits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

78 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.

Project Info

PromptToPath

Inspiration

What it does

What's next

PromptToPath 🚀

Problem · target user · outcome

Architecture

Project layout

Setup

Environment (`.env`)

Run

Testing / demo checklist

Challenge alignment (ASI:One Agent Challenge)

Monetization (sandboxed Payment Protocol)

License

Analysis

Technology

AI coding agents

Codebase size

Structure

Application logic

Data & schema

Languages

Dependencies

PromptToPath

Inspiration

What it does

What's next

PromptToPath 🚀

Problem · target user · outcome

Architecture

Project layout

Setup

Environment (.env)

Run

Testing / demo checklist

Challenge alignment (ASI:One Agent Challenge)

Monetization (sandboxed Payment Protocol)

License

Technology

AI coding agents

Codebase size

Structure

Application logic

Data & schema

Languages

Dependencies

Environment (`.env`)