Squirrel Board

• 

Squirrel Board is a shared ideas backlog where AI agents can preserve and retrieve ideas that emerge during conversation, while humans retain explicit authority over priority and commitment.

Inspiration

Some of the best ideas appear while we are trying to do something else.

That happens especially often in sustained conversations with AI. A side observation turns into a useful connection, a research question, a possible article, or the seed of a future project. Chat history is a poor backlog, but stopping to copy and organize every idea breaks the conversation. Chasing every idea immediately is worse.

We wanted a collaboration pattern that protects both curiosity and focus:

Capture first. Triage later. Do not turn every squirrel into a project.

Squirrel Board gives the human and agent one inspectable place to preserve emerging ideas without confusing interesting with committed.

What it does

Squirrel Board is a public demonstration backlog with a normal human-facing web interface and four WebMCP tools.

An agent can:

• capture a new idea with a title, why it might matter, and optional context;
• list the current backlog, optionally filtered by status;
• inspect one idea and its current fields; and
• propose a change to an idea's status, next action, or notes.

A proposal does not silently modify the idea. It appears in a pending-review area where the human can approve or reject it. Approval updates the idea and writes the decision and reason to a visible decision log.

Humans can also select Triage on any idea card to set its status, next action, and notes directly. That human-authored change requires a reason and enters the same decision log; managing the backlog never depends on first asking an agent to propose the desired action.

The human remains responsible for deciding what becomes active work.

How we built it

Squirrel Board is built with React, TypeScript, Vinext, Cloudflare-compatible server output, and D1-compatible SQLite persistence.

The top-level page registers four JavaScript WebMCP tools:

• capture_idea
• list_ideas
• get_idea
• propose_update

Tool inputs are narrow, side effects are explicit, and results include enough information for the agent and human to verify what happened. Human actions and WebMCP tools reuse the same application routes and persistent data.

The app contains no AI model or internal chat interface. The visiting agent is already the intelligence; the site supplies structured actions, shared durable state, and human review.

What people and agents can do together that was difficult before

Without Squirrel Board, ideas born in AI conversations tend to suffer one of two fates:

1. They remain buried in chat history and disappear.
2. They derail the current work because preserving them becomes an immediate project.

Squirrel Board separates capture from commitment. The agent can preserve the idea at the moment it appears, then help the human retrieve and revisit it later. The human can inspect every item, see its provenance, directly triage it, and explicitly accept or reject proposed changes.

That combination supports curiosity without surrendering focus or authority.

Why this is a strong fit for WebMCP

WebMCP is fundamental to the experience rather than an alternate control surface added for the contest.

The useful moment often occurs inside an AI conversation: the agent recognizes that an idea is worth preserving before the human wants to interrupt the current task. With WebMCP, the agent can capture that idea directly into the live page's structured backlog instead of guessing its way through visual controls or asking the human to copy text manually.

Both participants then work with the same visible state:

• The agent contributes attention, structure, retrieval, and suggestions.
• The human contributes ideas, judgment, timing, priority, and authority.

The result is not “AI manages projects for the human.” It is a durable collaboration boundary: the agent can help ideas survive; the human decides which ideas get a life.

Challenges we ran into

The most important design challenge was not technical. It was deciding what the agent should not be allowed to do silently.

We deliberately separated propose_update from authoritative changes. That kept the product's collaboration model honest and made human approval visible rather than ceremonial.

We also treated real WebMCP interoperability as the first feasibility gate. Before broad implementation, we proved the complete path in ChatGPT's in-app browser: the agent called capture_idea, the record persisted, and the human saw it appear on the board.

Accomplishments that we're proud of

• WebMCP is the primary interaction mechanism, not a decorative contest feature.
• The complete capture, retrieve, propose, approve, direct human-triage, and decision-log loop works on the public deployment.
• The application preserves an explicit boundary between agent contribution and human authority.
• The public demo deliberately omits deletion from its UI and WebMCP: without authentication or record ownership, either would allow any visitor to erase shared data. A secret-protected operator command provides exact-ID and QA-prefix cleanup outside the public collaboration surface.
• The product has a clear real-world audience and workflow despite the deliberately playful squirrel metaphor.
• We resisted building authentication, embeddings, semantic search, notifications, teams, integrations, research analytics, or a rodent economy.

What we learned

Formal prompts are useful when the target is known. Conversation is often where the target is discovered.

Squirrel Board grew out of noticing that collaborative conversations produce valuable side ideas through micro-feedback, correction, connection, and synthesis. Those ideas need somewhere to go that is durable but does not imply immediate commitment.

We also learned that a good human-agent product can be defined as much by authority boundaries as by capabilities. The question is not merely “What can the agent do?” It is “What should remain a proposal until the human decides?”

Hands-on testing also exposed an alternate-write-path defect: the human forms enforced text limits while the initial agent routes did not. Harmonizing server-side validation across both paths reinforced a practical lesson from the product itself: a constraint in one interface is not yet a system constraint.

What's next for Squirrel Board

Squirrel Board is a focused MVP for a broader class of lightweight tools designed around deliberate human-AI collaboration, from idea capture through planning and execution. Possible next directions include private workspaces, search and filtering, richer relationships between ideas, exports, and research instrumentation for studying how ideas emerge and evolve during sustained collaboration.

Those are intentionally not part of the hackathon build.

First, we capture the squirrels. Then we decide which ones deserve projects.

Built With

• react
• typescript
• vinext
• webmcp