Asynthetic

io.github.asyntheticaiPublished by GitHub account asyntheticaiv0.1.3Updated Oct 24, 2026

Ground truth for AI coding agents: what breaks between library versions and how to fix it

VerifiedStreamable HTTPWeb executableKnowledge & MemoryDeveloper Tools

Overview

AI-generated overview

Asynthetic gives coding assistants curated migration maps: breaking changes between library versions, with before/after code and cited sources.

What you can do
Look up breaking changes between two versions of a package, with before/after code and citations for each entry, plus a verification level and last-verified date. Ask what a single version breaks. Check whether two package versions are compatible, answered true, false or unknown with a cited reason. List which migration maps the server currently holds. When no data exists, the server reports found: false and tells the assistant not to guess.
When to use it
Use it when an assistant is upgrading a JavaScript or AI SDK library (for example Next.js 14 to 15 or AI SDK 4 to 5) and needs the actual diff rather than current documentation, or when checking peer-version compatibility before editing code.
Requirements
Either the hosted remote endpoint over Streamable HTTP, or the local npm package run with npx over stdio, which serves bundled maps offline. No account, API key or environment variable is needed for normal use. Self-hosting in HTTP mode uses PORT, and serving from Postgres uses SUPABASE_URL and SUPABASE_ANON_KEY.
Before you install
Read-only lookups over curated data: no code execution, no request-time fetching, no access to your project or files. The hosted endpoint receives only tool arguments such as package names and version strings, and sessions are ephemeral and in-memory. Coverage is narrow (Next.js 14 to 15 and AI SDK 4 to 5 at time of writing), and it is a free public beta.

Installation

In SourceWeft

  1. Open Asynthetic in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.asyntheticai%2Fasynthetic/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "asynthetic": {
      "type": "http",
      "url": "https://asynthetic.up.railway.app/mcp"
    }
  }
}

README

Asynthetic

Ground truth for AI coding agents.

Your agent's knowledge froze on a date. Asynthetic tells it exactly what changed — every breaking change between library versions, cited and tested.

sh
claude mcp add --transport http asynthetic https://asynthetic.up.railway.app/mcp
jsonc
// agent asks: get_migration("ai", "^4.0.0", "^5.0.0"){  "found": true,  "verification_level": "medium",  "migration": {    "breaking_changes": [      {        "title": "maxTokens renamed to maxOutputTokens",        "before_code": "generateText({ model, maxTokens: 1024, prompt })",        "after_code":  "generateText({ model, maxOutputTokens: 1024, prompt })",        "source_url": "https://ai-sdk.dev/docs/migration-guides/migration-guide-5-0"      }      // …22 more, every one cited    ]  }}

Models improve every month. Their knowledge still ends on a date.

Every coding agent ships with a knowledge freeze date. The libraries it writes against don't.

So agents do what the training data taught them: they write maxTokens into AI SDK 5 (removed), synchronous params into Next.js 15 (now a Promise), LangChainAdapter imports from a package that no longer exports them. The code looks right. The agent is confident. The build breaks — or worse, it doesn't, and the bug ships.

Tools that fetch current documentation tell agents what the API looks like today. That's half the problem. An upgrade needs the diff: what changed, what replaced it, and what silently behaves differently. No amount of "current docs" contains that.

Asynthetic is that missing half. Ask it about an upgrade, and it returns a hand-curated migration map: ordered breaking changes with before/after code, deprecation timelines, peer-version requirements, and a citation for every claim. Retrieval, never generation — the same question gets the same verified answer every time.

Before / after

Without Asynthetic — the agent "upgrades" your AI SDK app from memory: keeps result.usage for billing (now silently counts only the final step), leaves temperature unset (v5 removed the implicit 0 — output turns nondeterministic), renames nothing because v4 syntax was correct when the model trained.

With Asynthetic — one tool call returns all 23 breaking changes for that exact version window, including the three above, each with the fix and the official source. The agent applies facts. You review a diff instead of debugging a regression.

That's the product: the difference between an agent that remembers and an agent that knows.

What a map gives your agent

