npm.io
0.1.12 • Published 2d agoCLI

@rativiv/bob

Licence
—
Version
0.1.12
Deps
26
Size
9.5 MB
Vulns
0
Weekly
0
Install scriptsThis package runs scripts during installation (preinstall/install/postinstall)
SummaryDependencyVersions

Bob

Bob is a desktop IDE for orchestrating multiple AI coding agents locally.

Run local LM Studio models, Codex, Claude, Gemini, and OpenRouter-backed models side-by-side from a single workspace, with separate panels, shared project context, and an optional orchestrator for longer-running agent workflows.

Bob lets developers treat AI agents like a team: design with one, code with another, review with a third — including fully local models that never leave your machine.

Screenshot

Bob UI

Additional screenshots:

Features

  • Run multiple AI agent sessions simultaneously
  • LM Studio as a first-class local provider — agentic tool loops tuned for weak local models (inline tool-call parsing, loop guards, bounded budgets)
  • Compare models side-by-side in split or grid layouts
  • Orchestrate workflows between agents from a shared workspace
  • Works with existing CLI tools such as Codex, Claude Code, and Gemini CLI
  • Supports OpenRouter for API-based model access
  • Local-first architecture: your code stays on your machine
  • Durable Project Journey memory for API-backed agents: retains the goal, active artifacts, verified changes, feedback, and incomplete work across tool rounds and reconnects
  • Semantic codebase search over a local embedding index, scoped project rules, safe notebook editing, vision-model image reading, and a sandboxed local browser preview
  • Multi-window agent and workspace management
  • Built for developers, with explorer, Git, settings, and streaming chat timelines

Why Bob?

Most AI coding tools operate one agent at a time.

Bob is designed for parallel, role-based workflows where different agents handle different parts of the job while staying anchored to the same codebase.

Example workflow:

  • Architecture agent: designs the solution
  • Coding agent: implements the change
  • Review agent: validates behavior and catches regressions

All running in parallel from one desktop workspace.

Bob is also pragmatic about provider choice. You can run models entirely locally through LM Studio, use the CLI tools you already pay for, or route requests through OpenRouter when you need broader model coverage.

Durable project memory for local models

Local models have finite working context: sending every old message, tool trace, and file on every turn makes them slower and more likely to lose the thread. Bob keeps a compact, local Project Journey ledger for API-backed agent sessions instead. It tracks the original goal, active artifacts, recent changes, user feedback, browser/test evidence, and unfinished checklist work.

Before each next step, Bob supplies the model with the relevant project state and lets the model request the code or tools it needs. This makes a session behave as a coherent project journey without claiming unlimited model context or silently sending an entire workspace to a provider. It is especially useful with models served locally through LM Studio, where context length consumes system and GPU memory.

Installation

Bob currently runs by cloning the repository locally.

Requirements:

  • Node.js >=20 <27 (Node 22 LTS recommended)
  • npm
  • Optional provider setup:
    • LM Studio (local server on port 1234)
    • Codex CLI
    • Claude CLI / Claude Code
    • Gemini CLI
    • OpenRouter API key

Clone and run in development:

git clone https://github.com/rativiv/Bob.git
cd Bob
npm install
npm run dev

Build a desktop package:

npm run build

Releases:

CLI sanity check after installing providers:

codex --version
claude --version
gemini --version

If the postinstall step reports that a native rebuild was skipped, the embedded terminal will usually still work via prebuilt binaries. Source rebuilds are only needed on platforms where prebuilds are unavailable.

Architecture

Bob acts as a local orchestration layer for AI agent processes and provider integrations.

      Bob Desktop UI
        |
        v
  Workspace + Panel Manager
        |
        v
 Provider / Agent Runtime Layer
   |       |        |        |        |
   v       v        v        v        v
LM Studio Codex   Claude   Gemini  OpenRouter
  API      CLI      CLI      CLI       API

At a high level:

  • src/ contains the React renderer UI for panels, workspace tools, chat, and layout management
  • electron/main/ manages desktop runtime concerns, provider clients, permissions, updates, and local orchestration
  • electron/preload/ exposes the desktop bridge between the Electron main process and the renderer
  • The optional orchestrator plugin extends Bob with autonomous agent loops, shared state, and goal persistence
  • API-backed agent paths use the Project Journey ledger to persist structured task state locally and assemble focused continuity context for the next model request

Bob is local-first by design. Agent processes run on your machine, workspace context stays in your environment, and provider authentication remains with the CLI tools or API keys you configure.

Roadmap

Current capabilities:

  • Multi-agent workspace
  • LM Studio local-model agent loops with weak-model hardening
  • CLI integration for Codex, Claude, and Gemini
  • OpenRouter model access
  • Local orchestration and workspace-aware context
  • Semantic codebase search, project rules, notebooks, vision, and browser preview
  • Windowed desktop UI with split layouts and workspace tooling

Planned improvements (see docs/CHUNK4_PLAN.md):

  • Token-aware context accounting and automatic compaction
  • Durable run state with resume after restart
  • Automatic model routing
  • Subagents, checkpoints, and rollback

Contributing

Contributions and feedback are welcome.

Open an issue or submit a pull request if you want to help improve Bob.

Additional docs: