Contorium

by ContoriumLabs

352 downloads

Not rated

GitHub

About

Runtime continuity layer MCP for AI coding agents, providing persistent workspace state and session context across tools and runs.

Details

Author: ContoriumLabs
Downloads: 352
Categories: Developer Tools, Automation, Productivity, Other, AI

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Contorium

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

From the repository

—

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "contorium": {
            "contorium": {
                "command": "npx",
                "args": [
                    "@contorium/mcp"
                ],
                "env": {
                    "CONTORIUM_WORKSPACE": "/path/to/project"
                }
            }
        }
    }
}

McpServers

{
    "contorium": {
        "command": "npx",
        "args": [
            "@contorium/mcp"
        ],
        "env": {
            "CONTORIUM_WORKSPACE": "/path/to/project"
        }
    }
}

Project Intelligence Layer for AI-assisted development.

But it doesn't always knowwhy your project became what it is.

Contorium gives AI coding tools a persistent layer of project intelligence — preserving decisions, reasoning, constraints, structure, history, and evolving project state across sessions, tools, and models.

Not chat history. Not prompts. Project intelligence.

Website·Documentation·Overview·Decision Evolution & Retrieval

Git remembers what changed.
Contorium remembers why.

AI coding agents are getting better at writing and modifying code.

But long-lived projects have another problem:

The codebase contains what the project is — but not always why it became that way.

- AI sessions
- different coding tools
- model switches
- experiments and failed approaches
- architectural decisions
- long development cycles

Eventually, developers end up explaining the same project to AI again and again.

You should be building the project — not repeatedly explaining it.

Intent ↓ Decisions ↓ Reasoning ↓ Implementation ↓ Outcomes ↓ Evolution ↓ Current State

Contorium preserves and connects this information so AI tools can work from the project's accumulated understanding instead of reconstructing it from scratch every session.

Decisions
What was chosen, rejected, or changed?

Reasoning
Why was a particular approach taken?

Constraints
What must remain true, and why?

Structure
How are the project's modules, files, and functions connected?

Current State
What matters now, and what should happen next?

One Project. One Intelligence Layer. Every AI Tool.

Your project's accumulated understanding shouldn't have to.

Your Project │ ▼ ┌──────────────────────┐ │ Contorium │ │ │ │ Project Intelligence │ │ Layer │ └──────────┬───────────┘ │ ┌──────────┼──────────┐ ▼ ▼ ▼ Cursor Claude Codex │ Code │ │ │ │ └──────────┼──────────┘ ▼ Shared Understanding

Use the tools you prefer without forcing each one to reconstruct the project from zero.

- Cursor
- Claude Code
- Gemini CLI
- Codex
- VS Code
- MCP-compatible AI tools

- sessions
- tools
- model switches
- long development cycles

Contorium builds structured relationships across the project:

Intent ↓ Module ↓ File ↓ Function ↓ Dependency

Instead of treating a repository as a collection of disconnected files, Contorium builds a queryable representation of how the project fits together.

Track the changes that matter and connect them to the project's broader state.

Preserve the knowledge that is usually lost after a conversation ends:

- what was decided
- what alternatives were considered
- why an approach was chosen
- what happened afterward

This helps future AI sessions understand not onlywhat exists, butwhy.

Projects evolve. Knowledge becomes outdated.

Contorium tracks whether decisions still hold:

Change → Assumption → Impact → Decision Validity

VALID → WARNING → DECAYING → SUSPECTED_INVALID → NEEDS_REVALIDATION → INVALIDATED

contorium ask "What decisions need review?"

Generate a compact representation of the project's current state for AI handoff.

New session ↓ Read everything again ↓ Reconstruct context ↓ Start working

New session ↓ Read project intelligence ↓ Understand current state ↓ Continue working

Contorium makes project intelligence accessible to both developers and AI agents.

contorium ask "Why was MCP added?" contorium ask "What changed recently?" contorium ask "What do we know about authentication?" contorium ask "Is this decision still valid?"

It is connecting the relevant pieces of project knowledge.

Workspace Activity ↓ Collection ↓ Parsing ↓ Project Structure ↓ Knowledge Graph ↓ Intent & State ↓ Project Intelligence ↓ AI-ready Context / Handoff ↓ Any AI Tool

Contorium stores project intelligence locally inside:

The project carries its own accumulated understanding instead of tying it to a particular AI provider or session.

Contorium separates project intelligence from the AI tool using a local, structured architecture.

AI Tools (Cursor · Claude · Codex · …) │ ▼ IDE · MCP · CLI (adapters) │ ▼ CIL — Cognitive Interaction Layer │ ▼ PIL — Project Intelligence Layer │ ▼ .contora/

CIL is theinteraction layerbetween AI agents, developers, and project intelligence.

It provides the mechanisms needed to query, capture, and transfer project knowledge.

It is architecture — not the product brand.

The deterministic local store of structured project intelligence:

STATE · INTENT · DECISION · WHY TIMELINE · IMPACT · PROVENANCE · CONFIDENCE

The intelligence stays with the project.

Deeper guides:docs/OVERVIEW.md·docs/PIL_RUNTIME.md·docs/CIL.md

contorium capture decision contorium inspect state contorium transfer context contorium ask "What is this project becoming?"

Contorium is related to AI memory — but it is not intended to be just another chat-memory or retrieval system.

What changed ↓ Why it changed ↓ What happened ↓ What remains true ↓ What comes next

Memory is a capability. Project Intelligence is the goal.

- an autonomous coding agent
- a replacement for your AI coding tool
- a task generator
- a system that decides what you should build
- a replacement for Git

Contorium preserves project understanding so humans and AI can work from the same evolving state.

- Node.js 18+
- npm
- VS Code / Cursor for the IDE extension
- An MCP-compatible AI tool for MCP integration

git clone https://github.com/ContoriumLabs/contorium.git cd contorium npm install npm run compile

- OpenExtensions
- SelectInstall from VSIX
- Choose the generated.vsix
- Reload the window
- Open your project
- Set the current focus
- Transfer AI-ready project context when needed

Full guide:docs/IDE_EXTENSION.md·docs/INSTALL.md

Expose project intelligence to MCP-compatible AI tools:

claude mcp add --scope project contorium -- npx @contorium/mcp

codex mcp add contorium -- npx @contorium/mcp

ask_project transfer_project inspect_state · inspect_intent · inspect_decision capture_focus · capture_note · capture_decision inspect_pending_decisions · commit_decision prepare_execution_context · get_project_context · explain_context get_knowledge_health · get_review_queue

Full guide:docs/MCP.md·packages/mcp/README.md

npx contorium init . npx contorium sync . npx contorium ask "What is this project?" npx contorium decisions detect npx contorium context build --task "…" npx contorium inspect npx contorium explain database npx contorium transfer context npx contorium lifecycle npx contorium review npx contorium status .

To remove the local project intelligence store:

Project understanding should survive sessions, tools, and model changes.

Relationships between decisions, code, intent, and history matter more than isolated text.

AI can understand the project. Humans decide what the project becomes.

Project intelligence should stay close to the project and remain portable.

Optional AI improves explanation, story, essence, and suggested questions.

AI is an interpreter — not the source of truth.

AI coding is moving beyond one-shot code generation toward long-running, multi-agent development.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

Project Intelligence Layer for AI-assisted development.

One Project. One Intelligence Layer. Every AI Tool.

Install

More like this

@mendableai/firecrawl Mcp Server

Umut Naci

Playwright

Time

Sentry

Github