Project Info

Plan B Agent

Inspiration

As an international student navigating life in America, there were several times when my Plan A's fail and I felt anxious, tending to overthink everything. There were countless moments where life didn't always go as planned, you might fail a startup, you might get rejected from an internship or a job or places where you really want to be. "When one door is shut, another is opened", a saying popped into my head. Then I thought to myself what if there is a tool that will help to open that new door, a real Plan B, to slow down emotional roller coaster. So for my first hackathon, I decided to build that door for myself and other people who are in the same situation as me.

What it does

Plan B is a two-agent system. You describe what fell through, a missed cohort, a rejected internship, anything in plain language. 1.The Triage agent, powered by Claude, reads it and extracts the real shape of the problem: your goal, your timeline, what's actually blocking you. 2.It hands this off over a genuine Fetch.ai agent-to-agent message, not a function call, to the Pathfinder agent. Pathfinder searches the live web, then opens a real Browserbase cloud browser session to visit the page and check there's a genuine way to reach out. 4.If it can't verify a real contact method, it throws the option away completely. 5.For what survives, Claude drafts a specific, ready-to-edit outreach email using only the details it actually confirmed. How I built it Two independently running agents built on Fetch.ai's uAgents framework, communicating over real inter-agent messaging, both registered on Agentverse with mailbox authentication. One of Claude's best qualities is reasoning so I have decided to include Claude in this role. Claude's role is to perform three distinct reasoning roles across the system Constraint extraction, Search-strategy decisions, Grounded result evaluation, each scoped to its own agent. Search-strategy decisions, Grounded result evaluation, each scoped to its own agent. In order for the agents to give answers based on real world, I used Browserbase and Stagehand that provides real cloud browser verification, not local simulation. A Flask API bridges the agents to a React/Vite frontend. My purpose for this project is to show what AI agent can do that regular AI tools and wrappers cannot which is giving non hallucinated answer. So I decided to go with this feature to make sure the users actually get what they are expecting(a real plan B product) The core architectural decision was building a real anti-hallucination filter directly into the code with is_doable(), is_real_candidate(), sanitize_contact_method() so an unverifiable option is structurally incapable of reaching the user, not just discouraged by a prompt. Challenges I ran into As a solo, first time hacker, the biggest challenge was what every developer has to face: debugging unfamiliar failure modes under time pressure, the API overload, garbled extraction data from real websites, model hallucination toward placeholder values, under time pressure, and learning to verify every fix with real evidence to solve the real problem instead of assuming it worked. Claude's agentic tool-use can pause mid-turn on long, multi-step requests, a mechanism I hadn't worked with before. I built a continuation loop so the agent could pick back up and finish reasoning properly, which taught me a lot about how Claude handles extended tool use in practice. Fetch.ai's side taught me something different, how genuinely convenient it is to register an agent on Agentverse and make it discoverable through ASI:One. That part came together smoothly. The harder part was a Python 3.9 compatibility wall that blocked full Agent Chat Protocol support specifically, I diagnosed this precisely (confirmed via pip index versions uagents-core, no compatible version exists for my environment) rather than guessing around it. Since time was running low, I moved forward with the working version, which taught me a lot about navigating sponsor tools efficiently under real constraints. Accomplishments that I am proud of Registering in UC Berkeley AI hackathon hosted by Calhacks, one of the biggest AI hackathons in the world with more than 1300 people with different experiences, as my first hackathon and on top of that, I am a first time hacker. Despite all the anxiety as a first time hacker and lack of experience, I really glad I applied for this. I wasn't expecting my project to be finished in 24 hours but I can proudly say I did finish it. I went from "I only heard about the AI agents but I don't know what they do" to "I built an AI agent to solve a problem that I am having", thanks to sponsors (mainly Anthropic and Fetch.ai)and their workshops. It helped me get familiar with AI agents and to actually use them in my projects for better quality, performance and solution. What I learned What is an AI agent? What can it do? What makes them different from regular wrappers? There are more than one agent and that they can communicate with one another. How real multi-agent systems actually communicate (not just simulate), how to build verification into code instead of trusting a prompt, and how to debug unfamiliar systems methodically, isolating each layer, demanding raw evidence instead of summaries, testing out after a few lines of code, and refusing to declare something "fixed" until I'd seen it work myself cause I am not only building for the hackathon but also for the real users. Another challenge was at first, I was automating browser on my own laptop instead of on the cloud then I learned about browserbase and its cloud infrastructure, making me change my direction. Switching to browserbase taught me how different cloud-based browser automation actually is from local testing, real network latency, real session lifecycle management, and a session start/navigate/act/extract/end flow that has to be handled deliberately, not assumed. Once switched over, I could see real Browserbase session logs confirming every page visit was genuinely happening in their cloud, not simulated which became the core proof behind my whole "verified, not guessed" approach.I cannot let un polished, untrustworthy product for the users to use. It makes me focus on one feature at a time, implement, test, debug, build and repeat again. This project and hackathon makes me a better Software Engineer(SWE).

