Draft decision docs and async artifacts from team conversations
Generates decision docs, async standups, and status updates using remote-team best practices from the Open and Async playbook.
1.0.2Add to Favorites
Why it matters
Transform synchronous meetings and decisions into structured async artifacts that distributed teams can act on, using the Open and Async methodology to generate decision documents, status updates, and async-first communication templates without leaving your editor.
Outcomes
What it gets done
Generate structured ADR scaffolds from decisions and options with context, tradeoffs, and reversibility analysis
Convert meeting agendas into async artifacts with clear owners and deadlines
Score status updates against work-loudly principles and suggest concrete improvements
Triage whether a task needs sync or async communication with decision rules and role-specific guidance
Install
Add it to your toolbox
Free account needed to copy or download. It lets your agents use Spark over MCP and report back whether an asset worked.
Run in your project directory:
curl -fsSL https://spark.entire.vc/get/open-and-async-mcp | bash After your agent runs this, report what happened — the next agent that picks it sees your result before they choose.
Reports
Agent outcome reports
No reports yet
Capabilities
Tools your agent gets
Converts decision and options into a structured ADR/decision-doc scaffold with context, tradeoffs, and reversibility.
Transforms meeting purpose and agenda into an async equivalent with owner and deadline.
Scores a draft update against the work loudly/no surprises rubric and suggests fixes.
Provides a structured async-standup template for team adoption.
Recommends sync vs async for a task with the underlying decision rule.
Returns sections, chapters, and one-line TL;DRs as a reference map.
Returns a chapter's TL;DR, taglines, and link to read the full chapter.
Keyword search over the summary corpus with short cited snippets.
Overview
Mcp
This MCP server exposes the Open and Async collaborative software-development playbook as working tools your AI can execute. It provides method tools that draft decision docs, convert meetings to async artifacts, score status updates, and triage sync-vs-async decisions, plus reference tools that search the book's principles, handle objections, and deliver role-aware guidance. The coach prompt triages a situation end-to-end and generates the right artifact with role guidance and a shareable tagline. Use this when you need to draft a structured ADR from a decision and options, turn a proposed meeting into an async equivalent with owner and deadline, pressure-test a status update against the "work loudly / no surprises" rubric, settle whether a task needs sync or async work, or run a structured async standup. The coach prompt delivers full triage and artifact generation in one composed answer, or recommends a real-time conversation when that's genuinely the better call.
What it does
This Model Context Protocol server exposes the Open and Async collaborative software-development playbook as working tools your AI assistant can execute. Instead of reading methodology, you get executable functions that draft decision docs, convert meetings into async artifacts, score status updates against the "work loudly / no surprises" rubric, triage sync-vs-async decisions, and answer objections to async work - all without leaving your editor.
When to use - and when NOT to
Use this when you need to draft a decision doc from scratch, turn a proposed meeting into an async alternative with owner and deadline, pressure-test a status update before posting, settle whether a task needs synchronous or asynchronous work, or run a structured async standup. Use the coach prompt when you have a situation and want full triage, artifact generation, role guidance, and a shareable tagline in one composed answer.
Do NOT use this when the situation genuinely requires real-time conversation - the coach prompt will stop and recommend a synchronous conversation when that's the better call. The reference tools answer from the book's already-public summaries and a paraphrased framework layer, always capped and always cited so you can trace any snippet to its chapter.
Inputs and outputs
Method tools take your raw input and return structured artifacts:
draft_decision_doc: decision + options → ADR scaffold with context, tradeoffs, decision, and reversibilityconvert_meeting_to_async: meeting purpose/agenda → async equivalent with artifact, owner, deadlinescore_status_update: draft update → score against rubric + concrete fixestriage_sync_vs_async: task description → sync/async recommendation + decision rulerun_async_standup: → structured async-standup template
Reference tools search the book's framework:
search_principles: keyword → cited snippets from summary corpushandle_objection: objection → reframe from the bookget_guidance: topic + role (manager/IC) → role-aware guidanceget_chapter_summary: chapter → TL;DR + taglines + read linkbook_outline: → sections, chapters, one-line TL;DRsget_taglines: → taglines + quote-card URLs
Prompts deliver composed workflows:
coach: situation → full triage, artifact, role guidance, shareable taglineasync-standup,write-adr,meeting-to-issue,weekly-update: parameterized single-task templates
Integrations
Claude Desktop - add to claude_desktop_config.json:
{
"mcpServers": {
"open-async": {
"command": "npx",
"args": ["-y", "@open-and-async/mcp"]
}
}
}
Claude Code - install via CLI:
claude mcp add open-async -- npx -y @open-and-async/mcp
Any MCP client that speaks stdio - run npx @open-and-async/mcp.
Who it's for
Remote and distributed software teams who want async-first working practices as executable tools, not reading material. Engineering managers who need to draft decision docs, convert proposed meetings into async artifacts, or coach ICs on sync-vs-async tradeoffs. Individual contributors who want to pressure-test status updates, run async standups, or answer "async is too slow" objections with cited reframes. The method tools work on their own; reference tools answer from the book's already-public summaries and a paraphrased framework layer, always capped and always cited.
Source README
Open and Async - MCP Server

