From account to your first evidence-grounded Ask.

1. Create a Public Beta workspace

Sign up, open the dashboard, and create a scoped API key. The API-key secret is shown only when created or rotated.

2. Connect your MCP client

MCP endpoint:
https://api.ayneye.com/mcp

Authentication:
Authorization: Bearer YOUR_AYNEYE_API_KEY

Use your client's remote HTTP MCP configuration and keep the Bearer credential outside prompts, source code, screenshots, and logs.

Claude Code project setup

A tested Claude Code project configuration uses remote HTTP MCP with the Ayneye endpoint and keeps the API key in the AYNEYE_API_KEY environment variable.

{
  "mcpServers": {
    "ayneye": {
      "type": "http",
      "url": "https://api.ayneye.com/mcp",
      "headers": {
        "Authorization": "Bearer ${AYNEYE_API_KEY}"
      }
    }
  }
}

Save this as .mcp.json in the project directory. Do not replace ${AYNEYE_API_KEY} with a literal API key in source control.

read -s -p "Ayneye API key: " AYNEYE_API_KEY
echo
export AYNEYE_API_KEY

claude mcp list

The Ayneye entry should report Connected. If the server is disconnected, confirm that AYNEYE_API_KEY is exported in the shell that launches Claude Code and that the endpoint is exactly https://api.ayneye.com/mcp.

3. Discover the tools

ayneye.create_video
ayneye.upload_video
ayneye.get_video_status
ayneye.get_video_artifacts
ayneye.ask_video
ayneye.start_live
ayneye.get_live_state
ayneye.stop_live

Live camera workflow

For an authorized network-reachable live source, the agent uses the same frozen MCP contract. There is no separate ask_live tool. Ayneye Public Beta accepts HLS and authorized RTSP camera URLs through ayneye.create_video.

ayneye.create_video({
  "source_url": "rtsp://camera.example/live",
  "title": "Authorized camera",
  "auto_process": false,
  "capture_seconds": 10
})
→ ayneye.start_live
→ ayneye.get_live_state
→ ayneye.ask_video
→ ayneye.stop_live

A webcam attached directly to the developer's computer is not itself a network URL that the remote Ayneye service can open. Publish that webcam as a network-reachable RTSP or HLS stream first, then pass that URL to ayneye.create_video. Do not expose camera credentials in prompts, logs, screenshots, or example configuration.

Live processing remains bounded to a maximum of 60 seconds per session, and Ask is grounded in evidence accumulated by that session.

Tool input contract

For ayneye.create_video, capture_seconds is optional, defaults to 10, accepts 1 through 60, and cannot exceed the 60-second Public Beta processing maximum.

URL workflow

ayneye.create_video
{{
  "source_url": "https://example.com/video-or-stream.m3u8",
  "capture_seconds": 10
}}

ayneye.get_video_status
{{
  "video_id": "vid_..."
}}

ayneye.get_video_artifacts
{{
  "video_id": "vid_..."
}}

ayneye.ask_video
{{
  "video_id": "vid_...",
  "question": "What happened in this video?"
}}

These blocks show Ayneye tool arguments, not client-specific configuration syntax. Your MCP client discovers the schemas from the live server.

4. Analyze a URL or HLS source

Give the agent a natural task and source URL. The agent may choose a capture window between 1 and 60 seconds. The Public Beta hard maximum is 60 seconds per processing session; the schema default is 10 seconds.

5. Ask from evidence

After processing and evidence readiness, use ayneye.ask_video. If evidence is not ready, the public MCP contract returns evidence_not_ready instead of inventing a visual claim.

6. Upload a local file

An external MCP server cannot read an arbitrary path on your local computer. Local file bytes are transferred through the browser-mediated handoff and do not pass through the language model.

Local-file handoff sequence

1. Call ayneye.upload_video with filename.
2. Open the returned upload_url in your browser.
3. Select and upload the local file.
4. Call ayneye.upload_video again with the returned upload_handoff_id.
5. Read the returned video_id.
6. Use ayneye.get_video_status until evidence is ready.
7. Inspect ayneye.get_video_artifacts.
8. Ask with ayneye.ask_video using video_id and question.

Do not pass an arbitrary local filesystem path as a remote file reference. The remote MCP server cannot read files directly from your computer.

Local camera bootstrap

Connect a computer webcam without adding another MCP tool.

A local webcam is a device-ingest concern, not a ninth MCP tool. The public workflow bootstraps the camera over HTTPS, receives a tenant-scoped video_id, and then uses the existing Ayneye MCP live tools with that video.

Camera bootstrap contract

POST https://api.ayneye.com/v1/camera-ingest/sessions
Authorization: Bearer $AYNEYE_API_KEY
Content-Type: application/json

{
  "title": "Laptop camera",
  "capture_seconds": 60
}

capture_seconds is bounded to the current Public Beta live-processing limit and must not exceed 60 seconds.

The response supplies a temporary camera session containing: session_id, video_id, ingest_url, a one-time publish_token, and expiry information. Treat the publish token as a secret and never expose it to the AI model or print it in application logs.

Publish the local camera

Capture software on the developer computer publishes MPEG-TS video to the returned HTTPS ingest_url using HTTP Content-Type: video/mp2t and the returned one-time token in the X-Ayneye-Ingest-Token request header. When using FFmpeg HTTP output, explicitly set -content_type video/mp2t. The source is pushed from the local computer to Ayneye; Ayneye does not attempt to read an arbitrary local device path remotely.

Local webcam
→ local capture / FFmpeg
→ HTTPS ingest_url
→ GET /v1/camera-ingest/sessions/{session_id} until ready
→ video_id
→ ayneye.start_live
→ ayneye.get_live_state
→ ayneye.ask_video
→ ayneye.stop_live
→ ayneye.ask_video again

Check camera readiness

GET https://api.ayneye.com/v1/camera-ingest/sessions/{session_id}
Authorization: Bearer $AYNEYE_API_KEY

Wait until the camera-ingest session reports ready=true. Then use the returned video_id with the existing MCP contract.

Continue through MCP

ayneye.start_live({video_id})
ayneye.get_live_state({video_id})
ayneye.ask_video({video_id, question})
ayneye.stop_live({video_id})
ayneye.ask_video({video_id, follow_up_question})

Do not invent a connect_camera, publish_camera, or ask_live MCP tool. Camera bootstrap stays outside MCP; agent-facing video intelligence stays inside the existing public MCP tool contract.