What's next

1.Full ASI:One Chat Protocol once migrated off Python 3.9 2.Expanding Pathfinder's real-world actions beyond drafting, and generalizing Making the candidates from 1 to 2-3. 4.Deployment with Docker, vercel and render.

Plan B Agent

When life gives you lemons, we send an AI agent to go verify if there's actually a lemonade stand.

Plan A doesn't work out? Don't crash out! We are here to help you with your plan B.

*Built solo for the UC Berkeley AI Hackathon 2026 (Cal Hacks) — my first hackathon.🥳 *

The problem

Life doesn't always go our way. What happens when your Plan A doesn't work out?

Everybody should have a Plan B but it's overwhelming to think about one when your Plan A just failed and you're getting anxious, scrambling, unsure what's even still possible. If your brain is stressed, it's hard to think of a solutio. What actually helps isn't more advice. It's knowing what's real, verified, and actionable, with a clear first step.

That's what Plan B Agent does.

What it does

Plan B is a two-agent system. You describe what fell through, in plain language. One agent figures out the real shape of your problem. The other goes out, searches the live web, verifies a real way to act exists, and drafts a ready-to-edit outreach message — never showing you anything it couldn't confirm is real.

Meet the agents

Agent	Role
Triage	Reads your description, extracts structured constraints — goal, timeline, blocker, urgency
Pathfinder	Searches the live web, verifies real options exist, drafts your outreach

How it works, step by step

Triage reads your description and extracts structured constraints: goal, timeline, blocker, urgency.
Triage hands this off to Pathfinder over a real Fetch.ai agent-to-agent message — not a function call, a genuine inter-agent protocol exchange.
Pathfinder uses Claude with web search to generate concrete candidate options, grounded in real search results, not memorized knowledge.
For each candidate, Pathfinder opens a real Browserbase cloud browser session, navigates to the option's actual page, and looks for a real way to reach out (email, contact form, apply link).
If no real, verifiable contact method is found, the option is dropped — never shown as a guess. We only give you a solution that's actually solvable. This is enforced in code, not just prompted for.
For surviving options, Claude drafts a short, specific outreach email using only the verified details extracted from the real page.
You see a verified result and a ready-to-edit draft. Nothing is sent automatically until you review and send it yourself.

Why this isn't a wrapper

Unlike wrappers, these two agents are independently running agents, built on Fetch.ai's uagents framework, communicating over the real Agent Chat/message protocol, not two prompts to one model dressed up as agents.

Claude's biggest strength is reasoning, so Claude performs three distinct reasoning jobs across the system, each scoped to a different agent and a different responsibility:

Constraint extraction
Search-strategy decisions
Grounded evaluation of real results

Unlike regular AI tools that sometimes hallucinate and hand you a "Plan B" that isn't actually an option, Plan B Agent puts the user first so I made one feature mandatory, not optional. That feature is

The anti-hallucination filter. Any candidate without a genuine, Browserbase-verified contact method is discarded before it ever reaches the user. This is a hard rule enforced in code — is_doable(), is_real_candidate(), sanitize_contact_method() — not a hope baked into a prompt.

And it's a real action, not just advice: the system doesn't just suggest, it navigates a real page and produces a usable, specific draft grounded in what it actually found there.

Tech stack

Backend (Python)

