---
title: Get started
description: Start building with Extentos, the smart-glasses dev layer for Meta Ray-Ban. The recommended path is agent-driven — install the MCP server, it scaffolds the app.
type: tutorial
platform: all
related:
  - /docs/getting-started/with-agent
  - /docs/concepts/transport-vs-app
  - /docs/concepts/architecture
  - /docs/mcp-server/install
  - /docs/vendors/meta
  - /docs/resources/pricing
---

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: ...)`](/docs/mcp-server/tools/search). 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:

| Requirement | Why | How to get it |
|---|---|---|
| **Node.js 20 or newer** | The MCP server runs as an `npx` subprocess of your agent | [nodejs.org](https://nodejs.org). Verify with `node -v`. |
| **An MCP-compatible AI coding agent** | Operates the Extentos tools on your behalf | Claude Code (terminal CLI), Cursor, Windsurf, or Cline are the verified hosts. See [supported agents](/docs/mcp-server/agents) for capability differences and IDE-portability details. |
| **A native mobile project** (iOS Swift / Android Kotlin) | Extentos generates code into your existing app | An empty SwiftUI or Compose app works fine for a smoke test. |

**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](/docs/vendors/meta#required-setup-for-development).
- A paired Ray-Ban Meta variant (Gen 1, Gen 2, Display, or Oakley Meta HSTN). All variants work; see [vendors/meta § Compatible models](/docs/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](https://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](/docs/resources/pricing).
- Real Ray-Ban Meta hardware. The browser simulator at [extentos.com/s](https://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

```text
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 →](/docs/getting-started/choose-your-path)** — voice apps need no vendor setup at all; camera and display do. Then **[continue with the agent quickstart →](/docs/getting-started/with-agent)**.

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](/docs/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:

| Path | Status | Notes |
|---|---|---|
| [Android quickstart](/docs/getting-started/android) | ✅ Published | The by-hand Gradle path — install, manifest, init, first capability call |
| [iOS quickstart](/docs/getting-started/ios) | ✅ Published | The by-hand SwiftPM path — installs from `github.com/extentos/swift-glasses` (SwiftPM `from: "2.0.0"`), version-locked to the Android release line |

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](/docs/mcp-server/install) and [vendors/meta § Required setup](/docs/vendors/meta#required-setup-for-development) 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](/docs/guides/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:

| Goal | Read |
|---|---|
| Understand how Extentos differs from Meta's Mock Device Kit | [Transport vs app simulation](/docs/concepts/transport-vs-app) — the core differentiator framing |
| Understand the system architecture | [Architecture](/docs/concepts/architecture) — agent / MCP / library / backend / simulator stack |
| Learn what the SDK exposes | [Capabilities](/docs/concepts/capabilities) — audio / camera / hardware-event primitives and how handlers subscribe to them |
| See the Meta Ray-Ban capability matrix | [Vendors: Meta Ray-Ban](/docs/vendors/meta) — what's supported, what's preview, distribution state |
| Browse the MCP tool catalog | [MCP server overview](/docs/mcp-server) |
| Test on real Ray-Ban Meta hardware | [Vendors: Meta Ray-Ban § Required setup](/docs/vendors/meta#required-setup-for-development) — Meta Wearables Developer Center registration, Bluetooth pairing |

## 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](https://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](/docs/mcp-server/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](/docs/mcp-server/agents#2-browser-auto-open-behavior).

For deeper troubleshooting, see [install § Troubleshooting](/docs/mcp-server/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](/docs/getting-started/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](/docs/resources/pricing).

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

No. The browser simulator at [extentos.com/s](https://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](/docs/concepts/transport-vs-app).

### 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](/docs/sdk/ios). `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](/docs/mcp-server/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](/docs/getting-started/with-agent)** — the full step-by-step
- **[MCP server install](/docs/mcp-server/install)** — per-host install commands and config
- **[Supported agents](/docs/mcp-server/agents)** — Claude Code / Cursor / Windsurf / Cline capability differences
- **[Concepts: transport vs app simulation](/docs/concepts/transport-vs-app)** — the core differentiator framing
- **[Vendors: Meta Ray-Ban](/docs/vendors/meta)** — the production target, all variants supported
- **[Pricing](/docs/resources/pricing)** — free for development; the managed AI gateway is metered