fondof

Inspiration

Most of what we learn still lives in places built for humans, not agents: podcasts, blog posts, talks, documentation, and newsletters. They’re full of useful techniques, but they aren’t skills an agent can pick up and apply to a specific codebase.

fondof gives that knowledge a second life. Give it a source URL, a stated need, or up to four sources, and it turns the underlying ideas into a concise, repo-specific skill—with attribution intact.

We also wanted to explore what an agent-native web actually feels like. With WebMCP, fondof exposes its capabilities directly to agents, so a user can stay in a conversation and say: “Find me a skill on React performance and forge one from this talk for my repo.”

What it does

fondof turns knowledge into agent-ready skills:

1. Extract — pulls actionable ideas from articles, YouTube, docs, or free-text needs.
2. Fit — matches those ideas to a target repo’s stack, conventions, and paths.
3. Forge — creates a short, copyable skill for Cursor, Claude, Kiro, or any agent.
4. Hand off — copies Markdown or creates a shareable /s/{hash} link.
5. Attribute — preserves source attribution and optionally anchors provenance on Monad.

It exposes three WebMCP tools:

• search_skills — search the public skill pool.
• get_skill — retrieve a skill by hash.
• compose_skill — forge a skill from URLs or a stated need.

Humans decide what they want; agents handle the extraction, discovery, composition, and formatting.

How we built it

• Frontend: Next.js 16, Framer Motion, Tailwind, deployed on Netlify.
• API: Cloudflare Worker + Hono, with Durable Objects for coordination, KV for sessions, and Workers AI for LLM + embeddings.
• Ingestion: Firecrawl / Readability for articles and docs, YouTube transcripts, plus a local fallback for offline needs.
• Search & fit: Exa for semantic discovery, plus /api/skills?q= for searching the public skill pool by topic, repo, stack, or source.
• Blockchain: SkillPool on Monad testnet for optional public provenance.
• Agent layer: webmcp-provider.tsx registers the three tools; /.well-known/webmcp and Permissions-Policy enable discovery.
• Monorepo: pnpm workspaces across web, api, core, cli, contracts, and shared.

We also dogfooded the build process in Kiro with a spec-first trail mapping directly to the shipped code.

Challenges we ran into

• Multi-source composition: Combining up to four sources requires deduplication, merging, progress tracking, and partial-failure handling without losing the whole batch.
• Agent UX: WebMCP tools need to tell an agent not just what they do, but when to use them, what inputs they need, and how to recover from failures.
• Attribution without friction: We wanted every skill traceable to its sources without requiring wallets or sign-in for the happy path.
• Honest failures: Instead of silently swallowing bad URLs, the Studio surfaces ingest errors and compose_skill returns structured source_failures.

Accomplishments that we're proud of

• A real, deployed WebMCP implementation with three working tools, a /.well-known/webmcp manifest, and the correct permissions configuration.
• Multi-source skill composition across up to four URLs, with per-source progress and failure reporting.
• A public skill pool with search, source-domain pages, and shareable skill pages.
• Agent discovery, retrieval, and creation as one continuous workflow.
• Honest degradation when ingestion fails, fallbacks are used, or the chain is unavailable.
• Open source and tested: MIT licensed, with 209 passing tests and a live Cloudflare Worker.

What we learned

• The browser can be the integration layer. WebMCP lets the site expose its capabilities directly to agents, without requiring a custom MCP server or separate API key.
• Search is essential for agent-native apps. If an agent can’t find an existing skill, it will re-forge what already exists.
• Attribution can become a network primitive. Sources produce skills, skills get reused and re-forged, and outcomes can eventually feed back into the pool.
• Humans + agents work best as a loop: the human decides, the agent discovers and composes, and the human stays in control.

What's next for fondof

• Creator analytics so authors can see which content became skills and where those skills were used.
• Knowledge clusters to turn the skill pool into a map of related sources, ideas, and re-forges.
• Outcome verification using PRs, screenshots, and repo deltas to measure real-world usefulness.
• Agent-to-agent challenges for contesting and re-forging skills with transparent evidence.
• A lightweight reward layer for creators and high-quality forgers, tied to usage and verified outcomes.

Built With

• cloudflare-workers
• exa
• foundry
• framer-motion
• hono
• monad
• netlify
• next.js
• react
• tailwind-css
• typescript
• viem
• wagmi
• webmcp
• workers-ai