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:

Only if you need camera or display — voice apps never need these:

• A Meta Wearables 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 the discovery / validation / guidance MCP tools, on-device LocalSimTransport simulation, or real-hardware testing — all free, no signup. Two surfaces link a free email-only account: the browser simulator at extentos.com/s (session minting) and generateConnectionModule's scaffold step (it mints your account-bound project key); 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 (Extentos's in-memory local sim) 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)

First, choose your path → — voice apps need no vendor setup at all; camera and display do. Then 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 integration manifest. 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 / display / ai / lifecycle / custom to narrow to a single subsystem. The by-hand path means reading raw Logcat / os_log output yourself.

Alternative paths: by-hand integration

Per-platform quickstarts:

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.

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. (For a full voice assistant where the model owns wake / turn-taking / intent, the Phase-4 glasses.assistant.start { … } runtime is the canonical path — see voice assistant.)
• 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 Meta credentials to build a voice app?

No. Smart glasses expose a standard Bluetooth hands-free microphone and speaker to the phone, and Extentos reaches them through the operating system's own audio routing — no vendor SDK in the path. A voice assistant, dictation app, translator or coach needs no Meta Developer account, no App ID or Client Token, and no connection page. Only camera and display require vendor setup. See choose your path.

Do I need an Extentos account to start?

Three surfaces need the free account — createSimulatorSession (browser-simulator minting), generateConnectionModule's scaffold step (the account-bound project-key mint), and the account-scoped project tools (assistant config, credentials, connection-page writes, analytics). Discovery, validation, guidance, search, on-device simulation, and real-hardware testing are free forever with no account. The first gated 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 designed to be identical on both platforms — same primitives (audio.transcriptions, camera.capturePhoto, audio.speak, …), same Result-type return shapes, same connection-state model — so handler logic ports closely between Kotlin and Swift. In practice today, Android is the longer-proven path on real hardware (published to Maven Central); iOS ships the same surface as a Swift package from github.com/extentos/swift-glasses — see the iOS SDK. 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 published Android package (Maven Central) can be linked directly via Gradle and the published iOS package via SwiftPM, and the MCP server's tool responses are JSON that you could call from any HTTP client. But the path is rougher, 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 — the production target, all variants supported
• Pricing — free for development; the managed AI gateway is metered

Related