How Crunchtime runs Canvas LMS MCP autonomously — research, code, and release with Paperclip agents

Fjordbyte's Canvas LMS MCP server — a TypeScript library giving AI agents structured access to the Canvas LMS API — is maintained by a team of Paperclip agents. A CTO agent scans competitors weekly and delivers a structured gap analysis to Notion. Developer agents implement the prioritized features. A QA agent verifies and approves releases. The result: 30 releases shipped since open-source launch — with 104 tools across multiple Canvas API domains — with Christian Bru co-authoring code alongside Paperclip agents.

This isn't an aspiration. It's a verifiable state you can check in the GitHub release log right now.

The problem: open-source maintenance takes time most teams don't have

Open-source tools rarely die for technical reasons. They die from neglect: a busy developer, accumulating backlog, competitors shipping faster.

Canvas LMS powers learning for over 30 million educators and learners at 6,000+ institutions globally. That means the category "Canvas API tooling for AI agents" will be in demand for years — and competition has already started.

A GitHub search for "canvas lms mcp" in May 2026 returns at least ten active repositories. The leading competitor, vishalsachdev/canvas-mcp (Python), grew from 96 to 125 stars between April and early May 2026 — including 22 new stars in under two weeks in April — while most competitors stood still. DMontgomery40/mcp-canvas-lms (TypeScript), long a strong second at 94 stars, had been inactive for 5+ weeks as of 2026-05-01.

In a category growing faster than most maintainers can follow manually, the pace you can sustain determines who owns it.

What Crunchtime built for Fjordbyte

The solution was to connect Canvas LMS MCP to a team of four Paperclip agents with clearly separated responsibilities.

1. CTO agent — weekly product research

The CTO agent runs on a fixed schedule and delivers a structured Notion page with:

• Competitor state: stars, forks, new releases, new features since the previous run
• Gap analysis: which Canvas API domains are missing, estimated effort per gap
• Ranked recommendations with impact and effort ratings

The documented output from the 2026-05-01 run is here: Canvas LMS MCP — Product Research 2026-05-01.

The key finding from that run: the biggest adoption barrier wasn't missing tools — Canvas LMS MCP already had 104, vs the competitor's 91. The gap was setup friction. vishalsachdev's CLI wizard (canvas-mcp npm package, shipped in v1.2.0, April 2026) reduces installation to one command across multiple popular MCP clients including Claude Desktop, Cursor, Codex, and Windsurf. Canvas LMS MCP still required manual JSON editing.

That's exactly the kind of insight that reads well in a Notion doc — but gets buried in a busy daily schedule if you don't have an agent surfacing it for you.

2. Task generation — from gap to Paperclip board

CTO agent recommendations are converted to Paperclip issues automatically. From the 2026-05-01 cycle, three tasks were created under BRU-782:

• CLI setup wizard (npx canvas-lms-mcp init) — HIGH priority
• get_course_structure aggregate tool — MEDIUM priority
• outcomes domain — MEDIUM priority

No manual task assignment. The entire path from "we're behind on ergonomics" to "this is the next sprint" happens without a human in the middle.

3. Developer agent — implementation to PR

The developer agent picks up tasks from the board, implements, and opens pull requests. v1.9.0 (2026-04-27) with the download_file tool (PR #92) is an example of a release that went through this loop with minimal manual involvement.

4. QA agent — typecheck, tests, release

The QA agent runs the typecheck, test suite, and verifies that the schema for exported tools is backwards-compatible. Releases are tagged and pushed only after approval.

Verifiable numbers from 2026-05-01

All numbers are verifiable from GitHub and the linked Notion research page.

Why TypeScript — and why it matters

The leading competitor is built in Python. Canvas LMS MCP is TypeScript-native — a deliberate choice with practical consequences for users in 2026.

Model Context Protocol is itself built and maintained with the TypeScript SDK as the primary language. That means Canvas LMS MCP tool schemas are derived directly from TypeScript types — not retrofitted documentation. HTTP transport with per-request authentication — a feature vishalsachdev only shipped in April 2026 — has been supported in Canvas LMS MCP from the start.

With DMontgomery40 inactive, there's now a vacuum of actively maintained TypeScript alternatives. Users who want a well-maintained TypeScript Canvas MCP library effectively have one real choice.

MCP as a category: the protocol making AI agents useful

Model Context Protocol was launched by Anthropic in November 2024 as a standardized interface for connecting AI agents to external APIs and tools. In the months after launch, community contributions grew from nothing to thousands of MCP server implementations.

Canvas LMS is one of the clearest target categories: a well-defined REST API, a large and loyal user base (institutions don't switch LMS platforms every year), and a genuine need — AI agents that can navigate courses, assignments, and grades without manual input.

Owning the TypeScript implementation in this category, actively maintained with more tools than competitors, is a position that's hard to overtake — especially if the second-largest TypeScript competitor remains inactive.

What to expect from the same pattern

The pattern Crunchtime uses for Canvas LMS MCP generalizes to any technical product that needs continuous maintenance:

• An external API surface or competitor landscape that changes over time
• A need for regular releases based on prioritized features
• A desire for auditable documentation of what was prioritized and why

What it requires: a clear product definition, Paperclip agent setup with the four roles, and GitHub integration. First configuration takes time. After that, it scales autonomously.

Realistic expectation: two to four hours saved per week for an active open-source project, and a noticeably higher release cadence — because research and implementation no longer wait for a free afternoon to materialize. Since the loop is Notion-documented and Paperclip-tracked, you can always go back and see exactly what the CTO agent found, what was prioritized, and why.

How we'd build this for you

Crunchtime builds and configures agent workflows like the one described above — adapted to your stack, your Notion and GitHub setup, and your goals.

Have a technical product that needs maintenance? An internal platform with a growing backlog? An open-source library you want to keep active in a competitive category?

The first step is a Discovery Sprint: 3–5 days where we map the workflows, identify what can be agentified, and deliver a running proof of concept. No abstract promises — just concrete outputs you can verify.

Book a Discovery Sprint →

Sources

• bruchris/canvas-lms-mcp — GitHub repository and release history — https://github.com/bruchris/canvas-lms-mcp — 2026-05-08
• Crunchtime — Canvas LMS MCP Product Research 2026-05-01 (Notion) — Untitled — 2026-05-01
• vishalsachdev/canvas-mcp — GitHub repository — https://github.com/vishalsachdev/canvas-mcp — 2026-04-10
• Instructure — Canvas platform overview — https://www.instructure.com/canvas — 2024
• Anthropic — Model Context Protocol — https://modelcontextprotocol.io — 2024