Shuttle: Android MCP for TransactionTooLarge
Shuttle
An MCP server for the Shuttle Android framework: integration scaffolding, detection of TransactionTooLargeException risk and specs
- 87 ★ on the repository
- Last commit
- MIT
Minimal access
Why this level
- The server only generates code and answers from specs and calls no external services
- Generated Kotlin code should be reviewed by hand before it goes into the project
Install
- Works in
Manual install
Open the Shuttle repository in an editor where the server connects automatically, or add the entry from `mcp/README.md`. Call `scaffold_integration` to integrate and `detect_risk` to check code. Take the rules from `get_spec` and invent nothing.
Access and checks
How we reviewMinimal accessThe tool runs nothing and makes no network calls.
- The server only generates code and answers from specs and calls no external services
- Generated Kotlin code should be reviewed by hand before it goes into the project
This is third-party code. Review the repository files before installing.
What it does
Shuttle is an Android framework that transports large Serializable objects between app components without `TransactionTooLargeException` crashes. Objects do not travel through Intent and Bundle, so exceeding the Binder transaction limit does not break the app. This project's MCP server gives an agent knowledge of the framework right in the editor. The `scaffold_integration` tool generates ready Kotlin code for Hilt, Koin or manual wiring. `detect_risk` analyzes a Kotlin or Java snippet and finds patterns where large data may exceed the limit. `get_spec` returns the Shuttle spec by topic: `core`, `setup`, `transport`, `pickup`, `cleanup`, `annotations`. The server is published in the MCP registry and ships as a Docker image from GHCR, so you do not need to clone the repository. When you open the repo the server connects itself in VS Code, Cursor, Zed, Android Studio and Claude Code, while Claude Desktop and Windsurf need a one-time setup.
Who it is for. Android developers on Kotlin and Java who pass large objects between screens and want an agent to help integrate Shuttle.
Good fit when
- `TransactionTooLargeException` crashes in production and you need to find where else it threatens
- You want to wire Shuttle through Hilt or Koin from a ready template
- A team wants identical integration guidance for every developer across editors
- An agent should answer from the framework spec with no guessing
Not a fit when
- The project is not on Android: the framework and server target the Android platform only
- Your app does not pass large objects between components: Shuttle solves that task
- You need help with other libraries: the server knows only Shuttle
Example request
Scaffold a Hilt integration of Shuttle for com.example.myapp and check my order screen for `TransactionTooLargeException` threats.MCP
- Transport
- stdio
- Authentication
- not required
Limitations
The server answers only about the Shuttle framework and does not replace general project analysis. Running from the repository needs Java 21 and the built `mcp/build/libs/shuttle-mcp.jar`, produced by `./gradlew :mcp:shadowJar` and rebuilt after every source change.
The server must be launched from the repository root so it can find the spec files under `openspec/specs`. Editors without working directory support, such as Android Studio and the Claude Code CLI, require launching the host from the root. The framework's minimum Android API level is 26.
How to disable. Remove the `shuttle` entry from `.mcp.json` or the editor config. An automatically connected server disappears when you remove the config file from the repository.
FAQ
What does Shuttle do in an Android app?
It transports large Serializable objects between components without exceeding the Binder transaction limit, so `TransactionTooLargeException` does not crash production.
Which tools does the Shuttle MCP server have?
Three: `scaffold_integration`, `detect_risk` and `get_spec`.
Which editors connect the server automatically?
VS Code with Copilot, Cursor, Zed, Android Studio with JetBrains AI and the Claude Code CLI when you open the repository. Claude Desktop and Windsurf need a one-time setup.
Do I need to clone the repository?
No. The server is published in the MCP registry and runs as a Docker image from GHCR.
Which languages does `detect_risk` analyze?
The tool analyzes Kotlin or Java snippets for patterns that raise the chance of exceeding the transaction limit.
Discussion
No questions or reviews yet.
Related
MCP serversGradle MCP server for agents: project map, task runs, tests, dependency audit, source search and a Kotlin REPL
A command-line debugger for MCP servers from Giant Swarm: a REPL for tools, OAuth 2.1 and an MCP server mode for Cursor
A plugin with skills for building TypeScript MCP servers and MCP apps: the agent scaffolds, edits, debugs and verifies them
An MCP server that builds a code graph once and serves the answer to the agent instead of re-reading files
A Cocos Creator 2.4.x plugin with a local server so an agent edits scenes, prefabs and assets and builds the project over MCP
A debugger with no IDE: an agent sets breakpoints, steps through code and inspects variables in ten languages
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| Shuttle: Android MCP for TransactionTooLarge (this card) | yes | not required | 87 | |
| kotlin-agent-skills | no | 1,119 | general Kotlin rules for an agent with no tie to one framework | |
| Android skills | yes | 10,490 | general skills for Android development |
README in short
The README covers the framework's task, how it works, requirements, a quick start and transport examples with Intent and the Navigation Component. Separate sections cover architecture, demo apps and tradeoffs. The AI section describes the MCP server, and a separate `mcp/README.md` lists editors and verification steps.