Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@peeko Take a screenshot of the iPhone simulator and tell me if the button alignment looks correct."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Let Claude see your mobile app. Peeko is an MCP server that hands Claude screenshots of your iOS Simulator, Android emulator, or a physical Android device plugged into USB.
It is deliberately read-only. Peeko observes; it never taps, swipes, or types. Claude can look at what your app is rendering and reason about it — a layout that broke, a state you can't reproduce in words, a diff between what you meant and what shipped — without ever touching the device.
You: Why does the login screen look wrong on the iPhone 16?
Claude: [screenshot_ios] The "Continue" button is clipped — its container has a
fixed height of 44pt but the text wraps to two lines at this width.Platform | iOS Simulators | Android devices & emulators |
macOS | ✅ Xcode required | ✅ |
Linux | ❌ not possible | ✅ |
Windows | ❌ not possible | ✅ |
iOS support is macOS-only, and always will be: it relies on xcrun simctl, which ships with Xcode and does not exist on other operating systems. On Linux and Windows the three iOS tools return a clear error and the Android tools work normally.
Node.js 18 or later is required.
Installing the prerequisites
Xcode command line tools (macOS, for iOS): xcode-select --install
Android platform tools (all platforms, for Android):
macOS — brew install --cask android-platform-tools
Linux — apt install android-tools-adb (or your distribution's equivalent)
Windows — winget install Google.PlatformTools
Make sure adb ends up on your PATH. Peeko tells you so explicitly if it doesn't.
Related MCP server: macOS Simulator MCP Server
add-mcp detects the agents installed on your machine and writes the right config for each one:
npx add-mcp peeko@latestAdd -g to install globally rather than for the current project, and -a to target specific agents — claude-code, claude-desktop, codex, cursor, gemini-cli, goose, opencode, vscode, zed.
As a plugin, which needs no MCP configuration at all:
claude plugin marketplace add rocktane/peeko
claude plugin install peeko@peekoOr as a plain MCP server:
claude mcp add peeko -- npx -y peeko@latestcodex mcp add peeko -- npx -y peeko@latestopencode is configured by file only. In opencode.json:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"peeko": {
"type": "local",
"command": ["npx", "-y", "peeko@latest"],
"enabled": true
}
}
}Add this to your client's MCP configuration:
{
"mcpServers": {
"peeko": {
"command": "npx",
"args": ["-y", "peeko@latest"]
}
}
}Tool | What it does |
| Lists every booted iOS Simulator, with its UDID. |
| Returns a PNG of a Simulator's screen. |
| Name, OS version and screen size of a Simulator. |
| Lists every connected Android device and emulator. |
| Returns a PNG of a device's screen. |
| Name, OS version and screen size of a device. |
Every tool takes an optional device_id — a Simulator UDID on iOS, a device serial on Android. Omit it and Peeko picks the first available device, which is what you want when only one is running.
Boot a simulator or emulator, then just ask:
Take a screenshot of the simulator and tell me if the spacing looks right.
Compare the Android and iOS home screens side by side.
The list is empty on Android but not on iOS — screenshot both and tell me what differs.
Screenshots are sent to the model, exactly like any other tool result. Whatever is on the device screen goes with them — test accounts, tokens in a debug overlay, a customer's real data if you are pointed at production. Peeko cannot tell the difference. Check what's on screen before you ask for a capture.
Peeko never writes to the device, never installs anything on it, and never sends data anywhere other than the MCP client that invoked it.
Peeko is written in TypeScript. It runs on Node in production, and uses Bun as the dev runtime and test runner.
bun install
bun test # unit tests on the parsers
bun run typecheck # tsc --noEmit
bun run build # tsc → dist/
bun run start # run the server from source over stdioThe repo ships a .mcp.json that points at src/index.ts, so opening it in Claude Code gives you the server you're editing, live.
Layout
src/
index.ts MCP server: tool registration and stdio transport
tools/ one handler per tool; formats MCP results
platforms/
ios.ts xcrun simctl
android.ts adb
exec.ts subprocess helper; turns ENOENT into actionable errors
png.ts reads dimensions from a PNG's IHDR chunk
test/
parsers.test.ts covers the pure parsing functionsThe device-facing code shells out to xcrun and adb, so it can't be unit-tested without hardware. The parsers it depends on are pure functions and are tested directly — including CRLF handling, which is what makes Android work on Windows.
Issues and pull requests are welcome. Please run bun test and bun run typecheck before opening a PR; CI runs both on Linux, macOS and Windows.
MIT © Yohan (@rocktane)
Get detailed info about an Android device/emulator (name, OS version, screen size)
| Name | Required | Description | Default |
|---|---|---|---|
| device_id | No | Device serial (defaults to first connected device) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. Description states it returns detailed info but lacks details on read-only nature, output format, prerequisites (e.g., device connection), or error conditions. Adequate but minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no waste. Action and resource front-loaded. Brief and to the point.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Simple tool with one optional parameter. Description gives purpose and sample output fields but lacks output schema or return format details. Adequate for simplicity but could be more complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema covers 100% of parameters with description. Description adds no additional parameter context beyond the schema. Baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it gets detailed info about an Android device/emulator and lists example fields (name, OS version, screen size). Distinguishes from siblings: info_ios is for iOS, list tools list devices.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implied usage (when you need device details) but no explicit when-to-use or when-not-to-use. No mention of alternatives like list_android_emulators for obtaining device IDs first.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed info about an iOS Simulator (name, OS version, screen size). (macOS only)
| Name | Required | Description | Default |
|---|---|---|---|
| device_id | No | Simulator UDID (defaults to first booted simulator) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the tool is read-only (get info) and platform-specific (macOS). However, it does not mention error conditions, permission requirements, or the return format structure, leaving some behavioral uncertainty.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the purpose and includes key constraints. Every part contributes value, with no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one optional param, no output schema, no annotations), the description covers purpose, platform, and return content. It could be more complete by listing expected return fields, but is adequate for an agent to understand usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with a single optional parameter 'device_id'. The description adds value by noting it defaults to the first booted simulator, which is not in the schema. This clarifies behavior beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves detailed info about an iOS Simulator, listing specific details (name, OS version, screen size). It distinguishes itself from sibling tools like 'list_ios_simulators' (which lists all simulators) and 'info_android' (Android counterpart).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions 'macOS only,' which is a key usage constraint. However, it does not provide explicit guidance on when to use this tool versus alternatives (e.g., when needing a list vs. details on a specific simulator). No exclusion scenarios are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all connected Android devices and emulators
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and description does not disclose behavioral traits such as read-only nature, permission requirements, or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no wasted words, perfectly concise and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Simple tool, but lacks description of return format or behavior; could be improved with minimal extra context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so description adds no parameter meaning but meets baseline for zero-param tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'List all connected Android devices and emulators', using specific verb and resource, and distinguishes from sibling tools like list_ios_simulators.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives; missing context on prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all booted iOS Simulators (macOS only)
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. Description indicates a harmless list operation but does not disclose output format, error conditions, or dependencies like Xcode. Minimal but adequate for a simple read tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with key information, no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter list tool, the description covers purpose and platform constraint. Lacks details on output, but sufficient for the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters in schema, schema coverage 100%. Description does not need to add parameter details. Baseline of 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states verb 'List', resource 'booted iOS Simulators', and platform constraint 'macOS only'. It distinguishes from sibling tools like list_android_emulators and screenshot_ios.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly mentions macOS-only operation, providing clear context for when to use. No explicit when-not or alternatives, but siblings are different platforms/functions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Take a screenshot of an Android device/emulator screen. Returns a PNG image.
| Name | Required | Description | Default |
|---|---|---|---|
| device_id | No | Device serial (defaults to first connected device) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description should disclose behaviors. It only states the action and return type, omitting details like required connection, potential blocking, or side effects. This is minimal transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no unnecessary words. Every part contributes to understanding the tool's core function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema, the description is adequate but minimal. It doesn't mention error conditions, device requirements, or output format details beyond 'PNG image'. Sufficient for basic use but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single parameter, with a clear description in the schema. The tool description adds no extra value beyond what the schema already provides, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (take a screenshot) and the target (Android device/emulator), implicitly distinguishing from screenshot_ios by platform. It lacks explicit differentiation but is specific enough.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like screenshot_ios or info tools. No mentions of prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Take a screenshot of an iOS Simulator screen. Returns a PNG image. (macOS only)
| Name | Required | Description | Default |
|---|---|---|---|
| device_id | No | Simulator UDID (defaults to first booted simulator) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the return format (PNG) and OS restriction (macOS only), but does not disclose error handling (e.g., if no simulator is booted) or prerequisites (simulator must be booted). Basic transparency is present but gaps remain.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: one sentence covering action, target, return type, and platform constraint. No unnecessary words or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter and no output schema, the description covers the core purpose, output, and platform. However, it lacks error behavior hints or guidance on retrieving device_id (e.g., via list_ios_simulators), which would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides a description for the only parameter (device_id) with a default explanation. The tool description adds no additional semantic value beyond what the schema offers. With 100% schema coverage, baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (take a screenshot), the target (iOS Simulator screen), and the output (PNG image). The sibling tool screenshot_android is for Android, making this tool's purpose distinct.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions 'macOS only', implying a system constraint, but does not explicitly advise when to use this tool versus alternatives like screenshot_android or list_ios_simulators. Usage context is implied but not fully elaborated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0info_androidinfo_ioslist_android_emulatorslist_ios_simulatorsscreenshot_androidscreenshot_iosScored across 6 tools
Each tool targets a specific platform (Android or iOS) and action (info, list, screenshot), with no overlap or ambiguity.
All tools follow a consistent pattern: <action>_<platform> (e.g., info_android, list_ios_simulators), using lowercase with underscores.
Six tools cover the core operations for two platforms (listing, info, screenshots) without excess or deficiency.
The tool surface is complete for the stated purpose of retrieving device/simulator info, listing, and screenshots; no obvious gaps.
Pocket Agent (aipocketagent.com) MCP server — read tools for personas, apps, and product info.
MCP server for Appcircle mobile CI/CD platform.
MCP server for building and testing AI agents with multi-model experimentation and insights.
An MCP server that provides read access to your cloud storage providers, bank accounts and more.
