OSS maintainers are drowning in AI-generated "slop PRs" while simultaneously facing sophisticated supply-chain attacks (xz-utils style). Current solutions (2FA, signed commits, Sigstore) only verify identity — they don't answer "should I trust this person to touch this code?" The cost of contribution review is paid entirely by maintainers, in attention.

Evidence: Graduated Trust proposal — the entire document, recently enriched with cross-references by the Gardener agent. See also Fix OSS with Seed Hypermedia. The Vibe code like a PRO post directly motivates the slop PR problem.

OSS maintainers of popular packages (npm, PyPI, crates.io ecosystems)

Foundation security teams (OpenSSF, Apache, Linux Foundation)

Enterprise open source program offices (OSPOs)

CI/CD platform providers (GitHub, GitLab)

A GitHub/GitLab app that computes a trust score for every PR contributor based on their position in a cryptographically verifiable Web of Trust. The score determines friction level:

Hop 0-1 (maintainers + direct vouchees): No friction, normal review

Hop 2 (friend-of-friend): Light checks (key age, single reviewer ack)

Hop 3+ (distant): Proof-of-context questions, observation windows, multiple reviewers

No path: Maximum PoW + canary quarantine

A CLI/server that constructs a trust graph from signed contacts

A GitHub bot that adds a trust-score label + friction checklist to PRs

A simple hop-distance badge in the PR

Publish on a Seed site as the canonical trust-graph viewer.

Ship as a free GitHub App with a "Pro" tier for private repos

Publish the Graduated Trust essay widely (HN, lobste.rs, r/programming)

Partner with one high-profile OSS project (e.g., Homebrew, Tailwind, Vite) as a pilot

Cross-post to OpenSSF, CNCF security channels

Free tier: Public repos, basic hop scoring

Team tier ($99/mo): Private repos, custom friction policies, canary quarantine

Enterprise ($499/mo): SSO, audit logs, EigenTrust-style path quality weighting, integration with existing CI/CD

Sigstore: Verifies identity, not trustworthiness — complementary

Socket.dev: Detects malicious packages, not malicious contributors

GitGuardian: Secrets detection, not trust scoring

EigenTrust (academic): Paper only, no product

Keybase (deprecated): Had proof-of-identity but not scoped vouching

9/10 — The problem is widely acknowledged (xz-utils, slop PRs are daily pain), the solution is novel, and Seed already has the primitives.

Build a tiny demo: two Seed accounts, one vouch, display hop distance on a mock PR page. Show it to 5 maintainers of popular npm packages. Would they install a GitHub bot that shows this? Would they pay?

MVP: GitHub bot with static hop scoring (week 1-2)

Add vouch creation UI inside Seed (contacts extension) (week 3-4)

Proof-of-context question generation (week 5-6)

Observation windows and quarantine mode (week 7-8)

Self-hosted Enterprise (week 9-10)

---

Multiple agents operate in the Seed ecosystem (Knowledge Manager, Content Strategist/Gardener, Product Scout), but each requires custom infrastructure, charter documents, and tool integration. There's no reusable framework for building Seed-native agents. The Agents project is in development, and notes like 12 Engineering Principles for Agents and Agents, Memories and the Actor Model show active exploration.

Seed team members building automated agents

Seed site owners who want automated content curation

Developers building on Seed who need agentic workflows

A TypeScript SDK + CLI for building Seed agents with:

Pre-built tool integrations (read, write, search, activity feed)

State machine-based execution model (aligned with State machines to visualize the work of agents)

Charter/runbook scaffolding

Allowlist and permission management

Extract the common patterns from the Knowledge Manager and Gardener agents into a reusable npm package. Publish with docs and one tutorial.

Open-source SDK. Paid: Agent hosting service ($20-100/mo per agent), managed execution.

7/10 — Clear internal need. External demand uncertain until Seed has more developers.

Document the Gardener agent's architecture and ask 3 developers building on Seed: "Would a packaged version of this save you time?"

---

As noted in the Graduated Trust document, AI can produce plausible patches that compile but reveal, on closer inspection, that the contributor cannot answer basic questions about their own change. Maintainers report drowning in "slop PRs."

Evidence: Block c5grnrqz in Graduated Trust — "A contributor today can produce dozens of patches in an afternoon, none of which they understand." The proof-of-context section (block BOvMpIbs) describes the mechanic.

Same as Opportunity #1, but narrower: maintainers who want a technical filter before human review.

A service that analyzes a PR diff and surrounding codebase to generate comprehension questions. The contributor must answer correctly before the PR enters review. Questions test understanding, not access to documentation.

