The Problem

Managing team communication across multiple platforms (Slack, Discord, Telegram, etc.) leads to fragmented conversations and lost context. The lack of a unified interface for both human and AI agents further complicates collaborative work, especially when juggling synchronous chats, asynchronous threads, and shared resources. Existing tools either over-notify or under-organize, making it difficult to track ideas, share knowledge, or maintain focus.

What This Does

Inline is a lightweight, cross-platform chat application designed to unify team communication, AI agents, and shared workflows under a single interface. It replaces multiple messaging apps with a thread-first design, enabling organized, distraction-free collaboration. The project includes:

  • Native clients for macOS and iOS (apple/ directory), with planned support for Web, Android, Windows, and Linux.
  • Server-side components (server/ directory) handling authentication, message routing, and real-time updates via WebSocket.
  • Agent integration (crates/agent-bridge, crates/agent-driver-*) for AI-driven interactions, including adapters for OpenAI, Claude, and other models.
  • Plugin system (plugins/ directory) for extending functionality, with marketplace support for third-party integrations.
  • CLI tools (cli/ directory) for local development, testing, and automation.

The app emphasizes simplicity, flexibility, and a high signal-to-noise ratio, using threads as the primary organizational unit. Threads can be shared via links, titled for reference, and closed when no longer relevant, similar to managing open windows on a desktop.

How It Is Wired

Execution begins at cli/src/main.rs, which initializes the Rust-based CLI and orchestrates communication with the server and agent drivers. Key workflows:

  1. Client-Server Interaction: - The native client (apple/) connects to the server (server/) via WebSocket (server/src/ws.rs), handling message persistence (PostgreSQL) and real-time updates. - Threads are managed by the server/src/threads/ module, with metadata stored in server/src/db/schema/threads.sql.
  1. Agent Integration: - Agent drivers (crates/agent-driver-*) bridge external AI services (e.g., OpenAI, Claude) to the client via crates/agent-bridge. - The cli/src/bridge/adapter_locks/ directory contains adapters for specific AI models, with adapter_locks/amp managing OpenAI interactions.
  1. Plugin System: - Plugins (plugins/) are loaded at runtime, with marketplace definitions in .agents/plugins/marketplace.json. - The crates/agent-bridge module handles plugin lifecycle events, including initialization and message routing.

The project relies on:

  • Rust for high-performance backend and CLI components.
  • Swift for native macOS/iOS clients.
  • TypeScript for server-side logic and plugin development.
  • PostgreSQL for message and user data storage.

Key dependencies include:

  • tokio (async runtime) and warp (WebSocket server) in server/Cargo.toml.
  • react-native for cross-platform UI components in apple/.

How To Use It

Setup

  1. Clone the repository: ``bash git clone https://github.com/moses-y/inline.git ``
  2. Install dependencies: - Rust: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh - Node.js: Follow official instructions.
  3. Build the server: ``bash cd server cargo build --release ``
  4. Build the CLI: ``bash cd cli cargo build --release ``

Configuration

  • Server configuration is in server/config.yaml. Required environment variables:
  • DATABASE_URL: PostgreSQL connection string.
  • SECRET_KEY: Session secret for authentication.

Running It

  1. Start the server: ``bash cd server cargo run --release ``
  2. Start the CLI: ``bash cd cli cargo run --release ``

Real-World Use

Inline is ideal for teams needing a unified platform for human and AI collaboration. For example:

  • A software team uses threads to track bug reports, share code snippets, and conduct code reviews.
  • AI agents assist with real-time documentation updates or suggest optimizations directly in the chat.
  • Plugins extend functionality, such as integrating with GitHub for issue tracking or Slack for legacy message migration.

The thread-first design keeps discussions organized, while the agent integration reduces context-switching.

Code Health & Issues

  • Measured Analysis:
  • Tests: 1042 test files found.
  • Documentation: 173 documentation files found.
  • CI/CD: GitHub Actions workflows (cli-check.yml, server-test.yml) ensure code quality.
  • Licensing: MIT License present (LICENSE).
  • Observations:
  • High: No secrets management detected in repository (e.g., .env files).
  • Medium: Some scripts lack shebang lines (scripts/ directory).
  • Low: Inconsistent formatting in apple/ directory (mix of tabs/spaces).

The Bottom Line

Inline is a promising, lightweight alternative to Slack/Discord with strong thread-based organization and AI agent integration. The Rust/Swift/TypeScript stack ensures performance and flexibility, but the project is still maturing (0 stars, forked from a more popular repo). The thread-first design is a compelling differentiator, though enterprise adoption may require additional features like advanced permissions or SSO. For teams seeking a unified, distraction-free workspace, Inline is worth exploring.