Orb is a self-evolving AI agent framework built in JavaScript that wraps the Claude Code CLI with persistent memory, multi-profile isolation, and messaging platform integration. It does not reimplement Claude Code’s agent runtime. Instead, it acts as a message router and orchestrator—receiving inputs from platforms like Slack, assigning them to isolated profiles, launching or resuming dedicated Claude Code CLI workers per thread, and returning responses. Orb positions itself outside the agent loop: it handles routing, context assembly, profile boundaries, cron jobs, and permission relay, while leaving reasoning, memory management, and skill execution to the upstream CLI. This design allows Orb to stay lightweight and upgradable, since Claude Code updates land without requiring changes to Orb’s prompt stack or agent logic.

What it does

Orb provides several concrete capabilities layered around the native Claude Code CLI:

  • Multi-profile isolation: Each profile has its own scripts/, workspace/, and data/ directories. Workers launch with cwd set to profiles/{name}/workspace/, enabling separate CLAUDE.md configurations, skills, agents, and workspace state.
  • Slack Socket Mode adapter: Production-ready integration with Slack, using Socket Mode for real-time message delivery. Adapter boundaries allow future platforms (e.g., Discord, Matrix) to be added without touching core logic.
  • Holographic long-term memory: Stored in local SQLite, supporting fact extraction, trust scoring, time-based decay, and write-time arbitration—without relying on external vector databases.
  • DocStore full-text search: Built on SQLite FTS5, with automatic project slug inference from Slack thread context and registry-driven path mapping to workspace documents.
  • Cron scheduling and MCP permission relay: Per-profile cron-jobs.json files trigger fire-and-forget workers, with inflight guards to prevent overlapping runs; MCP (Model Context Protocol) requests from Claude Code—like file access or command execution approvals—are surfaced directly in Slack threads.

Getting it running

Orb requires Node.js 18+, Python 3.11+, a working Claude Code CLI installation (with authentication), and a Slack app configured for Socket Mode. It does not use Docker or containerized deployment—the runtime is local and process-based.

Start by cloning the repository and installing dependencies: 

git clone https://github.com/KarryViber/Orb.git
cd Orb
npm install
cp .env.example .env
cp config.example.json config.json

Then create a profile. The example shows setting up a profile named alice: 

mkdir -p profiles/alice/scripts
mkdir -p profiles/alice/workspace/.claude/skills
mkdir -p profiles/alice/data
cp profiles/example/workspace/CLAUDE.md profiles/alice/workspace/CLAUDE.md

Environment variables (e.g., SLACK_BOT_TOKEN, SLACK_APP_TOKEN) and configuration (e.g., adapter, profiles) must be filled in .env and config.json. After configuration, run: 

npm start

Orb will begin listening for Slack events. Sending a DM to the bot initiates a thread-specific worker. The first message triggers a Claude Code CLI session in profiles/alice/workspace/, and follow-up messages reuse that session via inject IPC—no full restart needed.

Who this is for

Orb suits developers and teams already using Claude Code CLI who want to expose agent capabilities through messaging interfaces without reimplementing memory, skills, or approval flows. It’s designed for users who value profile separation—such as managing distinct agents for documentation support, infrastructure automation, or internal tooling—while retaining full access to Claude Code’s native features: workspace skill auto-discovery, .claude/agents/ loading, and CLI-managed memory. Because Orb relies on local SQLite and filesystem layout rather than cloud APIs for memory or search, it fits teams prioritizing data locality and avoiding external dependencies. It is not aimed at beginners unfamiliar with Claude Code’s CLI conventions or those expecting a zero-config chatbot—it assumes familiarity with CLAUDE.md, skill registration, and workspace structure.

How it compares

Orb differs from general-purpose AI agent frameworks like LangChain, LlamaIndex, or AutoGen in that it does not abstract or replace the underlying agent runtime. It’s narrower in scope: a routing and persistence layer for one specific CLI. Compared to self-hosted chatbots like Ollama WebUI or AnythingLLM, Orb lacks a web interface, user-facing UI components, or document upload workflows—it only interfaces with Slack (for now) and expects users to manage workspace content manually. It’s also heavier than minimal Claude Code wrappers like simple shell scripts or cron-triggered CLI calls, due to its SQLite-backed memory system and thread-aware worker management. Unlike frameworks built around LLM orchestration (e.g., LangGraph), Orb makes no assumptions about agent topology—it defers all reasoning to Claude Code and focuses only on message routing and state persistence.

Orb has 51 stars on GitHub and is written in JavaScript. It does not require a database server, GPU, or cloud service—just Node.js, Python, and Claude Code CLI installed locally. If you want multi-profile Claude Code agents with Slack integration and local memory, this might fit. If you need a web UI, broad LLM support, or zero-configuration setup, Orb is not built for that. The source is at https://github.com/KarryViber/Orb.

View on GitHub →