A CLI that takes a git diff and generates 3-5 multiple-choice questions. Integrate as a GitHub Actions step.

Free tier: 10 checks/month. Pro: $29/mo unlimited. Enterprise: self-hosted.

6/10 — The problem is real, but question quality depends on LLM capabilities. Risk: contributors find ways to game it.

Build a single GitHub Action that generates questions for JS/TS diffs. Test on 10 real PRs from open source projects.

---

[NEW] 4. Trust Graph Interactive Block (Embeddable Seed Document Component)

The graduated trust concept is intellectually powerful but abstract. Maintainers, contributors, and OSPO teams need to _see_ the trust graph — who vouches for whom, hop distances, path quality — to believe it.

Evidence: The Graduated Trust document has the full theory but no interactive component. The Remodeling the web hub references trust documents.

Seed document authors wanting to embed trust visualizations inline

OSS maintainers evaluating a contributor's graph position

Foundation security teams demonstrating trust models to stakeholders

Conference speakers explaining graduated trust visually

A new Seed document block type: an interactive, embeddable trust graph visualization that renders a force-directed graph of Seed contacts, capabilities, and hop distances. Features:

Read-only mode: visualizes trust graph for a given account/domain

Interactive mode: hover/click nodes to see vouch details, hop paths

Embeddable: can be placed inline in any Seed document like a code block or embed

A React component that renders a D3/force-directed graph from a Seed contact list

API endpoint that returns the trust graph as JSON for a given account

A sample document embedding the block showing the Seed ecosystem's trust graph

Ship as an open-source npm package (@shm/trust-graph-block)

Embed in the Graduated Trust document itself as a live demo

Publish a "Seed Trust Explorer" site

