Vis Series

VisBoard

Open Source

Shared workspace where agents and humans plan, write, and ship together. Notes, checklists, files, MCP server.

Quick start

Start with the primary command, then continue with the full workflow below.

git clone https://github.com/LatticeAG/VisBoard.git

Problem

AI agents have no persistent workspace. Every session starts from scratch — no shared notes, no checklists, no stored context. When multiple agents work on the same project (Hermes, Codex, Claude Code, Cursor), each one independently reconstructs its understanding of the project, duplicates effort, and loses cross-agent knowledge. There is no primitive for an agent to leave a note for itself ('I was investigating the auth bug in module X, the stack trace is Y'), no way for one agent to see what another agent was working on, and no structured medium for human-agent collaboration that isn't either a chat window (ephemeral, unstructured) or a project management board (designed for humans, wasteful for agent context windows). Existing tools are either too structured (kanban boards with rigid fields) or too unstructured (chat logs with no versioning or search).

Solution

VisBoard is a shared workspace designed from the ground up for agents and humans to plan, write, and ship together. It provides versioned markdown notes (each edit creates a version with ETag concurrency control — no silent overwrites), checklist tracking (items with states, assignees, and completion timestamps), file storage (upload and associate any file with a note or checklist), and agent-scoped API keys so each agent has its own identity on the board. Changes stream in real time via SSE /events/stream — agents subscribe and react without polling. An MCP server (@visboard/mcp) exposes the full board model through the Model Context Protocol, letting Cursor and Claude Desktop connect directly without REST boilerplate. The /context endpoint returns a compact project snapshot optimized for agent context windows. Self-hostable via Docker Compose, zip export/import for portable workspaces, and each project auto-generates an AGENTS.md defining its conventions.

How it works

Create a project board via CLI or web UI. The board starts with versioned markdown notes, checklists, and file storage — structured for how agents reason, not for human project managers. Each board has a compact identity used in API calls and MCP configuration.

Agents connect to the board via either the MCP server or the REST API. Each agent gets a scoped API key tied to its identity — its notes, checklist items, and file uploads are tagged with its agent_id. This lets multiple agents share the same board without stepping on each other.

Changes propagate in real time via SSE /events/stream. When any agent or human edits a note, flips a checklist item, or uploads a file, every subscriber receives the diff immediately. Agents react to events without polling — a checklist completion event can trigger the next workflow step automatically.

The /context endpoint is designed specifically for agent context budgets. Pass ?project=sprint-24&max_tokens=4000 and it returns a compact, structured snapshot: board title, active notes, incomplete checklists, recent file uploads, and the workspace AGENTS.md protocol. No sidebar state, no UI chrome, no wasted tokens.

Workspaces are portable. visboard export creates a zip file of the board including all note versions, checklist state, file attachments, and API key configurations. visboard import restores it on another instance — for moving between self-hosted and SaaS, or sharing board templates across teams.

Each project automatically generates an AGENTS.md file that defines the workspace conventions. When an agent connects to this project, it reads AGENTS.md and learns the project's rules, tool naming conventions, and workspace etiquette — like a README for how agents should behave on this board.

Technical architecture

Each handoff carries structured context through the product's execution path. Hover a node to inspect its role.

Project Board

Step 1: Project Board receives structured context from the prior stage and prepares it for the next handoff.

Agent Connect (MCP)

Step 2: Agent Connect (MCP) receives structured context from the prior stage and prepares it for the next handoff.

SSE Event Stream

Step 3: SSE Event Stream receives structured context from the prior stage and prepares it for the next handoff.

Context API

Step 4: Context API receives structured context from the prior stage and prepares it for the next handoff.

Portable Workspace

Step 5: Portable Workspace receives structured context from the prior stage and prepares it for the next handoff.

AGENTS.md Protocol

Step 6: AGENTS.md Protocol receives structured context from the prior stage and prepares it for the next handoff.

When to use

Multi-agent teams working on the same project who need a persistent shared context that survives individual agent sessions.
Agent development workflows where you want to leave notes between sessions — a lab notebook for your agent that persists across invocations.
Teams designing autonomous agent collaboration workflows that need structured workspace primitives (notes, checklists, files, event streams).
Human-agent collaboration on complex tasks — a shared board where humans set priorities and agents report progress with live event streaming.
Project onboarding for new agents — the pre-populated board and AGENTS.md give the agent immediate project context without manual briefing.

Not for

Traditional project management workflows (sprints with story points, kanban with WIP limits, Gantt charts, burndown reports) — VisBoard is designed for how agents think, not for human PM tooling.
Single-agent, single-session tasks where a scratchpad or a local text file is sufficient — VisBoard's workspace overhead is unjustified for ephemeral work.
High-frequency real-time collaboration where sub-10ms latency is required — SSE event distribution adds a small overhead compared to local IPC.

Features

Versioned markdown notes with ETag concurrency control — no silent overwrites, every edit is recoverable

Checklist tracking with item states, assignees, and completion timestamps

File storage — upload and attach files to notes and checklists

Agent-scoped API keys — each agent has its own identity on the board

SSE /events/stream for real-time reactivity — agents subscribe and react without polling

MCP server (@visboard/mcp) — agents connect directly without REST boilerplate

Compact /context endpoint with token-budgeted responses, optimized for agent context windows

Portable workspaces with zip export and import — move between self-hosted and SaaS

Auto-generated AGENTS.md per project — defines workspace conventions for every connecting agent

Self-hostable via Docker Compose — MIT licensed

Install and usage

usage.sh

# Start VisBoard with Docker
git clone https://github.com/LatticeAG/VisBoard.git
cd VisBoard
docker compose up

# Create a project and API key via CLI
visboard project create --name "Sprint 24"
visboard apikey create --project "Sprint 24" --agent "codex"

# Agents connect via MCP (Cursor, Claude Desktop)
# Add to your MCP config:
{
  "mcpServers": {
    "visboard": {
      "command": "npx",
      "args": ["@visboard/mcp"],
      "env": { "VISBOARD_API_KEY": "sk-xxx" }
    }
  }
}

# Or use the REST API directly
curl http://localhost:3000/context?project=sprint-24&max_tokens=4000
# -> { "title": "Sprint 24", "notes": [...], "checklists": [...], "files": [...] }

# Export a workspace
visboard export --project "Sprint 24" --output sprint-24.zip

# Import on another instance
visboard import --file sprint-24.zip

Architecture explorer

Problem

Solution

View on GitHub

VisBoard

Quick start

Problem

Solution

How it works

Technical architecture

When to use

Not for

Features

Install and usage

Architecture explorer

Problem

Solution

Related products