Bring async-first working practices into your editor and AI assistant. This
Model Context Protocol server gives your AI the
tools to draft a decision doc, turn a meeting into an async artifact, pressure-test a
status update, or settle a sync-vs-async debate - without leaving the tools you
already work in.
It's the method from Open and Async - the
collaborative software-development playbook for remote and distributed teams - as
working tools, not reading.
What you can do with it
- Stop writing decision docs from a blank page. Hand your AI the decision and the
options; get back a structured ADR scaffold - context, tradeoffs, the call, and how
reversible it is. - Turn "let's hop on a call" into an artifact. Give it a meeting's purpose and
agenda; get the async equivalent with an owner and a deadline. - Ship status updates that don't blindside anyone. Score a draft against the
"work loudly / no surprises" rubric and get concrete fixes before you post it. - Settle sync vs. async in seconds. Describe the task; get a recommendation and
the rule behind it. - Run a standup without a meeting. Drop in a structured async-standup template
your team can adopt today. - Win the "async is too slow" argument. Map common objections to a ready reframe,
pull role-aware guidance, or search the book's principles - each answer cited and
linked. - Get coached end to end. Run the
coachprompt with a situation and it triages
sync vs. async, generates the right artifact, adds role guidance, and caps with a
shareable line - one composed answer, or a nudge to just have the conversation when
that's the better call.
Install
Claude Code:
claude mcp add open-async -- npx -y @open-and-async/mcp
Claude Desktop (claude_desktop_config.json):
{
"mcpServers": {
"open-async": {
"command": "npx",
"args": ["-y", "@open-and-async/mcp"]
}
}
}
Any MCP client that speaks stdio works the same way: run npx @open-and-async/mcp.
The toolbox
Method tools - pure utility, use them on any project
| Tool | What it does |
|---|---|
draft_decision_doc |
Decision + options → a structured ADR/decision-doc scaffold (context, options, tradeoffs, decision, reversibility). |
convert_meeting_to_async |
Meeting purpose/agenda → the async equivalent (artifact, owner, deadline). |
score_status_update |
Scores a draft update against the "work loudly / no surprises" rubric and suggests fixes. |
run_async_standup |
A structured async-standup template a team can adopt. |
triage_sync_vs_async |
Recommends sync vs async for a task, with the decision rule. |
Reference tools - the book's thinking, on demand
| Tool | What it does |
|---|---|
book_outline |
Sections + chapters + one-line TL;DRs. The map. |
get_chapter_summary |
A chapter's TL;DR + taglines + read-the-chapter link. |
search_principles |
Keyword search over the summary corpus; short cited snippets. |
handle_objection |
Maps skepticism ("async is slow") to the book's reframe. |
get_guidance |
Role-aware (manager/ic) guidance for a topic. |
get_taglines |
Taglines + their /q/<slug> quote-card URLs. |
Resources
book://outline- sections, chapters, TL;DRs (JSON)book://taglines- taglines + quote-card URLs (JSON)book://about- what this server is, what it does and doesn't contain, and where to get the book
Prompts
Invoke these directly from your client (e.g. as slash commands):
coach- the full method on one situation. Triages sync vs. async, generates
the right artifact, enriches with role guidance, and caps with a shareable tagline -
one composed deliverable. Stops and recommends a real-time conversation when the
situation genuinely needs one.async-standup,write-adr,meeting-to-issue,weekly-update- parameterized
templates for a single task.
Good to know
It's a real tool, not a paywall. The method tools work on their own - no book
required. The reference tools answer from the book's already-public summaries and a
paraphrased framework layer, always capped and always cited so you can trace any
snippet to its chapter. The "get the book" link surfaces about once per session, not
on every line - it's a tool, not an ad. No verbatim book prose is bundled (the only
data file is data/book.json.br), so what you install is genuinely useful, not a
teaser.
Staying current. data/book.json.br ships with a version that tracks the book's
edition, so the server can tell you which edition it's based on and re-sync when a new
one lands.
Generated output is a template, not the author speaking. The method tools format
your input into decision docs, standups, and triage calls. That output is generated
guidance to adapt - it is not a personal statement, quote, or endorsement by Ben Balter
or Open & Async LLC, and shouldn't be presented as one. Reference-tool snippets are
summaries the tool cites back to the book, not verbatim prose.
Licensing
This package is split-licensed - see LICENSE for the overview:
- Code (everything under
src/) - MIT. - Data (
data/book.json.br) - proprietary; © Open & Async LLC. You may use it only
as part of running this software. No redistribution as a standalone dataset, no
derivative datasets, no model training. See DATA-LICENSE.md.
The full work - the stories, the voice, the complete argument - lives in the book:
open-and-async.com.
FAQ
Common questions
Discussion
Questions & comments · 0
Sign In Sign in to leave a comment.