Tool	Role
`uagents` (Fetch.ai)	Multi-agent framework — Triage and Pathfinder run as a `Bureau`, communicate over real agent messaging, registered on Agentverse (`mailbox` + `publish_agent_details`)
Anthropic SDK (`anthropic`, `AsyncAnthropic`)	Claude calls powering Triage's extraction and Pathfinder's search/evaluation/drafting logic
Stagehand (`AsyncStagehand`) + Browserbase	Live cloud browser automation — real agentic web actions, not local simulation
Flask + flask-cors	REST API server bridging the agents to the frontend (`backend/app.py`)
Pydantic	Message schemas between agents (`messages.py`)
python-dotenv	Environment config loading
`cosmpy`, `bech32`, `ecdsa`, `pycryptodome`	Crypto/wallet dependencies pulled in by `uagents`

Frontend (JavaScript)

Tool	Role
React	UI
Vite	Dev server / bundler
ESLint	Linting

Architecture flow

React frontend
   |
   v
POST /api/plan  (Flask)
   |
   v
Triage agent (Fetch.ai uAgent, Bureau, Agentverse-registered)
   -> Claude: constraint extraction
   |
   v   (real Fetch.ai agent-to-agent message)
Pathfinder agent (Fetch.ai uAgent)
   -> Claude: search strategy + grounded evaluation
   -> Stagehand / Browserbase: real page verification
   -> Claude: outreach drafting
   |
   v
result.json -> Flask -> React frontend

Agentverse registration

Both agents are registered on Agentverse via mailbox=True and publish_agent_details=True, confirmed with a live-acquired mailbox access token.

Triage agent: agent1q2x6qgah36a43gl6xu59xc93j862n02tw5waqfw5kx8m8584jamfgqw28ht
Pathfinder agent: agent1qv4t44yqllc74w3ykc5kwhfepnd6ff5akkq90cdr906pluwxlh57kuyxjl2

Full Agent Chat Protocol (uagents_core.contrib.protocols.chat) was implemented following Fetch.ai's official quickstart pattern, but the module is unavailable in any uagents-core version compatible with our Python 3.9 environment — confirmed via pip index versions uagents-core, no newer version exists.

Given hackathon time constraints, and as a solo hacker, I prioritized a fully working, verified agent pipeline over a last-minute Python version migration. Core Agentverse registration and inter-agent communication are real and fully verified; ASI:One conversational discoverability was not completed in the time available.

Running it locally

Prerequisites

Python 3.9+
Node.js
An Anthropic API key
A Browserbase API key + Project ID

Setup

# clone the repo
git clone https://github.com/YOUR_USERNAME/plan-b-agent.git
cd plan-b-agent

# python environment
python3 -m venv venv
source venv/bin/activate
pip install -r backend/requirements.txt

# environment variables
cp .env.example .env
# then fill in: ANTHROPIC_API_KEY, BROWSERBASE_API_KEY, BROWSERBASE_PROJECT_ID,
# TRIAGE_SEED, PATHFINDER_SEED

# frontend dependencies
cd frontend
npm install
cd ..

Run it (3 terminals)

# Terminal 1 — agents
cd backend
source ../venv/bin/activate
python3 run_agents.py

# Terminal 2 — Flask API
cd backend
source ../venv/bin/activate
python3 app.py

# Terminal 3 — frontend
cd frontend
npm run dev

Open http://localhost:5173 and describe a plan that fell through.

What's next

Expand from 1 candidate option to 2–3
Full ASI:One Chat Protocol support once migrated off Python 3.9
Give Pathfinder agent the ability to take more real-world actions, not just draft
To make the actions automatical.

Built solo by Lily Maung

A Software Engineering student at SJSU, first time hacker for UC Berkeley AI Hackathon 2026.

Analysis

Compare with all teams

View

Metric

lilyMaung
6

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
CSSIn code
FlaskIn code
HTMLIn code
JavaScriptIn code
PythonIn code
ReactIn code

7 of 7 appear in the indexed code.

AI coding agents

GitHub CopilotConfig

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

Codebase size

Source size

55 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

Plan B Agent

Inspiration

What it does

What's next

Plan B Agent

When life gives you lemons, we send an AI agent to go verify if there's actually a lemonade stand.

Plan A doesn't work out? Don't crash out! We are here to help you with your plan B.

The problem

What it does

Meet the agents

How it works, step by step

Why this isn't a wrapper

Tech stack

Backend (Python)

Frontend (JavaScript)

Architecture flow

Agentverse registration

Running it locally

Prerequisites

Setup

Run it (3 terminals)

What's next

Analysis

Technology

AI coding agents

Codebase size

Structure

Interface

API & routing

Application logic

Languages

Dependencies