Get started

Extentos is a smart-glasses development layer for native iOS and Android apps. The recommended way to get started is to install Extentos's MCP server in your AI coding agent and let the agent do the rest — it scaffolds the connection module, writes the AppSpec, generates handler stubs, and provisions a browser simulator session in one continuous flow. This page is the entry point: prerequisites, the recommended path, what to expect, and where to go after the first session is running.

At runtime, your installed agent has access to the entire MCP tool surface. Once @extentos/mcp-server is registered with your AI coding agent, the agent calls 18 deterministic tools (getPlatformInfo, generateConnectionModule, initSpec, validateIntegration, createSimulatorSession, etc.) plus searches the live documentation via searchDocs(topic: ...). This page exists for pre-install evaluation (so an AI agent or developer can see the path forward before installing) and for SEO / human-search retrieval. The agent's live MCP responses are authoritative once installed; this page is the static reference.

Prerequisites

Three things, all free, all fast:

Optional later — when you graduate from the simulator to real hardware:

• A Meta Developer Center account (free, ~15–30 minute setup) for Meta DAT credentials. See vendors/meta § Required setup.
• A paired Ray-Ban Meta variant (Gen 1, Gen 2, Display, or Oakley Meta HSTN). All variants work; see vendors/meta § Compatible models.

Not required to start:

• An Extentos account. The first 1000 browser-simulator events are anonymous; account linking is lazy and free email-only when it fires. See pricing.
• Real Ray-Ban Meta hardware. The browser simulator at extentos.com/s plus the on-device LocalSimTransport (which wraps Meta's Mock Device Kit) cover the bulk of the dev loop.

The recommended path: agent-driven

1. Install the MCP server in your agent          (one command)
2. Tell your agent what to build                 (one prompt)
3. Agent provisions browser simulator session    (one tool call)
4. Test your app's flow in the browser           (immediate)

Continue with the agent quickstart →

The agent-driven path covers everything the by-hand iOS / Android quickstarts would cover — your agent calls generateConnectionModule which writes the SwiftPM dependency or Gradle artifact, the Info.plist or AndroidManifest entries, the bootstrap module, and the empty AppSpec. You don't have to choose between iOS-by-hand and Android-by-hand; the agent handles whichever platform (or both) you point it at.

Why agent-driven is the recommended path

Five reasons, in order of impact:

1. Fewer steps. Install the MCP server once, then describe what you want in natural language. The agent translates to 5–7 tool calls and writes the right files.
2. Cross-platform reach in one session. Your agent (e.g., Claude Code in a terminal) can edit your iOS Swift files and your Android Kotlin files simultaneously. By-hand integration on both platforms means doing the wiring twice; agent-driven means once.
3. Permission derivation handled automatically. getPermissions returns the exact set of Android manifest entries and iOS Info.plist keys for your spec. You don't have to memorize that voice_command triggers need NSSpeechRecognitionUsageDescription. See concepts/permissions.
4. Validation before testing. validateIntegration checks correctness before runtime, so you find spec errors at compose time instead of staring at silent no-ops.
5. Live debugging through getEventLog. When something goes wrong, your agent queries the structured 7-layer event log directly and tells you which layer failed. The by-hand path means reading raw Logcat / os_log output yourself.

Alternative paths (currently deferred)

Two pages are planned but not yet written:

In both cases, the agent-driven path produces the same outcome — same files generated, same permissions derived, same simulator session — without you needing to do the wiring by hand. If you specifically want to integrate without an AI agent, the MCP server install and vendors/meta § Required setup cover the per-platform requirements; those pages are accurate today even though the dedicated by-hand quickstarts are pending.

What success looks like at the end of the quickstart

When the first session is running, you'll have:

• The Extentos MCP server installed and visible in your agent's tool list (run /mcp in Claude Code to verify)
• The Extentos library wired into your iOS or Android app via generateConnectionModule — Info.plist keys, AndroidManifest permissions, dependency declarations all in place
• An AppSpec with at least one trigger (e.g., voice_command "describe this") and one block (capture_photo)
• A browser simulator session open at extentos.com/s/<sessionId> showing the wearer-perspective view, with your webcam feeding the camera and your microphone driving voice triggers
• validateIntegration returning ✓ before runtime
• Either auto-bind already attached (zero rebuild) or the URL-bake snippet pasted into your project (one rebuild)

End-to-end timing: 5–10 minutes if you're following along with an agent, faster on subsequent runs as npx cache hits and your agent learns the project shape.

After the quickstart

Once you have a working session, the next stops:

Common gotchas

A few things that trip up first-time installs:

• /mcp in Claude Code doesn't list extentos. Quit Claude Code completely (Cmd+Q on macOS, full exit on Windows) and reopen. The MCP host loads servers at startup; closing the window isn't enough.
• Node.js too old. Run node -v. Anything below 20 fails with Unsupported engine. Update from nodejs.org.
• First tool call is slow. Normal — npx is fetching @extentos/mcp-server on first run. Subsequent calls hit the cache and are instant.
• createSimulatorSession returns auth_required immediately. You've used the 1000 anonymous events on this install. The response includes a verification URL — sign up with email (no payment), and the agent retries automatically. See auth.
• Browser auto-open didn't happen. Some hosts (headless / SSH / sandboxed) can't auto-open. The simulator URL is always in the agent's response — copy it to your browser manually. See supported agents § Browser auto-open behavior.

For deeper troubleshooting, see install § Troubleshooting.

Frequently asked questions

How long does the quickstart take?

5–10 minutes for the first run. Subsequent runs are faster as npx caches and your agent learns the project layout. The bottleneck is usually whatever you ask the agent to build — adding "voice trigger that captures a photo and speaks the result" is faster than "voice trigger with branching AI logic and a custom video stream pipeline."

Do I need an Extentos account to start?

No. All MCP tools and on-device simulation are free forever, no account. The first 1000 browser-simulator events are also anonymous; only after that do you need a free email-only account. See pricing.

Do I need real Ray-Ban Meta glasses to start?

No. The browser simulator at extentos.com/s and the on-device LocalSimTransport cover the bulk of the dev loop. Real hardware verifies final-mile fit (camera fidelity, BT latency, real-world audio coexistence) but isn't required for daily iteration. See transport vs app simulation.

Can I start with iOS or Android only and add the other later?

Yes. The AppSpec is vendor-agnostic and platform-agnostic — your spec doesn't change based on whether you target iOS first, Android first, or both simultaneously. generateConnectionModule takes a platform parameter; call it once per platform.

What if I'm not using one of the listed AI coding agents?

Any MCP-compatible agent works — Extentos uses the standard MCP protocol over stdio. The verified hosts (Claude Code, Cursor, Windsurf, Cline) just have the most polished install experience. Generic MCP host setup is in install § Generic MCP host.

Can I integrate Extentos without an AI agent at all?

Technically yes — the Android and iOS libraries are source-available and can be linked directly via Gradle / SPM, and the MCP server's tool responses are JSON that you could call from any HTTP client. But the path is much rougher today (the dedicated by-hand quickstarts are deferred), and the productivity wins of agent-driven generation are large. The recommended approach is to use any MCP-capable agent for the initial integration and graduate to direct manipulation if you need it later.

Related

• Quickstart with an AI agent — the full step-by-step
• MCP server install — per-host install commands and config
• Supported agents — Claude Code / Cursor / Windsurf / Cline capability differences
• Concepts: transport vs app simulation — the core differentiator framing
• Vendors: Meta Ray-Ban — currently GA target, all variants supported
• Pricing — free for development, no paid tier at launch