Open-source block. Monetize through the Graduated Trust scoring service (#1) — the block is the visualization front-end.

D3.js examples: generic, not Seed-specific, no vouch semantics

Neo4j Browser: requires database, not embeddable

Obsidian Graph View: local notes only, no cryptographic trust

7/10 — Technically straightforward. If the Graduated Trust essay gains traction, this becomes the "show, don't tell" asset.

Build a static trust graph of the Seed ecosystem accounts using their contact lists. Embed it in the Remodeling the web hub.

---

[NEW] 5. "Remodeling the Web" Learning Curriculum & Badge Program

The web remodeling knowledge is now spread across 8+ documents in a rich hub at Remodeling the web. But there's no structured learning path.

Evidence: The See-Also section lists 9 interconnected resources covering hypermedia architecture, trust, content addressing, and web criticism.

Developers discovering Seed for the first time

Conference attendees who heard the "Remodeling the Web" thesis

Web platform thinkers exploring hypermedia alternatives

A structured learning curriculum that guides readers through the web remodeling thesis step by step:

Level 1 — The Diagnosis: Why the web is broken

Level 2 — The Vision: What hypermedia should be

Level 3 — The Foundation: Cryptography, identity, and trust without central authority

Level 4 — The Application: Concrete projects

Level 5 — The Future: Open questions, research directions

A single Seed document (/curriculum/remodeling-the-web) that links to existing resources in sequence.

Link from every Seed document: "Start the Remodeling the Web curriculum"

Include in Horacio's speaking slide deck as a QR code

Post to HN when the Graduated Trust essay drops

Free. Premium: certificate of completion with signed Seed capability ($19 one-time).

6/10 — Low build cost, strengthens the narrative, but monetization is indirect.

Publish the curriculum document and track how many readers complete all 5 levels. Survey: "Did this help you understand Seed's thesis?"

---

Users of Seed need to export their knowledge for backup, migration, or publishing on other platforms. The current export format is unusable — one user reported "I need to export docs and the format it gives me is useless for me :(". Multiple import tools exist (WordPress, PDF) but no symmetric export capability. This creates a lock-in perception that discourages adoption.

Evidence: User issue [I need to export docs and the format it gives me is useless for me](hm://z6MkuBbsB1HbSNXLvJCRCrPhimY6g7tzhr4qvcYKPuSZzhno/issues/i-need-to-export-docs-and-the-format-it-gives-me-is-useless-for-me). The Deploy a Seed Site From Your Own Fork guide shows user interest in portability. Import projects (WordPress importer, PDF Importer) lack export symmetry. The Web Import Script project further reinforces import-first, export-later pattern.

Seed users migrating content out (backup, migration to other platforms)

Seed site owners who want reproducible builds of their site

Academic users who need standard formats (Markdown, HTML, PDF) for citations

New users evaluating Seed who need assurance they can leave

A suite of export tools that convert Seed documents into standard portable formats:

Markdown export: Full document tree → clean Markdown with frontmatter, block structure preserved

ZIP archive: Complete site export with folder hierarchy matching Seed paths

PDF/HTML: For publishing and printing

JSON-LD: For academic/schema preservation, aligned with Seed's content-addressed graph

One-click site backup: Exports entire site with all versions and comments

A CLI tool (seed export) that exports a single Seed document or path to clean Markdown. Two commands: seed export ./my-path > output.md and seed export ./my-path --format zip > backup.zip. Published as a Seed site plugin.

Built into the Seed desktop app under "File → Export"

Available as a CLI via npm (@shm/export)

Documentation page: "How to export your Seed site"

Mention in onboarding: "Your data is yours — export anytime"

Free and open-source (core export). Premium features ($9/mo): batch export of entire sites, scheduled backups, PDF with custom styling, JSON-LD with full citation graph.

Notion export: Good Markdown export, but no PDF/JSON-LD

Obsidian publish: Format-specific, proprietary

WordPress export: XML-only, no Markdown

Differentiation: Content-addressed export preserves block-level provenance and cryptographic authorship — no other platform offers verifiable export chains.

8/10 — The demand signal is direct (user pain). Low technical risk. Directly addresses the "lock-in" objection that blocks Seed adoption.

Export one complex Seed document (e.g., the Graduated Trust proposal with its embedded links, headings, and code blocks) to Markdown. Show the result to the user who filed the export issue. Does it meet their needs?

---

The Seed ecosystem now operates 4+ autonomous agents (Knowledge Manager, Gardener, Content Strategist, Product Scout) on the same knowledge repository. Each has its own charter, runbook, and allowlist. They analyze overlapping documents, generate content, and make edits — but there is _no coordination layer_. The Gardener enriches documents with backlinks while the Content Strategist ranks opportunities from those same documents. Neither knows what the other is doing. Risk: edit conflicts, redundant work, contradictory conclusions, and agents stepping on each other's changes.

Evidence: The Repository Maintenance document from the Librarian agent references both the Gardener's Emerging Topics tracker and the Content Strategist's Signature Ideas — showing cross-agent dependency without formal coordination. The Agents project defines agent specs (specification, instance, session, completion, trigger) but explicitly omits multi-agent coordination, resource locking, or conflict resolution. The 12 Engineering Principles for Agents note and Breaking Ground with Agents show active exploration without a coordination answer.

Seed team members running multiple agents

External Seed site administrators who want automated agents

Developers building agent ecosystems on Seed

Any multi-agent deployment requiring conflict-free operation

A lightweight coordination protocol for Seed agents built on three primitives:

Document-level leases: Agents acquire temporary write-ownership of a document before editing, preventing simultaneous writes (implemented as capability delegation with TTL)

Agent activity broadcast: Each agent publishes a "currently working on" activity event so other agents can see in-progress work

Conflict detection & alerting: When two agents modify the same document, a conflict event is raised with both diffs and agent identities

Orchestrator agent (optional): A coordinator that schedules agent runs to avoid overlap

A simple lease system: before any agent writes to a document, it checks a "lock" document in the same path (_locks/document-name). If the lock exists and hasn't expired, the agent skips that document. If not, it writes the lock, does its work, then releases it. All lock operations go through the existing capability system.

Package as part of the Seed Agent SDK (#2)

Document the protocol in a spec document in the Seed community

Reference implementation for TypeScript agents

Conference talk: "Running 5 Agents Without Breaking Things"

Open-source protocol. Paid: Orchestrator agent as a managed service ($49/mo) with activity dashboard showing all agent operations across your site.

LangGraph: Agent orchestration for LLMs, not document-level coordination

CrewAI: Multi-agent coordination for task execution, not persistent document stores

Temporal.io: Workflow orchestration, heavyweight for this use case

Differentiation: Purpose-built for Seed's content-addressed, permission-based document model. Uses capabilities (not API keys) for lock ownership. Content addressing makes conflict resolution deterministic.

7/10 — The need is real and growing (4 agents already, more coming). The lease pattern is simple. The bet is whether the ecosystem will have enough agents to justify the coordination layer.

Simulate a conflict: Product Scout and Content Strategist agents both attempt to edit the Product Backlog simultaneously. Without coordination, document update fails or one overwrites the other. Implement a simple lease check and demonstrate clean serialization. Measure: conflict-free edit cycles.

---

Site owners on Seed have no insight into what's happening on their sites. No metrics: which documents get the most views, which discussions are active, where readers come from, what content grows the community. Users perceive Seed as "blogging software for static content" because there's no feedback loop showing engagement. The team has identified this need through multiple project entries and notes.

Evidence: The SeedTeamTalks project list includes Give publishers access to site statistics and Funnel Analytics. The opportunities list references "Email funnel" and "Site statistics". The issue Users perceive Seed as blogging software for static content shows the perception problem analytics would help correct. The Funnel Analytics project has a complete proposal.

Seed site owners and community managers

Seed administrators who need to make data-driven decisions

Content creators who want to understand their audience

Seed team members tracking product growth

A privacy-respecting analytics dashboard integrated into Seed sites, showing:

Document engagement: view counts, comment activity, time-on-document

Community growth: new members, active commenters, churn signals

Referral sources: how readers discover your site

Trending content: which documents are gaining traction

Discussion health: which threads are active, reply rates, resolution rates

A single dashboard page showing document-level view counts (from server-side blobs), comment activity (from activity feed), and subscriber growth (from subscription service). Built as a Seed document with query blocks aggregating feed data.

Built into the Seed admin panel as "Site Dashboard"

Available as a query block template site owners can embed

Email digest: weekly summary of site activity sent to site owner

Free tier: basic document views and comment activity (last 7 days). Pro ($19/mo): full analytics (30-day history, referrers, export). Enterprise ($99/mo): multi-site dashboard, custom events, API access.

Plausible / Fathom: Privacy-first analytics, but not integrated into Seed

Ghost Analytics: Built-in for Ghost CMS, but Seed is not a CMS

Discourse analytics: Forum-specific, not document-based

Differentiation: Runs entirely on Seed's existing data (activity feed, subscriptions, comments) — no external tracking scripts, no cookies, no GDPR friction. Query-block-based so site owners can customize their own dashboard.

7/10 — Clear demand (two project entries). Low technical risk (data already exists in activity feed). The question is whether this moves the needle on engagement perception.

Build a query block that shows "Documents with most comments this week" and add it to the SeedTeamTalks home page. Ask site owners: "Does seeing engagement data change how you think about your site?"

---

Developers love state machines conceptually but find them "hard to establish" in practice. The Seed ecosystem's own document machine has 10+ states (loaded, editing, publishing.saving, publishing.done, rebase, versionHistory, etc.) modeled in XState v5 — and debugging these complex state machines is painful without visual tooling. Agents also use state machines for deterministic behavior, compounding the need.

Evidence: The post State machines are great, but hard to establish explicitly documents this adoption pain. The Notes about how the document machine should work post details the complex document lifecycle. The State machines to visualize the work of agents post argues state machines are essential for agent determinism. The Agents and State Machines note models agents as state machines. The entire State Machines — Knowledge Map hub collects 10+ related documents across accounts.

Developers building complex UI with XState (Seed team primary)

Developers building observable agents with state machines

Technical writers documenting state machine behavior

Educators teaching state machine patterns

A visual state machine inspector/debugger that:

Renders any XState v5 machine as an interactive state diagram

Shows current state, transitions, and context in real-time

Records state transition history as a timeline for debugging

Supports "time travel": scrub through state history to see how the machine evolved

Embeddable in Seed documents as a block type

Works as a standalone web tool for non-Seed users

A React component that takes an XState v5 machine definition and renders it as an interactive SVG diagram using D3. Shows: current state highlighted, transition arrows with labels, context panel on click. Bundle as an npm package with a Storybook demo.

Open-source npm package (@shm/state-inspector)

Embed in Seed's own documentation for the document machine

Post to r/reactjs, XState Discord, Hashnode

Publish a "State Machine Playground" site for trying machines live

Open-source. Monetize through Seed Site Pro subscription ($19/mo) for the embeddable block. Enterprise: custom styling, offline mode, integration with existing XState inspect tools.

XState Viz: Official visualizer, but limited to static diagrams, not live inspection

Stately Studio: Paid visual editor, not inspector/debugger

React DevTools: Generic component inspector, no state machine semantics

Differentiation: First live state machine inspector with time-travel debugging and Seed document embed support. Directly addresses the "hard to establish" friction documented in Seed's own content.

6/10 — Niche market (XState users), but extremely high value for those users. Strong Seed fit (document machine, agents). Low build cost.

Take the 465-line XState v5 document machine from No more Edit mode project plan and render it with the inspector. Show to 3 developers who use XState. Ask: "Would you use this to debug your state machines?"

---