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 handler classes against the capability primitives, 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 deterministic tools — getPlatformInfo for the capability catalog, getCapabilityGuide(feature) for per-feature call shapes, getCodeExample(pattern) for canonical Kotlin/Swift compositions, generateConnectionModule for the scaffold, validateIntegration for the correctness gate, createSimulatorSession for browser-hosted hardware — 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 for MCP tools, code generation, on-device LocalSimTransport simulation, or real-hardware testing — all free, no signup. The browser simulator at extentos.com/s is the one surface that needs a free email-only account to mint sessions; the device-code flow fires the first time createSimulatorSession runs. 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 capability list. You don't have to memorize that subscribing to transcription_incremental needs NSSpeechRecognitionUsageDescription. See concepts/permissions.
4. Validation before testing. validateIntegration checks structural correctness (dependencies declared, bootstrap wired, permissions cover the declared capabilities) before runtime, so you find integration 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 event log directly and tells you which chip the failure landed in — errors for everything that failed (regardless of modality), or voice / camera / ai / lifecycle / custom to narrow to a single subsystem. 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
• A handler class (yours, e.g., CoachHandler) that subscribes to capability primitives — typically glasses.audio.transcriptions() for a wake phrase, glasses.audio.recordDiscrete() for the user's question, then glasses.audio.speak() for the response
• 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 transcripts
• 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. Expected on the first run — the browser simulator needs a free email-only account. The response includes a verification URL — sign up (Google or email + password, 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?

Only for the browser simulator. Every MCP tool, code generation, on-device simulation, and real-hardware testing is free forever with no account. The first createSimulatorSession call triggers a free email-only account link (Google or email + password — no payment, no card); after linking, sessions are unlimited. 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 SDK surface is identical on both platforms — same primitives (audio.transcriptions, camera.capturePhoto, audio.speak, …), same Result-type return shapes, same connection-state model. generateConnectionModule takes a platform parameter; call it once per platform. Your handler logic ports near-verbatim between Kotlin and Swift.

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