# Inline Docs

Source: https://inline.chat

Generated from the same Markdown files used by the HTML docs.

## Contents

- [Get Started](https://inline.chat/docs/index.md): Inline documentation links.
- [What's New](https://inline.chat/docs/changelog.md): Release notes and exact app build links.
- [Downloads](https://inline.chat/docs/downloads.md): Current app download links.
- [CLI](https://inline.chat/docs/cli.md): Install, sign in, find chats, send messages, and export transcripts.
- [Set Up an Agent](https://inline.chat/docs/agents.md): Connect an agent to an Inline bot.
- [Add Inline to Your Agent](https://inline.chat/docs/add-inline.md): Add Inline tools to an existing agent.
- [MCP](https://inline.chat/docs/mcp.md): Connect an agent to Inline MCP.
- [OpenClaw](https://inline.chat/docs/openclaw.md): Install the Inline plugin for OpenClaw.
- [Hermes Agent](https://inline.chat/docs/hermes.md): Install Inline for Hermes Agent.
- [Developers](https://inline.chat/docs/developers.md): Inline APIs, SDKs, and automation.
- [AppleScript](https://inline.chat/docs/applescript.md): Inline for Mac AppleScript syntax and examples.
- [Realtime API](https://inline.chat/docs/realtime-api.md): WebSocket endpoints and TypeScript quick start.
- [Rust SDK](https://inline.chat/docs/rust-sdk.md): Rust Realtime SDK and stateful client.
- [Bot API](https://inline.chat/docs/bot-api.md): HTTP methods for Inline bots.
- [Create a Bot](https://inline.chat/docs/creating-a-bot.md): Create a bot and retrieve its token.
- [Receive Bot Updates](https://inline.chat/docs/bot-updates.md): Bot API polling and webhooks.
- [Security](https://inline.chat/docs/security.md): Inline security and vulnerability reporting.
- [Technical Documentation](https://inline.chat/docs/technical/index.md): Inline protocol and API references.
- [Deep Links](https://inline.chat/docs/technical/deep-links.md): Inline app and web link formats.
- [Protocol](https://inline.chat/docs/technical/protocol.md): Inline Protocol v1 construction and implementations.
- [Realtime](https://inline.chat/docs/technical/realtime.md): Realtime V3 transport, authentication, and outcomes.
- [RPC Semantics](https://inline.chat/docs/technical/rpc.md): Realtime retry and reconciliation rules.
- [Sync](https://inline.chat/docs/technical/sync.md): Realtime update, cursor, and history-gap rules.
- [Files](https://inline.chat/docs/technical/files.md): File upload and recovery contracts.
- [Schema](https://inline.chat/docs/technical/schema.md): Inline schema entry points and scalar conventions.
- [Security](https://inline.chat/docs/technical/security.md): Realtime security and credential boundaries.
- [Local Agents](https://inline.chat/docs/technical/local-agents.md): Local bridge ownership and security.
- [API Schema](https://inline.chat/docs/technical/api-schema.md): Bot API schemas and generated packages.
- [Protocol Schema](https://inline.chat/docs/technical/protocol-schema.md): Realtime Protocol Buffer schema and generated packages.
- [Realtime V2](https://inline.chat/docs/technical/realtime-v2.md): Bearer-token Realtime compatibility endpoint.

---
title: "Get Started"
description: "Inline documentation links."
---

# Get Started

Source: https://inline.chat/docs

- [Download Inline](https://inline.chat/docs/downloads)
- [What's New](https://inline.chat/docs/changelog)
- [Install the CLI](https://inline.chat/docs/cli#install)
- [Set Up an Agent](https://inline.chat/docs/agents)
- [Add Inline to Your Agent](https://inline.chat/docs/add-inline)
- [Connect MCP](https://inline.chat/docs/mcp)
- [Install OpenClaw](https://inline.chat/docs/openclaw)
- [Install Hermes Agent](https://inline.chat/docs/hermes)
- [Developer Documentation](https://inline.chat/docs/developers)
- [Security](https://inline.chat/docs/security)

---
title: "What's New"
description: "Release notes and exact app build links."
---

# What's New

Source: https://inline.chat/docs/changelog

Release notes for Inline apps, developer tools, and integrations.

> [Download the latest Inline apps](https://inline.chat/download).

## September 2, 2026

### New

- 📝 Messages on macOS now support **rich formatting**, including headings, lists, checklists, tables, quotes, images, code blocks, and collapsible sections. This release also adds underline, strikethrough, highlight, and experimental native rendering for inline and display math.
- 🗂️ Added **chat folders** on macOS. Group conversations, choose a name and emoji, and organize folders in Open or Pinned. Pinned folders also appear in All Chats, and collapsed folders show a combined unread badge, with clearer unread indicators for nested threads.
- 🎨 iOS now has the same **themes** as macOS, with new color presets and gradient message bubbles.
- ✅ Added **Ack** on iOS and macOS. Double-click or double-tap someone else's message to acknowledge it with a small check-mark pill; repeat the action to remove it.
- Start a new thread directly from **All Chats** on macOS. Choose Home or a space, add participants and attachments, and write your first message in place. You can also filter All Chats by Home or a space without changing the selected sidebar chat.
- 🔗 Added **space join links** on iOS and macOS. Share a public space or invite people into a private one, with controls to turn links on or off.
- Added **Sign in with Apple** and **Sign in with Google** on iOS and macOS. iOS onboarding also has separate name and username steps and clearer sign-in progress.

### Quality of life improvements

- Copy links to DMs, threads, and individual messages on macOS. Message links open the referenced message. Home threads now have short numbered references, just like space threads, for linking and search.
- Added `/thread` on iOS and macOS to create a reply thread from the current conversation. Open the command picker from the composer's plus menu.
- Reply threads now show the message they branched from, so the original context is visible above the replies.
- Follow or pin chats from more places on iOS, including All Chats and search.
- Newly opened chats now appear at the top of Open Chats by default.
- Command-K on macOS includes more of your local conversations, including chats that were previously missing from its results.
- Undo closing chats or folders and archiving conversations on macOS.
- Added **Cleanup** on iOS to close inactive chats and remove empty folders, matching macOS.
- Turn on **Shorten Supported Links** on macOS to replace supported pasted URLs with readable titles. Escape, Undo, or Backspace restores the original URL.
- Choose Grid's input and output devices in **Audio and Video** settings. Opt into unmuting when you join or muting when you are alone, and hide Grid from the sidebar if you prefer.
- Improved sharing from other apps on iOS, including send progress and recovery from interrupted uploads.
- Improved participant and mention search when adding people, bots, groups, or Agents. Reply-thread suggestions now include people and groups from the parent conversation, with better exact-name ranking.
- Added dedicated bot-owner settings on iOS and macOS, including token rotation.
- Improved macOS agent setup, with clearer progress, errors, repair options, and retry instructions.
- Adjust chat text size on macOS across all message layouts.
- Audio documents now play inline instead of opening as generic files.
- Notifications preserve meaningful line breaks, describe photos and other media, show encrypted photo previews on iOS, and open the exact message when possible.
- iOS now animates the delivery status from sending to sent. Also polished swipe-to-reply avatars and dark message bubbles.
- Software updates on macOS now open in their own window.
- Hover over truncated macOS sidebar titles to see the full name.

### Better tools and APIs for agents and hackers

- [OpenClaw](https://inline.chat/docs/openclaw) can now create reply threads from DMs and keep replies, typing, and activity in the child thread. Also improved rich replies, DM routing, agent-authored buttons, and compatibility with OpenClaw 2026.8.
- [Hermes](https://inline.chat/docs/hermes) now has native pickers for questions, approvals, and model selection, plus richer replies and agent-authored buttons. Added optional processing reactions, quieter progress updates, and compatibility with Hermes 0.21.
- Browse and open existing local Codex sessions with `/sessions` or `/open`, resume the exact session before another prompt, and release Codex from Inline with `/stop` or `/close`. Project discovery now includes saved Codex roots and larger paged catalogs.
- Codex work now stays in one updating **Working** message and finishes as a normal reply, preserving complete long-form output instead of splitting progress across many messages. The message limit is now 100,000 characters.
- Added browser-based login to the [Inline CLI](https://inline.chat/docs/cli). Agents and non-interactive tools can start the login flow for you to finish in your browser. CLI 0.7.7 also preserves rich Markdown input, resumes interrupted Realtime V3 uploads, installs the Codex plugin without extra flags, and improves shell completions and update checks.
- Added an **AppleScript API** for the Mac app. Find people and chats, create threads, inspect the current selection, read recent cached messages, send Markdown, and create Hookmark-compatible links from your own scripts.
- Expanded the [Bot API](https://inline.chat/docs/bot-api) with polling, webhooks, thread and participant events, files, skill catalogs, and a typed TypeScript client. Bots can send rich Markdown, add callback or copy-text buttons, update buttons independently, and forward or delete messages in batches.
- Added [Realtime V3](https://inline.chat/docs/realtime-api), with encrypted client-server transport, TypeScript and Rust support, durable resumable uploads, and authoritative recovery after reconnects or lost responses.
- Added Agent profile management to the Bot API, CLI, SDK, OpenClaw, and Hermes. The experimental **Skilled Agents** UI on iOS and macOS lets bot owners create named specializations, set a skill and instructions, and mention them in existing conversations.

### Fixes

- Improved catching up on missed messages, read state, unread counts, and chat updates after reconnecting. Damaged or incomplete local chat history can now recover from bounded authoritative snapshots without clearing the account.
- Fixed uploads that could stall, duplicate work, or unexpectedly sign you out. Large transfers now resume after reconnects and recover safely when finalization or a provider response is interrupted.
- Improved sign-in retries, logout, and account switching, including cleanup of stale account state.
- Fixed stale or duplicate macOS notifications, with better grouping and handling of replies and mentions.
- Fixed iOS chat previews and transitions when opening a conversation from a notification.
- Settings changes no longer interrupt OpenClaw's reply connection. Fixed agent settings that could stay loading or show stale results after switching bots or chats.
- Fixed code-block and rich-formatting errors in streamed bot replies, including incomplete fences, repeated progress updates, stale disclosure state, and broken image-gallery selection.
- Fixed pinned threads moving out of pinned folders, and restored chat placement when undoing a close on macOS.
- Fixed file paths being mistaken for slash commands and improved command and mention completion in the macOS composer. Autocomplete no longer resizes the chat while it is open.
- Improved macOS voice recording, including draft recovery, cancellation, and caption spacing.
- Improved Grid reconnects, screen sharing, and cleanup after leaving or losing access.
- Fixed cases where macOS could get stuck while quitting or loading the sidebar.
- Improved MCP browser sign-in and fixed connections left open after failed initialization.
- Improved macOS sidebar unread navigation and reporting when a chat cannot be opened.
- Fixed the forwarding picker showing an empty state before chats had finished loading.
- Fixed repeated press-and-hold urgent nudges and nudge toolbar press handling.
- Restored active reaction colors and corrected macOS reply-preview backgrounds and swipe-to-reply avatar movement.
- Fixed long link-heavy messages that could make the app unresponsive, and stopped URLs inside code from generating previews.

---

## August 15, 2026

[macOS 0.2 tip, build 4947](https://public-assets.inline.chat/mac/tip/4947/Inline.dmg) · [iOS TestFlight build 1193](https://testflight.apple.com/join/FkC3f7fz)

### New

- 🏠 iOS has an all-new Home with **Open**, **All Chats**, and **Search**, plus faster navigation and more control over how chats are shown.
- 🧵 The macOS sidebar now shows reply threads under their parent. You can pin or collapse them together, rename a reply thread, or open one beside the main conversation.
- 🎧 Added **Grid** on macOS: lightweight voice rooms for spaces, with presence, screen sharing, and controls for microphones, room names, and access.
- 🎨 Added themes on macOS, with new color presets across the sidebar, chats, composer, Grid, and settings.
- 🤖 Added one-click agent setup on macOS and in Inline CLI 0.7.3. Connect OpenClaw, Hermes, Codex, Claude, OpenCode, or Amp, create or reuse a bot, then start it and verify it is ready.
- Added a local agent bridge so coding agents can run as private Inline bots, keep workspace context, and continue work in reply threads.

### Quality of life improvements

- Improved bot setup and management, including profiles, chat controls, and commands such as `/command@bot`.
- Added **Copy as Markdown** for threads, with clean text and media links ready to paste as reference.
- Drop files or media onto a macOS sidebar chat to open it with the attachments ready as a draft.
- Press and hold a chat on iOS Home to preview it and see its actions.
- Command-K on macOS is faster, with immediate local results and better ranking over time.
- Added Privacy settings for **Appear in Global Search** and **Share Time Zone**. Both are on by default.
- Improved document, X, and Figma previews. Notifications now show document names and more reliable avatars.
- Choosing **All Notifications** now follows the chat, so it stays visible in your sidebar.
- Clear a conversation only for yourself, or privately share a thread with another Inline user.
- Improved profile setup, including Memoji profile photos on macOS and new Account settings on iOS.
- Improved macOS Settings, software updates, menus, emoji options, and email-code autofill.
- The iOS share menu now suggests the Inline chats you share with most often.
- Made reactions more compact and unread badges more consistent.
- Improved OpenClaw and Hermes setup and thread support. MCP now supports ChatGPT apps.
- Added **Connectors** on macOS and iOS. Connect Notion or Linear, reference pages with `[[`, and create tasks from Inline.

### Fixes

- Fixed sign-in, account switching, and fresh-account sync issues.
- Fixed incorrect unread counts.
- Fixed iOS chat opening, navigation, and share routing.
- Fixed iOS attachment sizing, message layout, and toolbar state.
- Improved macOS message performance and chat switching.
- Fixed macOS compose autocomplete, send-button state, and file drops.
- Fixed duplicate or misrouted bot and agent replies.
- Fixed notification settings, sender avatars, and invalid push tokens.
- Fixed media sends that could stall and URL previews that could disappear.
- Fixed message ordering and permission checks for chat actions.

---

## July 8, 2026

[macOS 0.2, build 4495](https://public-assets.inline.chat/mac/beta/4495/Inline.dmg) · [iOS on TestFlight](https://testflight.apple.com/join/FkC3f7fz)

### Better tools and APIs for agents and hackers

- Released new plugins for [OpenClaw](https://inline.chat/docs/openclaw) and [Hermes Agent](https://inline.chat/docs/hermes) with improved thread support.
- Released an [open-source Matrix bridge](https://github.com/inline-chat/matrix-inline), so you can use Inline in Beeper if that's your thing.
- Released a new version of the [Inline CLI](https://inline.chat/docs/cli) with new commands for agentic usage. The new `transcript` command gives agents a complete thread as Markdown, including files and media.
- Released `inline-sdk` and `inline-client` for Rust.
- Published `llms.txt` and made the docs more agent-friendly.
- Improved our MCP server so it is more capable at finding and summarizing things.

---

## June 29, 2026

[macOS 0.2, build 4354](https://public-assets.inline.chat/mac/beta/4354/Inline.dmg) · [iOS on TestFlight](https://testflight.apple.com/join/FkC3f7fz)

### New

- 🎙️ Added voice messages on macOS and iOS.
- 💫 Added a smooth new iOS send-message animation.

  [Watch the iOS send-message animation](https://inline.chat/changelog/2026-06-29/ios-send-message.mp4)

- `GIF` GIF support on macOS and iOS!
- 👀 Added a **Follow** button for threads. Followed threads appear in your sidebar when they receive a new message.

  ![The Follow button in the macOS chat toolbar](https://inline.chat/changelog/2026-06-29/follow-button.png)

  > We automatically follow threads you create, reply threads addressed to you, and reply threads you write in. If a thread is noisy, you can manually unfollow it and we won't automatically follow it again.

- 🏷️ You can now create user groups such as `@eng`, `@design`, or `@support`. They make it easy to mention or add multiple people to a thread at once. Create one from Space Settings.
- 🔍 Search messages from Command-K on macOS.

### Quality of life improvements

- Added a new typing animation and a **recording voice** compose status.
- The macOS reaction picker now sorts suggestions by your recent usage instead of using static defaults.

  ![Recently used emoji suggestions in the macOS reaction picker](https://inline.chat/changelog/2026-06-29/reaction-picker-recent.png)

- Choose whether macOS shows unread badges as dots or numbers.

  ![Dot and numbered unread badge options in macOS settings](https://inline.chat/changelog/2026-06-29/unread-badge-style.png)

- Significantly improved large X/Twitter cards with larger media, author profiles, and long-text support.

  ![An expanded X post preview with large media and author information](https://inline.chat/changelog/2026-06-29/x-preview.png)

- The dock badge now includes unread followed threads, not only unread direct messages.

  ![The Inline macOS dock icon showing two unread messages](https://inline.chat/changelog/2026-06-29/dock-badge.png)

- Added **Copy Link** for sharing threads with other Inline users.

  ![Copy Link in the macOS thread menu](https://inline.chat/changelog/2026-06-29/copy-link.png)

- Added an all-new Apple share-menu experience for sending content from other apps into Inline.
- Added haptic feedback when reordering threads in the sidebar.

### Fixes

- Thread icons now match across macOS, iOS, and notifications.
- Fixed a bug on iOS 27 where the composer could move outside the viewport.
- Improved voice waveform rendering and fixed composer state after sending voice messages.
- Fixed message hover states getting stuck in minimal mode.
- Fixed the emoji picker in the composer and switched it to our custom picker.
- Reduced scrolling lag on macOS and iOS. There is still more to improve!
- Fixed message-tap routing for documents, attachments, and URL previews on iOS.

---

## June 19, 2026

### New

- 💬 Bubbles now have tails! Thanks to [Jace](https://x.com/JaceThings) for her help polishing them.
- 🧲 Sticky avatars make scrolling chats nicer on macOS and iOS, in both minimal and bubble message modes.
- 🔗 Linking to a thread with `[[thread]]` now shows a backlink in the linked thread. This is the beginning of our multiplayer knowledge graph system.

### Fixes and improvements

- Pinning a message now shows a small service message in the chat.
- You can right-click a URL preview and exclude its domain from previews in your space threads.
- Improved large URL previews across more card and media types.
- Press and hold the macOS back or forward toolbar button to see your navigation history.

  ![Previous chats and dates in the macOS back-button history menu](https://inline.chat/changelog/2026-06-19/navigation-history.png)

- Configure what holding or double-clicking a message does on macOS.
- Improved voice waveform rendering and reset composer state after sending voice messages.
- Fixed macOS 26 toolbar and background behavior, including the glass composer height.
- Fixed holding on reactions on macOS 15.
- Added composer auto-pairing for `[]` and `()`.

---
title: "Downloads"
description: "Current app download links."
---

# Downloads

Source: https://inline.chat/docs/downloads

## Inline Beta Apps

- [Download for macOS](https://inline.chat/download/mac/beta) (`.dmg`)
- [TestFlight for iOS](https://testflight.apple.com/join/FkC3f7fz)

More platforms coming soon, with web coming first, followed by Windows, Android and Linux.

## More

- [Install the CLI](https://inline.chat/docs/cli#install)
- [Changelog](https://inline.chat/docs/changelog)
- [View previous macOS versions](https://inline.chat/docs/downloads/previous).

---
title: "CLI"
description: "Install, sign in, find chats, send messages, and export transcripts."
---

# CLI

Source: https://inline.chat/docs/cli

## Install

#### macOS or Linux

```bash
curl -fsSL https://inline.chat/cli/install.sh | sh
```

Linux targets: x86_64 and ARM64, with glibc or musl.

#### Homebrew

```bash
brew tap inline-chat/homebrew-inline
brew install --cask inline
```

Try it:

```bash
inline --version
```

## Sign In

```bash
inline login
```

Confirm your login:

```bash
inline me
```

CLI uses your account, not a bot or bot token. It's extremely useful for pairing with your Codex/Claude/etc for chatting, searching, creating threads, summarizing, etc.

## Update

```bash
inline update
```

For a Homebrew installation, use `brew upgrade --cask inline`.

## Doctor

Run `inline doctor` and review the output if reporting a bug.

## Help

Use `inline --help` for all command groups. [CLI reference and source](https://github.com/inline-chat/inline/tree/main/cli)

---
title: "Set Up an Agent"
description: "Connect an agent to an Inline bot."
---

# Set Up an Agent

Source: https://inline.chat/docs/agents

## Setup Prompt

Paste this into your favorite LLM so it can do the setup itself.

```text
Set up this agent as a bot in Inline:
https://inline.chat/docs/agents.md
```

Ideally specify which of your agents you want to bring and whether it's local or remote. For example:

```text
Set up my local OpenClaw as a bot in Inline:
https://inline.chat/docs/agents.md
```

## Inline for Mac

If you have the macOS app, we have a wizard for setting up your local agents. It sets up the CLI, finds your harnesses, installs the plugins, configures them, creates a bot, authenticates the plugin, and opens the chat ready to use. It may be brittle given the number of moving parts, so if it fails, try those steps manually.
Open **Inline → Settings → Bots → Set Up Agent…** or choose **Set Up an Agent…** from the app menu.

## Using the CLI

Check the CLI:

```bash
inline --version
```

[Install](https://inline.chat/docs/cli) it if missing:

```bash
curl -fsSL https://inline.chat/cli/install.sh | sh
```

Sign in if needed:

```bash
inline login --browser --no-open
```

Find installed agents:

```bash
inline agents discover
```

Run interactive setup:

```bash
inline agents setup
```

Agents and scripts should select the current runtime explicitly:

```bash
inline agents setup --target codex
```

Support status:

- Codex: alpha.
- Claude Code: beta.
- OpenCode: beta.
- Amp: experimental.
- Hermes Agent: beta.
- OpenClaw: experimental.

## Verify

A ready setup has:

- `status: "ready"`
- `service.ready: true`
- A bot username and `openUrl`

Open the bot via CMD+K or search on iOS and start chatting.

## Status

Check a local bridge (for Codex/Claude/OpenCode/Amp setups that use our bridge):

```bash
inline bridge status
```

Check Hermes:

```bash
hermes inline status --json --probe
```

Check OpenClaw:

```bash
openclaw channels status --channel inline --probe --json
```

---

[OpenClaw](https://inline.chat/docs/openclaw) · [Hermes Agent](https://inline.chat/docs/hermes) · [Local-agent boundaries (Technical)](https://inline.chat/docs/technical/local-agents)

---
title: "Add Inline to Your Agent"
description: "Add Inline tools to an existing agent."
---

# Add Inline to Your Agent

Source: https://inline.chat/docs/add-inline

Add Inline's skill and plugin to ChatGPT, Claude, etc. If you want to bring your bot/agent to Inline instead, use [Set Up an Agent](https://inline.chat/docs/agents).

## Setup Prompt

```text
Install Inline's plugin, skill, and MCP (if CLI is unavailable) based on the guides:
https://inline.chat/docs/add-inline.md
```

## ChatGPT/Codex Plugin

Add the Inline marketplace:

```bash
codex plugin marketplace add inline-chat/inline
```

Install the plugin:

```bash
codex plugin add inline@inline
```

Restart Codex. In ChatGPT desktop, open **Plugins** and install **Inline** from the Inline marketplace.

The plugin includes the Inline skill and MCP integration.

## Skill

If you have the CLI, run:

```bash
inline skill install
```

Or use `npx skills`:

```bash
npx skills add inline-chat/inline --skill inline --global
```

You may need to restart the agent for it to show up.

For manual install, download and copy the [`skills/inline` folder](https://github.com/inline-chat/inline/tree/main/skills/inline).

- Codex: `~/.codex/skills/inline`
- Claude Code: `~/.claude/skills/inline`

## MCP

Follow [Connect MCP](https://inline.chat/docs/mcp).

## CLI

[Install the CLI](https://inline.chat/docs/cli) if you haven't.

Heads up: don't use `inline agents setup` when you only want the plugin, skill, MCP, etc.

## Verify

Ask the agent:

```text
Use Inline to list my chats.
```

---

[Inline plugin](https://github.com/inline-chat/inline/tree/main/plugins/inline) · [Inline skill](https://github.com/inline-chat/inline/tree/main/skills/inline) · [MCP](https://inline.chat/docs/mcp) · [CLI](https://inline.chat/docs/cli)

---
title: "MCP"
description: "Connect an agent to Inline MCP."
---

# MCP

Source: https://inline.chat/docs/mcp

## Connect

Codex:

```bash
codex mcp add inline --url https://mcp.inline.chat/mcp/v2
```

Claude Code:

```bash
claude mcp add --transport http inline https://mcp.inline.chat/mcp/v2
```

Amp:

```bash
amp mcp add inline https://mcp.inline.chat/mcp/v2
```

Other clients: add this as a remote Streamable HTTP server:

```text
https://mcp.inline.chat/mcp/v2
```

Complete OAuth and choose the spaces and conversation types the agent may access.

## Verify

Ask it something like:

```text
Use Inline to list my chats.
```

---

[MCP tools](https://github.com/inline-chat/inline/tree/main/mcp) · [OAuth metadata](https://api.inline.chat/.well-known/oauth-authorization-server) · [Protected resource metadata](https://mcp.inline.chat/.well-known/oauth-protected-resource)

---
title: "OpenClaw"
description: "Install the Inline plugin for OpenClaw."
---

# OpenClaw

Source: https://inline.chat/docs/openclaw

## Easy setup

```bash
inline agents setup --target openclaw
```

The command checks the installed OpenClaw version before creating a bot, installs
the matching trusted plugin, restarts the gateway, and only reports ready after a
live Inline probe. If it stops, the error includes the failed phase and retry
command; no failed or partial run is reported as ready.

## Install

Install the compatible plugin for the current OpenClaw line:

```bash
openclaw plugins install @inline-openclaw/inline --force --accept-capabilities
```

### Version Match

| OpenClaw                                          | Inline plugin |
| ------------------------------------------------- | ------------- |
| `2026.8.x` (`>=2026.8.2`)                         | `0.0.65`      |
| `2026.7.x` (`>=2026.7.1`)                         | `0.0.63`      |
| `2026.6.x` (`>=2026.6.11`, including `2026.6.34`) | `0.0.63`      |

Install a matched version with:

```bash
openclaw plugins install @inline-openclaw/inline --force --accept-capabilities
```

On OpenClaw 2026.8, `--accept-capabilities` approves the capabilities declared
by Inline's trusted first-party package so the noninteractive install cannot
stall on a prompt. Older supported hosts do not recognize that flag; install
their matched `0.0.63` package with `--force` only.

## Configure

Set `channels.inline`:

```yaml
channels:
  inline:
    enabled: true
    token: "<INLINE_BOT_TOKEN>"
```

You may omit `token` and provide `INLINE_TOKEN` to the gateway.

Defaults:

- `dmPolicy: "pairing"`
- `groupPolicy: "open"`
- `requireMention: true`

Configure allowlists for a restricted bot. A mention requirement is not an operator allowlist.

## Restart

Restart the gateway:

```bash
openclaw gateway restart
```

List plugins:

```bash
openclaw plugins list
```

Check the Inline channel:

```bash
openclaw channels status --channel inline --probe --json
```

Inspect the plugin:

```bash
openclaw plugins inspect inline --json
```

Open a DM with the bot, complete pairing, and verify it works.

## Update

Ask OpenClaw to update the tracked Inline plugin:

```bash
openclaw plugins update inline --accept-capabilities
```

Restart after active work finishes:

```bash
openclaw gateway restart
```

## Checks

- Plugin missing: check `openclaw plugins list` and the gateway's install environment.
- Token missing: set `channels.inline.token` or `INLINE_TOKEN`.
- DM ignored: complete pairing or check the sender allowlist.
- Group ignored: check group policy, sender policy, and the mention.
- No reply: check provider sign-in and gateway errors.

---

[Plugin source and configuration](https://github.com/inline-chat/inline/tree/main/openclaw)

---
title: "Hermes Agent"
description: "Install Inline for Hermes Agent."
---

# Hermes Agent

Source: https://inline.chat/docs/hermes

## Easy setup

```bash
inline agents setup --target hermes
```

The command installs and configures the adapter, restarts the gateway, and only
reports ready after Hermes verifies the credential and the new gateway process.
If a step fails, Inline shows the failed phase and a retry command instead of
reporting the setup as ready.

## Install Manually

Install the adapter (plugin):

```bash
npm install -g @inline-chat/hermes-agent-adapter
```

### Version Match

| Hermes Agent                 | Inline adapter |
| ---------------------------- | -------------- |
| `>=0.17.0` (tested with `0.21.0`) | `0.0.15`       |

Install the plugin onto Hermes:

```bash
inline-hermes install
```

Enable the plugin:

```bash
hermes plugins enable inline-platform
```

Configure the gateway:

```bash
hermes gateway setup
```

Select **Inline**, then create a bot or paste an existing [bot token](https://inline.chat/docs/creating-a-bot).

## Verify

Check the installation:

```bash
inline-hermes doctor --json
```

Probe Inline connectivity:

```bash
hermes inline status --json --probe
hermes gateway status
```

The interactive Hermes wizard saves configuration first; restart and the probe
above are the readiness check.

Start the Hermes gateway, message the bot in Inline, and verify a final reply.
Find your bot by entering its username in CMD+K on macOS or the Search tab on iOS.

## Update

You may be able to update your Inline plugin via the `/inline_update` command in your DM with the Hermes agent.

Or update the adapter manually:

```bash
npm install -g @inline-chat/hermes-agent-adapter@latest
inline-hermes install --force
hermes gateway restart
```

---

[Adapter source and reference](https://github.com/inline-chat/inline/tree/main/hermes-agent)

---
title: "Developers"
description: "Inline APIs, SDKs, and automation."
---

# Developers

Source: https://inline.chat/docs/developers

## APIs

- [Bot API](https://inline.chat/docs/bot-api): HTTP, bot token, polling or webhooks.
- [Realtime API](https://inline.chat/docs/realtime-api): WebSocket RPCs, updates, and live state.
- [MCP](https://inline.chat/docs/mcp): hosted tools with user OAuth consent.
- [CLI](https://inline.chat/docs/cli): signed-in terminal and script access.

## SDKs

- `@inline-chat/bot-client`: TypeScript Bot API client.
- `@inline-chat/realtime-sdk`: TypeScript Realtime client.
- `inline-sdk`: low-level Rust API and Realtime RPCs.
- `inline-client`: stateful Rust cache and sync client. (experimental)

## Automation

- [OpenClaw](https://inline.chat/docs/openclaw)
- [Hermes Agent](https://inline.chat/docs/hermes)
- [Deep Links](https://inline.chat/docs/technical/deep-links)
- [AppleScript](https://inline.chat/docs/applescript)
- [Matrix bridge](https://github.com/inline-chat/matrix-inline)

## Reference

- [Create a Bot](https://inline.chat/docs/creating-a-bot)
- [Technical Documentation](https://inline.chat/docs/technical)
- [Bot API Schema](https://api.inline.chat/bot-api-reference)
- [Realtime Schema](https://github.com/inline-chat/inline/blob/main/proto/core.proto)
- [Source and Packages](https://github.com/inline-chat/inline)

---
title: "AppleScript"
description: "Inline for Mac AppleScript syntax and examples."
---

# AppleScript

Source: https://inline.chat/docs/applescript

Inline supports scripting on macOS via AppleScript. Here's a guide with some examples that are useful for asking your LLM to create any scripts you may want for making shortcuts, local integrations, etc.

## Account and Spaces

Return the current account and cached spaces:

```applescript
tell application "Inline"
  return {current account, list spaces}
end tell
```

## Current Conversation

Return the open reply thread or primary conversation:

```applescript
tell application "Inline"
  set selectedChat to current selection
  if selectedChat is missing value then error "Open a conversation first." number -1728
  return {id of selectedChat, name of selectedChat, URL of selectedChat}
end tell
```

- `current selection`: open reply thread, otherwise the primary conversation.
- `current thread`: alias for `current selection`.
- `current chat`: primary conversation only.

## Find a Person

Search cached users in a space:

```applescript
tell application "Inline"
  return find users "@maya" in space "7" maximum count 20
end tell
```

Search public usernames when the person is not cached:

```applescript
tell application "Inline"
  return search public users "@maya" maximum count 20
end tell
```

## IDs

Keep IDs as quoted decimal text, such as `"42"`.

## Create a Thread and Send

Replace the space ID and username before running:

```applescript
tell application "Inline"
  set people to find users "@maya" in space "7"
  if (count of people) is not 1 then error "Choose exactly one participant."
  set recipient to user id of item 1 of people

  set newThread to create thread "Release review" in space "7" participant ids {recipient}
  set destination to chat id of newThread
  set body to "**Ready for review** — [@Maya](inline://user/" & recipient & ")"
  return send message body to chat destination
end tell
```

Create a public space thread with `publicly visible true` and no participant list. Home threads cannot be public.

## Send and Retry

Send Markdown to a known chat:

```applescript
tell application "Inline"
  return send message "**Build passed**" to chat "123"
end tell
```

Reuse the same positive Int64 request ID only when retrying the same logical send:

```applescript
tell application "Inline"
  return send message "Build passed" to chat "123" request id "456"
end tell
```

- Markdown mentions: `[@Maya](inline://user/42)`
- Success returns `chat id`, `message id`, and `send request id`.

## Open a Chat and Copy Its Link

Find one cached chat, open it, and copy its link:

```applescript
tell application "Inline"
  set matches to find chats "Design" maximum count 20
  if (count of matches) is not 1 then error "Choose a more specific name."
  set destination to chat id of item 1 of matches
  open chat destination
  set the clipboard to chat link destination
end tell
```

## Shell Script

Save this as `notify-inline.applescript`:

```applescript
on run argv
  if (count of argv) is not 2 then error "Usage: notify-inline.applescript CHAT_ID MARKDOWN"
  set destination to item 1 of argv
  set body to item 2 of argv
  tell application "Inline"
    set receipt to send message body to chat destination
    return message id of receipt
  end tell
end run
```

Run it with a chat ID and Markdown body:

```bash
osascript ./notify-inline.applescript "123" "**Build passed**"
```

## Command Syntax

- `show inline`
- `current account`
- `list spaces`
- `list users [in space "7"] [maximum count 20]`
- `find users "Maya" [in space "7"] [maximum count 20]`
- `user info "42"`
- `search public users "@maya" [maximum count 20]`
- `list chats [in space "7"] [maximum count 20]`
- `find chats "Design" [in space "7"] [maximum count 20]`
- `current chat` / `current thread` / `current selection`
- `open chat "123"`
- `create thread "Review" [in space "7"] [participant ids {"42"}] [publicly visible true]`
- `recent messages "123" [before message "789"] [maximum count 20]`
- `send message "Hello" to chat "123" [request id "456"]`
- `chat link "123"`

Lists use cached data. Counts accept 1–100; public search returns at most 20 results. Titles are limited to 150 UTF-16 units. Commands have a 30-second deadline and at most 16 may be in flight.

macOS Automation permission is required. Errors: `-1743` permission, `-10004` account unavailable, `-1728` item unavailable, `-1712` timeout, `-10000` operation failed.

---

[Deep-link formats](https://inline.chat/docs/technical/deep-links) · [Bot API](https://inline.chat/docs/bot-api) · [CLI](https://inline.chat/docs/cli)

---
title: "Realtime API"
description: "WebSocket endpoints and TypeScript quick start."
---

# Realtime API

Source: https://inline.chat/docs/realtime-api

## Versions

- V3: `wss://api.inline.chat/realtime/v3` — Inline Protocol keys; current.
- V2: `wss://api.inline.chat/realtime` — bearer token; compatibility.

## Install

Bun:

```bash
bun add @inline-chat/realtime-sdk
```

npm:

```bash
npm install @inline-chat/realtime-sdk
```

## V2 Quick Start

Set `INLINE_TOKEN` and `INLINE_CHAT_ID`. Save as `send-realtime.ts`:

```ts
import { InlineSdkClient } from "@inline-chat/realtime-sdk"

const token = process.env.INLINE_TOKEN
const chatId = process.env.INLINE_CHAT_ID
if (!token || !chatId) throw new Error("Set INLINE_TOKEN and INLINE_CHAT_ID")

const client = new InlineSdkClient({ token })
try {
  await client.connect()
  await client.sendMessage({ chatId: BigInt(chatId), text: "Hello over Realtime" })
} finally {
  await client.close()
}
```

Run it:

```bash
bun run send-realtime.ts
```

Verify the message in Inline.

## V3

V3 requires `inlineProtocol.credentials` with permanent and bound temporary authorization keys. A bearer token cannot authenticate V3.

- [V3 authentication and transport](https://inline.chat/docs/technical/realtime)
- [Protocol specification](https://github.com/inline-chat/inline/blob/main/packages/protocol/docs/realtime-v3.md)
- [TypeScript implementation](https://github.com/inline-chat/inline/tree/main/sdk/src/realtime)
- [RPC retry rules](https://inline.chat/docs/technical/rpc)
- [Sync](https://inline.chat/docs/technical/sync)
- [Rust SDK](https://inline.chat/docs/rust-sdk)

---
title: "Rust SDK"
description: "Rust Realtime SDK and stateful client."
---

# Rust SDK

Source: https://inline.chat/docs/rust-sdk

Requires Rust 1.96 or newer. Experimental.

## Packages

- `inline-sdk`: RPCs, uploads, identity, and Realtime transport.
- `inline-protocol`: generated Protocol Buffers and secure protocol.
- `inline-client`: stateful cache, sync cursors, pending transactions, and committed events.

## Install

Add the SDK:

```bash
cargo add inline-sdk
```

Add Tokio:

```bash
cargo add tokio --features macros,rt-multi-thread
```

## V2 Quick Start

Set `INLINE_TOKEN`. Save as `src/main.rs`:

```rust
use inline_sdk::{ClientIdentity, RealtimeClient, proto};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let token = std::env::var("INLINE_TOKEN")?;
    let identity = ClientIdentity::try_new("my-rust-app", "0.1.0")?;

    let mut realtime = RealtimeClient::builder(
        "wss://api.inline.chat/realtime",
        token,
    )
    .identity(identity)
    .connect()
    .await?;

    realtime.call(proto::GetMeInput {}).await?;
    Ok(())
}
```

Run it:

```bash
cargo run
```

## Stateful Client

Add the stateful client:

```bash
cargo add inline-client
```

Use one sync owner. Start with [`inline-client`](https://github.com/inline-chat/inline/tree/main/crates/client) instead of building a second cache around `inline-sdk`.

## Notes

- V3 uses [key-based authentication](https://inline.chat/docs/technical/realtime#authentication-lifecycle).
- IDs are `Int64`; TypeScript projections use `bigint`.
- Errors are non-exhaustive.
- Reconcile uncertain mutations before retrying.
- [`inline-sdk`](https://github.com/inline-chat/inline/tree/main/crates/sdk)

---
title: "Bot API"
description: "HTTP methods for Inline bots."
---

# Bot API

Source: https://inline.chat/docs/bot-api

Inline has an easier to use HTTP API for creating bots. We recommend using this for most integration usages, unless you need advanced features and maximum control where you should use our full realtime API which is used in our own official clients.

## Bot API

- Version: `0.1`
- Base URL: `https://api.inline.chat`
- Method URL: `https://api.inline.chat/bot/<method>`
- [Method reference](https://api.inline.chat/bot-api-reference)
- [OpenAPI JSON](https://inline.chat/openapi.json)

## Authentication

Recommended header:

```text
Authorization: Bearer <token>
```

Simpler path for quick tests:

```text
https://api.inline.chat/bot<token>/<method>
```

## Receive a Chat ID

[Create a bot](https://inline.chat/docs/creating-a-bot), set `INLINE_BOT_TOKEN`, and initialize its update queue before sending a test message:

```bash
curl -sS "https://api.inline.chat/bot/getUpdates?timeout=0" \
  -H "Authorization: Bearer ${INLINE_BOT_TOKEN}"
```

Send the bot a DM in Inline, then poll:

```bash
curl -sS "https://api.inline.chat/bot/getUpdates?timeout=30" \
  -H "Authorization: Bearer ${INLINE_BOT_TOKEN}"
```

Use `message.chat.chat_id` as `INLINE_CHAT_ID`. Messages sent before the first poll or webhook setup are not backfilled.

## TypeScript Client

Install with Bun:

```bash
bun add @inline-chat/bot-client@^0.1.0
```

Install with npm:

```bash
npm install @inline-chat/bot-client@^0.1.0
```

Set `INLINE_BOT_TOKEN` and `INLINE_CHAT_ID`. Save as `send.ts`:

```ts
import { InlineBotClient } from "@inline-chat/bot-client"

const token = process.env.INLINE_BOT_TOKEN
const chatId = process.env.INLINE_CHAT_ID
if (!token || !chatId) throw new Error("Set INLINE_BOT_TOKEN and INLINE_CHAT_ID")

const bot = new InlineBotClient({ token })
const me = await bot.getMe()
if (!me.ok) throw new Error(`${me.error_code}: ${me.description}`)

const sent = await bot.sendMessage({ chat_id: chatId, text: "Hello from my bot" })
if (!sent.ok) throw new Error(`${sent.error_code}: ${sent.description}`)
```

Run it:

```bash
bun run send.ts
```

## Methods

- Identity and chats: `getMe`, `getChat`, `getChatHistory`, `getMessages`, `searchMessages`
- Threads: `createThread`, `createReplyThread`, `addThreadParticipant`, `removeThreadParticipant`
- Messages: `sendMessage`, `editMessageText`, `deleteMessage`, `forwardMessage`, `sendReaction`
- Files: `uploadFile`, `getFile`
- Updates: `getUpdates`, `setWebhook`, `deleteWebhook`, `getWebhookInfo`

Use exactly one destination: `chat_id` or `user_id`. Legacy `peer_thread_id` and `peer_user_id` are accepted.

## Threads and Mentions

Create a private thread and send its first message:

```ts
const userId = 42
const created = await bot.createThread({
  title: "Support",
  participants: [userId],
})
if (!created.ok) throw new Error(created.description)

const reply = await bot.sendMessage({
  chat_id: created.result.chat.chat_id,
  text: `Hello [there](inline://user/${userId})`,
})
if (!reply.ok) throw new Error(reply.description)
```

- Public threads require a space and no participant list.
- Markdown mentions use `inline://user/{userId}`.
- A bot cannot remove itself from a thread.

## Updates

Polling and webhooks consume the same queue. Setting a webhook disables polling.

- Retention: up to 24 hours.
- Delivery: at least once; deduplicate by `update_id`.
- Batch: 1–100 updates.
- Queue: 100,000 updates, 128 MiB total, 512 KiB per update.
- Response: about 4 MiB maximum.
- Polling: one active long poll per bot.
- Webhook secret header: `x-inline-bot-api-secret-token`.

[Polling and webhooks](https://inline.chat/docs/bot-updates)

## Files and Access

- `getFile` and `file_id` reuse require a bot-owned upload or an accessible message.
- Bots do not receive their own messages.
- Humans activate the default `mentions` trigger through DMs, mentions, replies, commands, and message actions.
- Bots activate other bots only with an explicit resolved mention.

## Responses

Success:

```json
{ "ok": true, "result": {} }
```

Error:

```json
{ "ok": false, "error_code": 400, "description": "Invalid arguments was provided" }
```

Check `ok` on every response. The client does not retry automatically. A lost send response may be an uncertain commit; do not retry blindly.

## Packages

- `@inline-chat/bot-client`: client and generated types.
- `@inline-chat/bot-api-types`: generated request, response, entity, and method types.

---
title: "Create a Bot"
description: "Create a bot and retrieve its token."
---

# Create a Bot

Source: https://inline.chat/docs/creating-a-bot

Bots have a name, username and a token to give them life through our API, plugins or Bot client SDK.
For connecting your agents, you need a bot. However, our CLI's `inline agents setup` or macOS `Set Up an Agent` flows do it automatically.

## Inline for Mac

1. Open **Inline → Settings → Bots**.
2. Enter a name and a username ending in `bot`.
3. Select **Create Bot**.
4. Copy the token.
5. Find your bot by entering its username in CMD+K on macOS or the Search tab on iOS.

## CLI

Create the bot:

```bash
inline bots create --name "My Inline Bot" --username myinlinebot
```

List existing bots:

```bash
inline bots list
```

Reveal a bot token. This prints a secret:

```bash
inline bots reveal-token --bot-user-id 123
```

## Verify

Set `INLINE_BOT_TOKEN`, then call `getMe`:

```bash
curl -sS "https://api.inline.chat/bot/getMe" \
  -H "Authorization: Bearer ${INLINE_BOT_TOKEN}"
```

---

[Bot API](https://inline.chat/docs/bot-api) · [OpenClaw](https://inline.chat/docs/openclaw) · [Hermes Agent](https://inline.chat/docs/hermes) · [Set Up an Agent](https://inline.chat/docs/agents)

---
title: "Receive Bot Updates"
description: "Bot API polling and webhooks."
---

# Receive Bot Updates

Source: https://inline.chat/docs/bot-updates

Use one consumer per bot:

- `getUpdates`: one active long poll; persist the offset.
- Webhook: HTTPS handler; verify the secret; return `2xx` after durable handling.

Polling and webhooks share one queue. Setting a webhook disables polling. Messages sent before the first poll or webhook setup are not backfilled.

## Polling

Read a batch:

```bash
curl -sS "https://api.inline.chat/bot/getUpdates?timeout=0&limit=20" \
  -H "Authorization: Bearer ${INLINE_BOT_TOKEN}"
```

Processing loop:

1. Load the saved offset.
2. Long-poll with that offset.
3. Process by increasing `update_id`; tolerate gaps.
4. Stop at the first failure.
5. Persist completed work.
6. Save one above the last successfully handled ID.
7. Poll again.

Fetching does not acknowledge durable processing. Delivery is at least once; deduplicate by `(bot identity, update_id)`.

## Webhook

Register after the handler is ready:

```ts
const secret = process.env.INLINE_WEBHOOK_SECRET
if (!secret) throw new Error("Set INLINE_WEBHOOK_SECRET")

const registered = await bot.setWebhook({
  url: "https://your-service.example/inline-updates",
  secret_token: secret,
  message_trigger: "mentions",
})
if (!registered.ok) throw new Error(registered.description)
```

Handler rules:

- Verify `x-inline-bot-api-secret-token` with a constant-time comparison.
- Deduplicate by bot identity and `update_id`.
- `x-inline-update-id` is stable across retries.
- `x-inline-attempt` starts at 1.
- Deliveries may be concurrent and out of order.
- Durably enqueue or finish before returning `2xx`.
- Current timeout: 10 seconds.
- Numeric `Retry-After` on `429` and `503` is capped at one hour.

Inspect `getWebhookInfo` for pending count, last error, and dropped updates.

## Update Selection

Default update kinds:

- `message`
- `edited_message`
- `message_action`
- `bot_participation`

Reactions require `allowed_updates`. The default `mentions` trigger includes DMs and human mentions, replies, commands, and message actions. Bots require a structured mention.

## Checks

- `WEBHOOK_ACTIVE`: keep the webhook or call `deleteWebhook` before polling.
- `POLL_CONFLICT`: stop the duplicate long poll.
- Empty new queue: initialize delivery, then send a fresh human DM.
- Repeated update: fix acknowledgement and deduplication.
- Missing thread message: check access, `message_trigger`, `allowed_updates`, and mentions.
- Growing webhook backlog: check reachability, secret validation, and handler failures.
- Missing updates after downtime: retention is 24 hours and the queue is bounded.

[Queue limits](https://inline.chat/docs/bot-api#updates) · [Method reference](https://api.inline.chat/bot-api-reference)

---
title: "Security"
description: "Inline security and vulnerability reporting."
---

# Security

Source: https://inline.chat/docs/security

We'll be writing a more in-depth page soon, but here's a summary:

- Inline is in beta, and security has been one of the most important aspects of the product for us. We'll keep improving security at every layer, alongside privacy controls and spam mitigation mechanisms.
- We use a secure encrypted transport based on Telegram's MTProto 2, giving Inline a strong foundation for transport security.
- iOS and macOS local databases are encrypted using SQLCipher.
- Message text and related content are stored encrypted. Before GA, we're continuing to expand this coverage by encrypting files ourselves before storing them with Cloudflare, alongside more thread and space metadata and settings.
- E2EE is on our roadmap, at least for DMs, once we can address its UX challenges without sacrificing an easy-to-use and fast experience.
- We're also planning a self-hosting option for companies that have limitations around sending data to a third party.

More details soon. Feel free to ask us questions directly in the meantime.

## Technical Details

- [Inline Protocol](https://inline.chat/docs/technical/protocol)
- [Technical Security](https://inline.chat/docs/technical/security)
- [Local Agent Security](https://inline.chat/docs/technical/local-agents#security)

## Report a Vulnerability

- Email [hey@inline.chat](mailto:hey@inline.chat). Use the subject **Security**.
- You can also DM @mo inside Inline to have a friendly chat!

---
title: "Technical Documentation"
description: "Inline protocol and API references."
---

# Technical Documentation

Source: https://inline.chat/docs/technical

## Topics

- [Protocol](https://inline.chat/docs/technical/protocol)
- [Deep Links](https://inline.chat/docs/technical/deep-links)
- [Realtime](https://inline.chat/docs/technical/realtime)
- [RPC Semantics](https://inline.chat/docs/technical/rpc)
- [Sync](https://inline.chat/docs/technical/sync)
- [Files](https://inline.chat/docs/technical/files)
- [Schema](https://inline.chat/docs/technical/schema)
- [Security](https://inline.chat/docs/technical/security)
- [Local Agents](https://inline.chat/docs/technical/local-agents)

## Sources

- [Inline Protocol specification](https://github.com/inline-chat/inline/blob/main/packages/protocol/docs/realtime-v3.md)
- [Realtime V3 RPC semantics](https://github.com/inline-chat/inline/blob/main/packages/protocol/docs/realtime-v3-rpc-semantics.md)
- [`core.proto`](https://github.com/inline-chat/inline/blob/main/proto/core.proto)
- [Bot API reference](https://api.inline.chat/bot-api-reference)
- [TypeScript SDK](https://github.com/inline-chat/inline/tree/main/sdk)
- [Rust SDK](https://github.com/inline-chat/inline/tree/main/crates)

---
title: "Deep Links"
description: "Inline app and web link formats."
---

# Deep Links

Source: https://inline.chat/docs/technical/deep-links

Use positive decimal IDs. `in://` is canonical; `inline://` is a supported production alias.

## App Links

```text
in://user/{userId}
in://chat/{chatId}
in://chat/{chatId}/message/{messageId}
in://join/public/{spaceHandle}
in://join/invite/{inviteToken}
```

## Web Links

```text
https://inline.chat/c/{chatId}
https://inline.chat/s/{spaceHandle}
https://inline.chat/invite/{inviteToken}
```

## Accepted Aliases

- Scheme: `inline://`
- Chat host: `thread`
- User query keys: `id`, `user_id`, `userId`
- Chat query keys: `id`, `chat_id`, `chatId`, `thread_id`, `threadId`
- Message query keys: `message_id`, `messageId`
- Message path alias: `in://thread/{chatId}/message/{messageId}`

Opening a link does not grant access. Store chat and message IDs together.

Markdown mentions use `inline://user/{userId}`, not `in://user/{userId}`.

---
title: "Protocol"
description: "Inline Protocol v1 construction and implementations."
---

# Protocol

Source: https://inline.chat/docs/technical/protocol

Inline Protocol v1 carries Realtime V3. It uses the MTProto 2.0 secure-transport construction with Inline endpoints, keys, sessions, schema, and RPCs.

## Construction

- Handshake: pinned RSA keys, RSA_PAD, finite-field DH, nonces, and transcript validation.
- Records: MTProto 2.0 KDF, AES-256-IGE, message keys, salts, sessions, message IDs, sequences, and direction checks.
- Authorization: permanent device key plus bound temporary keys.
- Temporary keys: 24-hour lifetime; rotate at 80%.
- Reliability: containers, ACKs, resend/state requests, cached results, clock correction, and replay rejection.
- Carrier: obfuscated abridged framing over binary WebSocket.
- Application: `inline.invoke`, `inline.result`, and `inline.update` contain Protocol Buffer bytes.
- No Telegram API or endpoint compatibility.

## Specification

- [Inline Protocol and Realtime V3](https://github.com/inline-chat/inline/blob/main/packages/protocol/docs/realtime-v3.md)
- [Conformance vectors](https://github.com/inline-chat/inline/blob/main/packages/protocol/vectors/inline-protocol-v1.json)
- [Production trust roots](https://github.com/inline-chat/inline/blob/main/packages/protocol/trust-roots/inline-protocol-production.json)
- [MTProto 2.0](https://core.telegram.org/mtproto/description)

## Implementations

- [TypeScript secure transport](https://github.com/inline-chat/inline/tree/main/packages/protocol/src/secure)
- [TypeScript V3 connection](https://github.com/inline-chat/inline/blob/main/sdk/src/realtime/v3-connection.ts)
- [Rust secure transport](https://github.com/inline-chat/inline/blob/main/crates/protocol/src/secure.rs)
- [Rust V3 connection](https://github.com/inline-chat/inline/blob/main/crates/sdk/src/realtime_v3.rs)

---
title: "Realtime"
description: "Realtime V3 transport, authentication, and outcomes."
---

# Realtime

Source: https://inline.chat/docs/technical/realtime

- Endpoint: `wss://api.inline.chat/realtime/v3`
- Authentication: Inline Protocol permanent and bound temporary keys.
- Encoding: exact [`core.proto`](https://github.com/inline-chat/inline/blob/main/proto/core.proto) bytes.
- Carrier: obfuscated abridged frames over binary WebSocket.
- Compression: disabled.
- Bearer tokens do not authenticate V3.

## Authentication Lifecycle

1. Create a permanent key with the protocol handshake and pinned server keys.
2. Run `authBegin` and `authComplete` inside the encrypted session.
3. Create and bind a temporary key.
4. Rotate temporary keys before expiry.

Use the SDK implementation:

- [TypeScript V3 connection](https://github.com/inline-chat/inline/blob/main/sdk/src/realtime/v3-connection.ts)
- [TypeScript V3 transport](https://github.com/inline-chat/inline/blob/main/sdk/src/realtime/v3-transport.ts)
- [Rust V3 connection](https://github.com/inline-chat/inline/blob/main/crates/sdk/src/realtime_v3.rs)

## Outcomes

- `notSent`: rejected before carrier dispatch.
- `rejectedBeforeExecution`: execution provably did not begin.
- `accepted`: dispatched; not yet confirmed.
- `confirmed`: authenticated result or application error received.
- `commitUnknown`: execution may have begun; do not retry blindly.
- `reconciled`: stable identity or authoritative query found the result.

Cancellation stops the wait; it does not prove execution stopped.

## References

- [Protocol](https://inline.chat/docs/technical/protocol)
- [RPC semantics](https://inline.chat/docs/technical/rpc)
- [Sync](https://inline.chat/docs/technical/sync)
- [Files](https://inline.chat/docs/technical/files)
- [V3 specification](https://github.com/inline-chat/inline/blob/main/packages/protocol/docs/realtime-v3.md)
- [V2 compatibility](https://inline.chat/docs/technical/realtime-v2)

---
title: "RPC Semantics"
description: "Realtime retry and reconciliation rules."
---

# RPC Semantics

Source: https://inline.chat/docs/technical/rpc

## Rules

- Read-only methods may replay with identical input.
- `accepted` is not a confirmed application outcome.
- After dispatch, an unclassified mutation becomes `commitUnknown` on timeout, cancellation, disconnect, or missing result.
- Retry a stable-identity method only with the same identity and a documented repeat-safe policy.
- Reconcile state-shaped mutations before retrying.
- Reject `UNSPECIFIED` before execution.
- Cancellation ends the wait, not execution.

Only outer transport `rpc_error(503)` and `rpc_error(504)` carry pre-execution or commit-unknown meaning. A protobuf `RpcError` inside an authenticated result is a method error.

## Stable Identities

- `SEND_MESSAGE`: reuse the non-zero `random_id`.
- `CREATE_SUBTHREAD`: reconcile parent chat and message.
- `CREATE_UPLOAD`: reuse `(account session, client_upload_id)`.
- `SAVE_UPLOAD_PART`: reuse `(upload_id, part_index)` with identical bytes and hash.
- `FINISH_UPLOAD`: reuse `upload_id` and reconcile the canonical result.

## No Automatic Replay

Reconcile before retry:

- Message edits and deletes.
- Participant, dialog, notification, profile, session, and connector changes.
- Upload cancellation.
- DialogFolder update and delete.

Require a stable operation identity before automatic retry:

- Chat, bot, space, group, Grid-room, external-task, CLI-session, connector-OAuth, and DialogFolder creation.

Connection-local lanes serialize selected non-commutative operations. They do not create cross-connection transactions or make methods repeat-safe.

[Complete replay matrix](https://github.com/inline-chat/inline/blob/main/packages/protocol/docs/realtime-v3-rpc-semantics.md)

---
title: "Sync"
description: "Realtime update, cursor, and history-gap rules."
---

# Sync

Source: https://inline.chat/docs/technical/sync

Inline sync preserves cached state while repairing gaps.

## Buckets

- User: account, settings, profile, dialog state, space membership, and top-level chat access.
- Space: membership and space settings.
- Chat: messages, attachments, pins, metadata, visibility, participants, groups, moves, deletion, and scoped history clearing.
- Ephemeral: reactions, compose, presence, notifications, `GridEvent`, and `BotEvent`.

Each durable update maps to one inferred bucket.

## Cursor

```text
seq <= cursor      ignore
seq = cursor + 1   apply and commit
seq > cursor + 1   fence bucket and fetch
```

Only the affected bucket pauses. Do not advance past an unsupported or malformed durable update without authenticated sequence coverage.

## Catch-Up

- Page size: up to 100 logical updates.
- Replay ceiling: 10,000 updates.
- Larger gaps return `TOO_LONG` and require a snapshot.
- Validate snapshot identity and sequence.
- Commit projection and cursor together.
- Preserve the old cursor if repair fails.
- Preserve cached messages and user-owned dialog preferences.

## Discovery

Install the update collector before `GET_UPDATES_STATE`. Apply its preceding update batches before closing target collection. Fetch hinted buckets plus the user bucket; do not enumerate every stored cursor.

## History

Update continuity does not prove message-history continuity. Track message-ID gaps separately. Close a gap only after a successful history response.

- [TypeScript sync owner](https://github.com/inline-chat/inline/blob/main/sdk/src/sdk/inline-sdk-client.ts)
- [Rust sync engine](https://github.com/inline-chat/inline/blob/main/crates/client/src/sync.rs)
- [V3 update contract](https://github.com/inline-chat/inline/blob/main/packages/protocol/docs/realtime-v3.md)

---
title: "Files"
description: "File upload and recovery contracts."
---

# Files

Source: https://inline.chat/docs/technical/files

## Bot API

- Upload with `uploadFile`.
- Fetch or reuse a `file_id` only for a bot-owned upload or an accessible message.
- [Bot API](https://inline.chat/docs/bot-api)

## Realtime Uploads

```text
createUpload
saveUploadPart
getUploadState
finishUpload
cancelUpload
```

Contract:

- `client_upload_id`: stable opaque 16-byte create identity.
- `upload_id`: server-issued identity; preserve across reconnects.
- `sha256`: 32-byte whole-file digest.
- Part size: read `part_size`; currently 512 KiB.
- Maximum: 1,000 parts and 500 MiB.
- `accepted_parts`: server-accepted part indices.
- Expiry: 24 hours idle; seven days maximum.
- Parts may arrive out of order.
- Identical part retries succeed; conflicting bytes fail.

After a lost response, call `getUploadState`.

## Finish

- `missing`: send returned `part_indices`, then finish again.
- `processing`: wait `retry_after_seconds` (1–30), then query the same upload.
- `complete`: use the canonical typed media result.
- `failed`: inspect the code and `retryable` flag.

Do not create a second upload after a lost finish response. Message sending is a separate operation.

## Ownership

- V3 binds an upload to user, account session, and permanent key.
- Temporary-key rotation preserves ownership.
- Revocation or logout ends access.
- Upload bytes stay in encrypted RPCs.
- Bot API upload and CDN download are separate contracts.
- `cancelUpload` may refuse cancellation during processing.

## Reference

- [TypeScript helpers](https://github.com/inline-chat/inline/blob/main/packages/protocol/src/uploads.ts)
- [Rust client](https://github.com/inline-chat/inline/blob/main/crates/sdk/src/native_upload.rs)
- [V3 upload contract](https://github.com/inline-chat/inline/blob/main/packages/protocol/docs/realtime-v3.md)

---
title: "Schema"
description: "Inline schema entry points and scalar conventions."
---

# Schema

Source: https://inline.chat/docs/technical/schema

## Entry Points

- Bot API: [OpenAPI JSON](https://inline.chat/openapi.json) · [Methods](https://api.inline.chat/bot-api-reference)
- Realtime application: [`core.proto`](https://github.com/inline-chat/inline/blob/main/proto/core.proto)
- Realtime transport: [Inline Protocol](https://inline.chat/docs/technical/protocol)
- Generated packages: [API Schema](https://inline.chat/docs/technical/api-schema) · [Protocol Schema](https://inline.chat/docs/technical/protocol-schema)

## Conventions

- Realtime IDs: 64-bit integers; TypeScript output uses `bigint`.
- Bot API IDs: JSON numbers in the supported range; inputs may accept decimal strings.
- Message identity: store `(chat_id, message_id)`.
- Timestamps: Unix seconds unless documented otherwise.
- Message entity offsets: UTF-16 code units.
- Send identity: reuse a non-zero `SEND_MESSAGE.random_id` only for the same logical send.

Encode `bigint` for JSON:

```ts
const json = JSON.stringify(value, (_key, item) =>
  typeof item === "bigint" ? item.toString() : item,
)
```

---
title: "Security"
description: "Realtime security and credential boundaries."
---

# Security

Source: https://inline.chat/docs/technical/security

## Realtime V3

- TLS/WSS: certificate-validated network transport.
- Handshake: pinned RSA keys, RSA_PAD, finite-field DH, permanent keys, and bound temporary keys.
- Records: MTProto 2.0 KDF, AES-256-IGE, message keys, direction checks, replay rejection, and authenticated results.
- Dispatch: user, session, space, chat, bot, scope, and file authorization.
- Server termination: both encryption layers end at Inline's server; this is not end-to-end encryption.

References:

- [Protocol](https://inline.chat/docs/technical/protocol)
- [V3 specification](https://github.com/inline-chat/inline/blob/main/packages/protocol/docs/realtime-v3.md)
- [Trust roots](https://github.com/inline-chat/inline/blob/main/packages/protocol/trust-roots/inline-protocol-production.json)
- [Conformance vectors](https://github.com/inline-chat/inline/blob/main/packages/protocol/vectors/inline-protocol-v1.json)

## Credentials

- Bot API: bot token.
- Realtime V2: Inline bearer token.
- Realtime V3: permanent and bound temporary keys.
- MCP: OAuth 2.1 with PKCE, scopes, and selected chat context.
- CLI: signed-in local CLI session.

Credentials are not interchangeable. Do not log tokens, keys, OAuth grants, webhook secrets, or local control credentials.

## Apple Database

The authenticated iOS and macOS account database uses SQLCipher with a 256-bit random key stored in Keychain with after-first-unlock accessibility. This does not cover every downloaded file or operating-system cache.

[Product security](https://inline.chat/docs/security)

---
title: "Local Agents"
description: "Local bridge ownership and security."
---

# Local Agents

Source: https://inline.chat/docs/technical/local-agents

## Ownership

- One Inline bot identity per selected harness.
- The bridge owns the provider process.
- Existing chat bindings override the default workspace.
- `--folder` selects a narrower workspace.
- Codex is the primary local-bridge alpha path.
- Claude and OpenCode are beta; Amp is experimental.
- Hermes is beta; OpenClaw is experimental.

## Security

- Authorize senders by stable user ID.
- Owner-only routing is the default.
- Chat membership or a mention does not grant command permission.
- Do not expose the bridge as a public listener.
- Provider credentials stay with the provider.
- Tokens and local control credentials must not appear in logs.
- Shared or public chats do not expand filesystem or command authority.
- Preserve the provider's exact approval scope.

[Setup](https://inline.chat/docs/agents) · [Bridge reference](https://github.com/inline-chat/inline/blob/main/docs/local-agent-bridge.md)

---
title: "API Schema"
description: "Bot API schemas and generated packages."
---

# API Schema

Source: https://inline.chat/docs/technical/api-schema

- [OpenAPI JSON](https://inline.chat/openapi.json)
- [Interactive method reference](https://api.inline.chat/bot-api-reference)
- [Bot API setup](https://inline.chat/docs/bot-api)
- `@inline-chat/bot-client`: typed HTTP client and Bot API types.
- `@inline-chat/bot-api-types`: generated requests, responses, entities, and methods.

---
title: "Protocol Schema"
description: "Realtime Protocol Buffer schema and generated packages."
---

# Protocol Schema

Source: https://inline.chat/docs/technical/protocol-schema

- [`proto/core.proto`](https://github.com/inline-chat/inline/blob/main/proto/core.proto): methods, results, objects, and updates.
- [`@inline-chat/protocol`](https://github.com/inline-chat/inline/tree/main/packages/protocol): TypeScript schema and transport.
- [`inline-protocol`](https://github.com/inline-chat/inline/tree/main/crates/protocol): Rust schema and protocol.

Install TypeScript:

```bash
npm install @inline-chat/protocol
```

Install Rust:

```bash
cargo add inline-protocol
```

`Method` selects the matching `RpcCall` input. Unknown fields must remain forward-compatible. Unknown durable updates still require [sequence coverage](https://inline.chat/docs/technical/sync#cursor) before cursor advancement.

---
title: "Realtime V2"
description: "Bearer-token Realtime compatibility endpoint."
---

# Realtime V2

Source: https://inline.chat/docs/technical/realtime-v2

- Endpoint: `wss://api.inline.chat/realtime`
- Authentication: Inline bearer token.
- Payload: typed Realtime RPCs and updates.
- Status: compatibility path.

[TypeScript quick start](https://inline.chat/docs/realtime-api#v2-quick-start) · [Realtime V3](https://inline.chat/docs/technical/realtime)