the mcp server pattern for agent skills

when we started building nod, we had a choice. build a traditional saas app with its own ui, auth, and onboarding. or build skills that plug into the agents people are already using.

we chose skills. here's why.

agents are the new interface

the best ai agents already know your context. they know what you're working on, what you've been reading, who you've been talking to. building another app means throwing all that context away and starting over.

mcp (model context protocol) lets us build tools that agents can use directly. your agent gains new abilities without you learning a new interface.

what's an mcp server?

an mcp server is a lightweight service that exposes tools to ai agents. think of it like an api, but designed specifically for agent interaction. the agent discovers what tools are available, understands what they do, and calls them when relevant.

for shout, the mcp server exposes tools like:

- `shout_save_link` - save a link with metadata extraction - `shout_list` - browse your saved links - `shout_create_collection` - organize links into collections - `shout_feed` - see what people you follow are sharing - `shout_generate_digest` - create a weekly roundup

your agent calls these naturally during conversation. "hey, that article is great, let me shout that for you." or you say "shout this" and it happens.

why not a rest api?

we could have built a traditional rest api and written integration code for every agent platform. but mcp gives us plug-and-play compatibility. any mcp-compatible agent (sidebrain, openclaw, claude, etc) can use nod skills immediately.

one server, every agent.

the composability angle

the real power is composability. nod skills aren't monolithic. shout handles link curation. intros handles introductions. recap handles weekly updates. each is its own mcp server. agents can mix and match.

and because they're all reading from the same data (your links, your profile, your network), they make each other smarter. shout data improves intro matching. intro connections lead to better content in your feed.

building your own

if you're an agent developer, the pattern is simple:

1. define your tools (what can the agent do?) 2. build a lightweight server (typescript + @modelcontextprotocol/sdk) 3. connect to your data layer (supabase, postgres, whatever) 4. publish and let agents discover it

the agent ecosystem needs more skills. the interface layer is solved. the tool layer is wide open.