THREAD

• 

  THREAD turns project planning into a negotiated contract: agents propose with evidence, and only humans approve.

• 

  Agents can inspect, simulate, and recommend—but only a human can approve and atomically apply a plan.

• 

  A live dependency graph keeps tasks, risks, constraints, critical paths, forecasts, and agent actions in one shared state.

• 

  Compare Safest, Fastest, and Highest-impact proposals with exact graph changes, constraint checks, and seeded forecasts.

• 

  Every approved change records its actor, reason, and evidence in the decision ledger, with full rollback available.

• 

  1. Forty-six WebMCP tools expose strict, debuggable state, backed by Cloudflare D1 persistence and browser-local recovery.

Inspiration

Most project-management tools tell you what needs to be done, but not whether the plan can actually succeed.

A checklist might show 20 unfinished tasks while hiding the facts that only five determine the deadline, one uncertain task could delay everything, and the total plan has almost no chance of finishing with the available time and budget. AI assistants can suggest improvements, but those suggestions often remain trapped in a chat instead of becoming safe, visible changes to the real plan.

I built THREAD to give humans and AI agents the same structured reality: one dependency graph, one planning engine, one simulation model, and one persistent workspace.

What it does

THREAD turns a goal into a living execution graph.

Each task can contain:

• Dependencies
• Status and priority
• Minimum, expected, and maximum duration
• Confidence
• Cost
• Description and graph position

A workspace also tracks deadlines, budgets, resources, hard constraints, risks, milestones, and available capacity.

From this information, THREAD can:

• Calculate the critical path
• Identify slack, conflicts, and bottlenecks
• Show which tasks block the most downstream work
• Run reproducible Monte Carlo simulations
• Estimate finish probability, median completion time, P80, P95, and cost exposure
• Identify the risks and tasks driving schedule variance
• Compare immutable what-if scenarios
• Apply, replan, optimize, or roll back structured changes
• Record human, agent, system, and persistence activity

The seeded demonstration models the work required to submit THREAD itself. It includes 14 tasks, 21 dependencies, three hard constraints, quantified risks, limited capacity, and a fixed budget. Its baseline simulation shows that a plan can appear reasonable while still having only about a 71% chance of finishing.

Users can test alternatives such as cutting nonessential work, recruiting help, or adding more features. Every scenario runs through the same seeded engine, making comparisons reproducible rather than arbitrary.

Human-agent collaboration

THREAD is not a chatbot placed beside a task board.

Through WebMCP, a compatible agent can directly understand and operate the project’s structured state. The live application currently exposes 38 native tools covering:

• Workspace, task, dependency, constraint, risk, resource, timeline, and activity retrieval
• Task, milestone, dependency, risk, resource, constraint, and scenario creation
• Task updates, completion, prioritization, movement, and risk resolution
• Critical-path analysis, conflict detection, bottleneck discovery, simulation, and feasibility calculation
• High-level plan application, optimization, replanning, scenario comparison, and rollback

These tools use strict schemas and stable identifiers. Invalid relationships—including self-dependencies, duplicates, missing tasks, and dependency cycles—are rejected before they can corrupt the graph.

Human actions and agent actions use the same domain services. When an agent changes a task, the human sees that change in the graph. When the human changes a constraint, the agent reads the updated value. The activity stream shows who performed each action, making agent participation visible and reversible.

How I built it

I designed THREAD around a shared application layer instead of implementing separate logic for the interface and WebMCP.

The visual interface, planning engine, persistence system, and WebMCP tools all operate on the same workspace model. This prevents the agent-facing representation from drifting away from what the user sees.

The planning engine performs deterministic critical-path calculations across the dependency graph. The simulation engine then evaluates task-duration ranges, confidence, costs, capacity, dependencies, and quantified risks across seeded iterations.

Using a fixed seed means that the same plan produces the same result. That reproducibility is important when a human and agent are comparing alternatives: an improvement should come from the plan changing, not from random noise.

Workspace state is persisted with Cloudflare D1, with browser-local recovery available when remote persistence cannot be reached. A dedicated WebMCP debugger displays the complete registered surface and can test read tools, mutation tools, malformed inputs, state synchronization, and reset behavior.

The public demo requires no signup or API key, allowing judges to load a complete workspace immediately.

Challenges

The hardest challenge was keeping the human interface and agent interface synchronized.

It would have been easier to create a collection of WebMCP wrappers that returned demonstration data. Instead, each tool needed to call the same validated services as the visible application and produce a real state change.

Graph correctness was another challenge. Dependency editing must prevent cycles while continuously recalculating task timing, slack, and the critical path.

Simulation also required care. A percentage is not useful if it cannot be explained or reproduced, so THREAD reports percentile estimates, cost ranges, failure sources, and variance drivers alongside the headline probability.

Finally, I had to make a complex planning model understandable. The graph, inspector, risk panels, feasibility score, scenario cards, simulation results, and activity history all needed to reveal depth without overwhelming a first-time user.

What I learned

I learned that WebMCP becomes most valuable when it exposes capabilities that are difficult and unreliable to perform through visual clicking alone.

An agent can retrieve an entire dependency graph, identify bottlenecks, simulate the plan, and apply a validated set of operations through structured tools. Meanwhile, the human retains the interface best suited to judgment: a visual graph, transparent comparisons, and an inspectable history.

The strongest human-agent experiences do not hide the agent or replace the human. They give each participant the right interface while keeping both grounded in the same state.

What I am proud of

I am most proud that THREAD is more than a technical WebMCP demonstration. It is a functioning planning product with:

• A complete visual workspace
• Real dependency and risk modeling
• Reproducible simulation
• Persistent shared state
• A substantial native WebMCP surface
• Human and agent activity tracking
• Scenario isolation and rollback
• A dedicated verification console
• A judge-ready, no-signup demo

What is next

The next step is deeper plan negotiation: allowing agents to prepare several simulated proposals while humans lock non-negotiable constraints, compare visual graph differences, answer structured tradeoff questions, and approve the final plan.

The long-term vision is for THREAD to become an execution environment where humans and agents do not merely discuss goals—they build, test, negotiate, and maintain a plan that has a measurable chance of succeeding.

Built With

• cloudfared1
• cloudfareworkers
• css3
• html5
• javascript
• lucide
• react
• reactflow
• vite
• webmcp
• zod