Migration MapsHand-curated upgrade intelligence per version window: 40 breaking changes across 2 live maps (next 14→15, ai 4→5)
CitationsEvery map cites official sources and carries a last_verified date. Maps are never LLM-generated.
Verification LevelsEvery response self-reports confidence: high (empirically tested on real builds), medium, low — derived, never self-declared
Field NotesWhere reality diverges from docs, maps say so — e.g. Turbopack doesn't actually enforce the @next/font removal that Webpack does; Next 15's React 19 "requirement" isn't build-enforced. Found by running the upgrades, not reading about them.
SemVer ResolutionAsk with ranges (^14.2.0 → ^15.0.0); resolution method is always disclosed
Peer ChecksStatic compatibility answers (next@15 + [email protected] → false, with the cited reason)
Honest MissesNo data means found: false and an explicit instruction not to guess — never a plausible fabrication

The next 14→15 map is Asynthetic's first verification_level: high: every entry tested against real builds on 14.2.35 and 15.5.20, across Turbopack and Webpack, dev and production.

Install

Hosted (nothing to install):

sh
claude mcp add --transport http asynthetic https://asynthetic.up.railway.app/mcp

Local (offline, bundled data):

sh
claude mcp add asynthetic -- npx -y asynthetic

Any MCP client works — Cursor, Claude Code, Windsurf, or your own agent:

json
{ "mcpServers": { "asynthetic": { "url": "https://asynthetic.up.railway.app/mcp" } } }

Then upgrade something. The agent calls get_migration before it edits.

Tools

ToolAnswers
get_migration(package, from, to)"What breaks between these versions, and how do I fix each one?"
get_breaking_changes(package, version)"What does this version break?"
check_peer_compatibility(a, va, b, vb)"Do these two versions work together?" — true / false / unknown, cited
list_available_maps()"What does Asynthetic know?"

Full response shape, transports (Streamable HTTP + stdio + legacy SSE), and self-hosting: see docs below.

Why trust it

Asynthetic's founding rule: a wrong map is worse than no map. Everything follows from that.

  • Curated exclusively from official changelogs, migration guides, and releases — with the URL attached to every entry.
  • verified status is earned empirically, not editorially: real projects, both bundlers, dev and production, on pinned versions. The process regularly finds things the docs get wrong — those findings ship in the maps.
  • Confidence is machine-readable (verification_level, source_count, pre-release warnings), so agents can weigh answers instead of trusting blindly.
  • Unknown is a first-class answer. The server tells agents when it doesn't know and instructs them not to invent.

Narrow and deep, on purpose: fast-moving AI and JavaScript frameworks first, correctness over coverage always.

Self-hosting

sh
git clone https://github.com/asyntheticai/asynthetic.gitcd asynthetic && npm install && npm run build && npm start

Zero-config serves the bundled maps over stdio. Set PORT for HTTP mode (/mcp, legacy /sse, health at /). Set SUPABASE_URL + SUPABASE_ANON_KEY to serve from Postgres (schema/schema.sql, then npm run seed). Missing config never crashes — it falls back and says so on stderr.

data/maps/          the maps (source of truth, JSON, Zod-validated)src/server.ts       MCP toolssrc/store/          Postgres + local backends, SemVer resolverscripts/smoke.ts    23-check end-to-end suite across every transport

Contributing a map

  1. Official sources only. Changelogs, release notes, migration guides. Record every URL. Blog posts can start a hunt; they can't finish one.
  2. Follow the schema in src/types/migration-map.ts — validation rejects anything malformed before it can ever be served.
  3. New maps enter as draft. verified is earned by testing snippets on real builds of the pinned versions. Retired maps become stale — excluded from serving, kept as record.
  4. npm run smoke must pass. Don't guess versions or API names: if it's not in an official source, flag it in the PR instead.

Status

Free public beta — hosted endpoint and npm package open to everyone. Next: more maps (Tailwind 3→4, React 18→19, Zod 3→4, AI SDK 5→6), more high-verification promotions, project-aware compatibility analysis. Details will be announced.

Security

Read-only by construction: every tool is a lookup over curated data. No code execution, no request-time fetching, no access to your project or filesystem. The hosted endpoint sees only tool arguments (package names, version strings); sessions are ephemeral, in-memory, and isolated. Report issues via GitHub security advisories.

License

Source-available under BSL 1.1: self-hosting for your own use — personal, team, company-internal — is always permitted; reselling it as a competing hosted service isn't. Converts automatically to Apache 2.0 on July 4, 2030.

Built with TypeScript, the official MCP SDK, Zod, and Supabase. Serving live at asynthetic.up.railway.app/mcp.

Source: README.md at commit 844feff

Tools

0
SourceWeft has not read this server's tools yet.

Version history

1
  1. v0.1.3LatestSep 16, 2026

Score

75% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

    Declare a license in the repository or the registry entry.