Kondi MCP server
Commit Oct 17, 2026Build multi-LLM workflow pipelines using deliberating councils of specialized AI agents that execute tasks through MCP-connected tools.
Also known as thisPointOn/kondi
- Stars
- 5
- Tools
- 4
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Oct 17, 2026
- License
- MIT
What is Kondi MCP?
Kondi builds multi-LLM workflow pipelines using deliberating councils of specialized AI agents that execute tasks through MCP-connected tools. It exposes 4 tools, such as read_file, write_file, list_directory.
Summary generated from the project's README
About Kondi MCP server
Building multi-LLM workflow pipelines using deliberating councils of specialized AI agents is what Kondi enables for developers. This open-source desktop application allows you to move beyond single model prompts by convening groups of personas—such as managers, consultants, and reviewers—to debate and execute complex tasks. You can mix and match models from providers like Anthropic, OpenAI, DeepSeek, and NVIDIA NIM within a single visual graph, assigning different models to specific roles in a council.
Users connect the application to local or remote MCP servers to give agents functional capabilities. It includes a built-in library of nine platform servers providing over 120 tools for services like GitHub, Slack, Discord, and X. The system uses a deterministic state machine to manage structured deliberation, ensuring that outputs are verified against reality through shell-script checks or git status rather than just relying on model prose. You bring your own API keys or use local models via Ollama to power your workflows.
What you can do with it
- 1Automated code review and debuggingA developer can set up a coding council that decomposes specifications, implements code in parallel, and runs a loop of review and testing.
- 2Verifying technical outputs with real testsInstead of trusting a model's word, you can use script steps to ensure a coding council's work actually passes functional requirements.
Written from the project's README. Every use case is checked against a quote from it.
Kondi MCP tools 4
Detected from the READMEread_filewrite_filelist_directoryrun_command
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablethispointon/kondi is public and reachablegithub.com/thispointon/kondi ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-10-17github.com/thispointon/kondi ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model4 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubKondi
Kondi is a free, open-source desktop app for building multi-LLM workflow pipelines — visual graphs where every step is a deliberating council of models from any provider (Claude, GPT, DeepSeek, NVIDIA NIM, and more), wired together with human gates, real script checks, and loops that carry feedback.
Single models are sycophantic. Councils are honest.
Chained prompts trust the previous step blindly, and one model mostly agrees with itself. A Kondi step runs a structured debate instead — a manager frames the problem, consultants argue it, a worker delivers, reviewers check — and the whole run is auditable, verified against reality (file output checked against git, not the model's prose), and fails loudly instead of faking success.
Free · no account · no fees. Bring your own API keys — or run an entire multi-model council for $0 on NVIDIA NIM free credits.
What makes it different
- Councils, not single calls — every step is a manager / consultants / worker / reviewer deliberation, and you pick which model plays each seat.
- Any provider in one graph — Anthropic, OpenAI, DeepSeek, xAI, Z.AI, Moonshot, NVIDIA NIM, Ollama — per persona, per step. Even the
claudeandcodexCLIs as tool-wielding coding workers. - Control flow that argues back — parallel branches with strict joins, human approval gates, shell-script checks, and conditions that loop back to an earlier step carrying exactly why it was sent back.
- Proof over plausibility — script steps run your tests for real; a coding council's file output is verified against
git status; a worker that only narrates success yields a failed council, not a fake one. - Free & open source — MIT-licensed, desktop, your keys. Run whole councils on free NVIDIA credits with no card.
See it proven, end to end
Four showcase pipelines run with real models, every step's output inspected and verdicted — including the failures that became engine fixes. Step tables, real run excerpts, and honest verdicts:
Features at a Glance
| Feature | What It Does |
|---|---|
| Multi-Provider LLM Support | 10 providers, 40+ models, CLI and API paths |
| Chat | Multi-chat with file attachments, tool calling, per-chat working directories |
| MCP Server Integration | Connect any MCP server — remote, local, or from the built-in library |
| Built-in Platform Servers | 9 servers with 120+ tools for social media, Git, and more |
| Council System | Council modes (council, code_planning, coding, review, enrich, analysis, agent) with persona templates; generate a council from chat |
| Structured Deliberation | Deterministic state machine with context versioning and audit trail |
| Coding Orchestrator | Spec decomposition, parallel implementation, code review, test, debug loop |
| Pipelines | Multi-stage workflows chaining councils, coding, LLM calls, and human gates |
| CLI Pipeline Runner | Run pipelines headlessly from the terminal |
| Search Service | Bundled SearXNG web search and content extraction |
| Built-in Tools | File access and shell commands, always available |
Multi-Provider LLM Support
Each persona in a council can use a different provider and model. Ten providers with two access paths:
| Provider | CLI (Subscription) | API (Key) |
|---|---|---|
| Anthropic | Opus 4.6, Sonnet 4.5, Haiku 4.5, Opus 4.5, Sonnet 4 | Sonnet 4.5, Haiku 4.5, Sonnet 4 |
| OpenAI | GPT-5.5, GPT-5.5 Pro, GPT-5.4 / Mini / Nano, GPT-5.3 Codex, GPT-5.2 Codex | GPT-5.4 / Mini / Nano, GPT-4o, o1 |
| DeepSeek | -- | V4 Pro (reasoning), V4 Flash |
| Gemini CLI | Gemini 2.5 Pro/Flash, 2.0 Flash | |
| xAI | -- | Grok 3, Grok 3 Fast, Grok 3 Mini |
| Z.AI | -- | GLM 5.1, GLM 4.6, GLM 4.5 Flash/Air |
| Moonshot (Kimi) | -- | Kimi K2.6 (vision), Kimi K2.7 Code, Kimi K3 (1M context) |
| NVIDIA NIM | -- | Nemotron 3 Ultra 550B / Super 120B / Nano 30B, DeepSeek V4 Pro, GLM 5.2, GPT-OSS 120B — free developer credits |
| Ollama | -- | Any locally-running model (auto-discovered) |
CLI providers spawn the locally installed binary (claude --print, codex exec) as a subprocess and use your existing subscription — no API key needed. OAuth tokens from CLI tools only work through their own binaries (server-side client attestation), so the app proxies through them rather than calling the API directly. Multi-turn chat sessions use --resume (Claude) / resume --last (Codex) to maintain conversation state without resending history. The app auto-detects installed CLIs at startup and validates connectivity. Ollama models are discovered automatically when the Ollama server is running.
Run a council for free (NVIDIA NIM)
NVIDIA's build.nvidia.com gives developers free API credits for hosted frontier open models — no credit card, key in about two minutes. Kondi ships a curated NIM catalog (every model verified with real streaming completions, because NIM's /models list advertises some that don't work) and a built-in nvidia routing profile that runs a full multi-model council on that single free key:
- Nemotron 3 Ultra 550B plans and makes decisions
- GLM 5.2 writes the code
- DeepSeek V4 Pro reviews it
- Nemotron 3 Nano 30B handles compression and housekeeping
Paste your nvapi-* key in Settings → Providers → NVIDIA NIM, then pick Smart Routing: nvidia (route:nvidia) anywhere a model can be selected. NIM's API doesn't allow browser calls (no CORS), so Kondi relays requests through its Rust backend with live token streaming intact.
Chat
- Streaming markdown responses with syntax-highlighted code blocks
- MCP tool calling — connected server tools execute inline with expandable result blocks
- File attachments — drag-and-drop support for 30+ file types
- Shell-like input history — Up/Down arrow to cycle through previous messages
- Tool autocomplete — type
@to browse and insert available tools - Per-chat working directories — each chat can target a different project folder
- Context compression — changing working directory mid-chat automatically compresses previous messages
- Multi-chat — up to 20 persistent conversations with recency sorting
- Per-session model switching — change provider/model without affecting your defaults
MCP Server Integration
Connect agents to any MCP server through four paths:
- Remote servers via SSE/HTTP — enter a URL, Kondi probes for auth requirements automatically
- Local servers via stdio — launch npm packages, Python scripts, or any executable
- Built-in server library — browse and one-click install popular servers (GitHub, Slack, PostgreSQL, Notion, Linear, Brave Search, and more)
- GitHub install — paste a GitHub repo URL to auto-fetch, install, and connect
Authentication proxy: For OAuth-protected servers, Kondi spawns a local Node.js proxy per server that handles PKCE browser flows, dynamic client registration, token refresh, and retry logic. Proxy config stored at ~/.local/share/kondi/proxies/.
Credential management: Built-in servers display token input fields directly in the Tools panel. Enter your API key or bot token, save, and connect — no env vars or config files needed.
CLI tool sync: Connected MCP servers are automatically proxied to localhost and synced to Claude Code (~/.claude.json) and Codex (~/.codex/config.toml) tool configurations. The unified router calls ensureProxiesForServers() before each LLM call to guarantee proxies are running and synced. CLI-based agents connect to the local proxy endpoints transparently.
Built-in Platform Servers
Nine MCP servers ship with Kondi, providing 120+ tools across social platforms, messaging, and version control. Each server starts disconnected — add your API token in the Tools panel and connect.
X / Twitter (13 tools)
Post tweets, search, get mentions, like/unlike, retweet, look up users, view followers and following.
Discord (13 tools)
Send/edit/delete messages, list channels and guilds, manage reactions, create threads, pin messages, list members.
Slack (16 tools)
Post/update/delete messages, search messages, list channels and users, manage reactions and pins, get thread replies.
LinkedIn (10 tools)
Create/get/delete posts, view profile and connections, manage comments and likes, get organization info.
Facebook (12 tools)
Post to pages, manage comments and reactions, view page/post insights, publish photos, get page info.
Instagram (11 tools)
Publish photos, view/reply to comments, search hashtags, get account and post insights, manage stories.
Reddit (14 tools)
Submit posts and comments, search, view subreddit info and rules, vote, get user profiles, save content.
Telegram (15 tools)
Send messages/photos/documents, edit/delete/forward messages, send polls and locations, manage chat settings.
Git (15 tools)
Full local git operations: status, log, diff, show, branch, checkout, add, commit, push, pull, stash, blame, remote, tag, merge.
Council System
Councils are groups of AI personas that collaborate on a task. Each persona has a name, avatar, color, system prompt, LLM assignment, stance (advocate/critic/neutral/wildcard), domain expertise, interaction style, temperature, verbosity, and optional MCP server restrictions.
15 built-in persona templates across four categories:
| Category | Templates |
|---|---|
| Strategic | Devil's Advocate, Optimist, Pragmatist, Visionary, Customer Voice |
| Technical | Security Hawk, Performance Nerd, Simplicity Advocate, Scale Thinker |
| Creative | Wild Card, Editor, Audience Advocate |
| Domain Expert | Finance Mind, Legal Eagle, Data Scientist |
Seven council modes:
| Mode | Pattern |
|---|---|
| Deliberation | Structured Manager -> Consultants -> Worker workflow with phases |
| Debate | Personas argue opposing positions |
| Build | Collaborative — personas add to each other's ideas |
| Review | One presents, others critique |
| Synthesis | Each gives perspective, then combine |
| Socratic | One questions, others defend |
| Freeform | Natural conversation |
Turn strategies: round-robin, react, popcorn, volunteer, moderator, parallel, relevance.
Structured Deliberation
The deliberation orchestrator is a deterministic state machine:
Problem Framing -> Independent Analysis -> Interactive Rounds -> Decision -> Directive -> Execution -> Review
| | | | | | |
Manager Consultants Consultants Manager Manager Worker Manager
Phases:
- Problem Framing — Manager creates the shared context document (v1)
- Independent Analysis — Round 1: each consultant analyzes independently
- Interactive Rounds — Round 2+: consultants see and engage with each other's analysis
- Deciding — Manager synthesizes all input into a final decision
- Directing — Manager writes a concrete work directive for the worker
- Executing — Worker carries out the directive (optionally with file write permissions)
- Reviewing — Manager evaluates output, accepts or sends back for revision
Context versioning: Consultants propose patches to the shared context document. The Manager accepts or rejects each one, incrementing the version. All proposals are recorded. Enable Evolve Context to automatically append consultant findings and worker results to the context document as the deliberation progresses (v1 → v2 → v3...).
Append-only ledger: Every agent invocation, phase transition, and artifact change is recorded with timestamps, token counts, latency, and cost estimates.
Configuration: min/max rounds, max revisions, execution order (parallel/sequential), context token budget, decision criteria, expected output, soft word limits per response.
Live controls: Pause/resume, force decision (skip remaining rounds), abort, send a message while paused.
Coding Orchestrator
A specialized orchestrator for software implementation:
Decompose Spec -> Implement Modules -> Code Review -> Test -> Debug Loop
| | | | |
Manager Worker(s) Reviewer Build+Test Worker
- Decompose — Manager breaks the spec into modules with files, interfaces, dependencies, and per-worker directives
- Implement — Workers implement their assigned modules with file write permissions
- Code Review — Reviewer evaluates output with severity ratings (critical/major/minor)
- Test — Runs install + build + test commands; captures stdout/stderr/exit codes
- Debug — Worker fixes failures in a loop (configurable max cycles)
Auto-detection: If no commands are configured, the orchestrator scans the working directory for tooling:
- Install: pnpm -> yarn -> npm (lockfile priority), pip, go mod, Makefile
- Build: package.json scripts, tsconfig, Cargo.toml, go.mod, Makefile
- Test: vitest/jest/mocha, cargo test, go test, pytest, Makefile
Safeguards: Git snapshot before changes, dependency verification before build, build verification before tests.
Pipelines
Chain councils, coding steps, LLM calls, and human checkpoints into automated workflows:
+--------------+ +--------------+ +---------+ +--------------+
| Council: |---->| Coding: |---->| Gate: |---->| Council: |
| Research & | | Implement | | User | | Review & |
| Plan | | Solution | | Approve| | Finalize |
+--------------+ +--------------+ +---------+ +--------------+
Step types:
- council / code_planning / coding / review / enrich — full deliberation (or coding) councils
- analysis / agent — the same deliberation workflow as a smaller council (no skipped phases)
- script — run a shell command, capture stdout
- condition — evaluate an expression and
continue/skip_next_stage/stop/loop_to_stage(rewind to an earlier stage and re-run, bounded by a max-loops budget — for iterative refine→review loops) - gate — pause for human approval
Stages run sequentially; steps within a stage run in parallel. Artifacts flow between steps via template variables ({{input}}, {{input.field}}, {{input[N]}}, {{file}}). Each artifact includes provenance headers so downstream steps know where context came from. Output types: string, json (field-addressable downstream), file, directory.
Pipeline builder: Visual stage/step layout, drag-to-reorder, per-step persona/model/tool/directory configuration, output type annotations (string, file, directory).
CLI Pipeline Runner
Run pipelines headlessly from the terminal:
npx tsx cli/run-pipeline.ts <pipeline.json> [--working-dir <path>] [--model <model>] [--dry-run]
- Uses the same orchestrators as the GUI
- Auto-routes to Claude CLI or Codex CLI based on model name
- Colored terminal output with timestamps
- JSON execution report on completion
- Session export (
.kondi-session.json) for import back into the GUI - Per-persona session persistence within council steps
Built-in Tools
Always available without any MCP server:
| Tool | Description |
|---|---|
read_file |
Read file contents (relative or absolute paths) |
write_file |
Create or overwrite a file |
list_directory |
List files and folders with metadata |
run_command |
Execute a shell command in the working directory |
All operations scoped to a configurable working directory. Enable Directory Constrained mode to confine agent writes to that directory (reads are still allowed for context). Containment is hard-enforced, not advisory: the working dir is git init-isolated so the Claude CLI can't adopt a parent repo as its project, and a PreToolUse hook denies any write resolving outside the dir (the Codex CLI uses its native workspace-write sandbox). Agents can read the codebase for grounding but cannot escape the working directory.
Search Service
Bundled SearXNG-backed search MCP server with Docker lifecycle management:
web_search— Search the web across categories (general, news, images, science, social media) with time range and language filtersweb_fetch— Fetch a URL and extract readable content via Mozilla Readability
Start/stop/restart from the Services panel. Requires Docker.
Tech Stack
| Layer | Technology |
|---|---|
| Desktop Runtime | Tauri 2.9 (Rust) |
| Frontend | React 19, TypeScript, Vite 7 |
| Backend | Rust (tokio, reqwest, serde) |
| MCP Proxy | Node.js, Express |
| Search Server | Node.js, SearXNG, Readability |
| Styling | Tailwind CSS, PostCSS |
Installation
Prerequisites
| Requirement | Version | Notes |
|---|---|---|
| Node.js | 18+ | Frontend, proxy, CLI runner |
| Rust | 1.77.2+ | Tauri backend |
| Tauri CLI | 2.x | cargo install tauri-cli |
| System deps | -- | See Tauri prerequisites |
Linux (Debian/Ubuntu):
sudo apt update
sudo apt install libwebkit2gtk-4.1-dev build-essential curl wget file \
libxdo-dev libssl-dev libayatana-appindicator3-dev librsvg2-dev
macOS:
xcode-select --install
Windows: Install Microsoft C++ Build Tools and WebView2.
Install a Release (recommended)
Download the installer for your platform from the latest GitHub Release — no build required:
| Platform | File | Install |
|---|---|---|
| Windows | Kondi_*_x64-setup.exe (or _x64_en-US.msi) |
Double-click → install. |
| macOS (Apple silicon) | Kondi_*_aarch64.dmg |
Open the .dmg, drag Kondi to Applications. |
| Linux (portable) | Kondi_*_amd64.AppImage |
chmod +x Kondi_*.AppImage && ./Kondi_*.AppImage |
| Linux (Debian/Ubuntu) | Kondi_*_amd64.deb |
sudo apt install ./Kondi_*.deb |
| Linux (Fedora/RHEL) | Kondi-*-1.x86_64.rpm |
sudo dnf install ./Kondi-*.rpm |
Releases are currently unsigned (code-signing certs not yet configured), so the OS warns on first launch. The app is safe — these steps dismiss the warning:
- Windows: SmartScreen → More info → Run anyway.
- macOS: a plain double-click may say "Kondi is damaged and can't be opened" (Gatekeeper quarantine on unsigned apps). Either right-click the app → Open → Open, or clear the quarantine flag once:
xattr -dr com.apple.quarantine /Applications/Kondi.app- Linux: none. The
.deb/.rpmpull in their deps (libwebkit2gtk-4.1-0,libgtk-3-0); for the.AppImagethose libs must be present, plus FUSE (sudo apt install libfuse2) — or run it with--appimage-extract-and-run.
Notes:
- macOS ships Apple-silicon only right now; an Intel (
x64).dmgisn't built yet. - Signing/notarization (removes the warnings entirely) is documented in
docs/RELEASING.md— add the certs as repo secrets and it's automatic.
Build from Source
git clone git@github.com:thisPointOn/kondi.git
cd kondi/mcp-connect-mvp
# Install frontend dependencies
npm install
# Build the MCP proxy (spawned when connecting to authenticated servers)
cd kondi-mcp-proxy && npm install && npm run build && cd ..
# Development mode (hot-reload)
npm run tauri:dev
# Production build
npm run tauri build
# Output: src-tauri/target/release/bundle/ (.deb, .rpm, .AppImage on Linux)
(Optional) Built-in MCP Servers
The built-in platform servers (X, Discord, Slack, etc.) are bundled at ~/.local/share/kondi/mcp-servers/ on install. For development, they resolve from the repo root. Each server needs npm install && npm run build if building from source.
(Optional) Search Service
cd kondi-search-mcp
docker-compose up -d # Start SearXNG on port 8888
npm install && npm run build
Connect from the Services panel in the app.
Quick Start
- Launch —
npm run tauri:devfrommcp-connect-mvp/ - Configure a provider — Settings -> LLM Providers -> add an API key or sign in via CLI
- Chat — Start a conversation. Connected MCP tools execute inline.
- Connect tools — MCP Servers panel -> add servers or use built-ins
- Build a pipeline — Sidebar -> Pipelines -> New Pipeline. Every step is a council; drop steps on the graph.
- Configure each step — pick the step type, seat personas/models, set the task and expected output
- Wire the flow — add gates, script checks, and conditions that loop back with feedback
- Run — launch it and watch each council deliberate in the ledger, then the verified results
- Import the examples — one click, from the Pipelines library (see kondi.ai/#/examples)
Configuration
LLM Providers
| Provider | What You Need |
|---|---|
| Anthropic CLI | Claude Code installed and logged in |
| Anthropic API | API key from console.anthropic.com |
| OpenAI CLI | Codex CLI installed and logged in |
| OpenAI API | API key from platform.openai.com |
| DeepSeek | API key from platform.deepseek.com |
| Gemini CLI installed, or API key | |
| xAI | API key from console.x.ai |
| Moonshot (Kimi) | API key from platform.moonshot.ai |
| Ollama | Ollama running locally on port 11434 |
API keys are stored locally and only sent to the provider's own endpoint. CLI providers use the tool's existing authenticated session.
Kondi MCP questions
What tools does Kondi MCP provide?
It exposes 4 tools, including read_file, write_file, list_directory, run_command.
How does Kondi handle MCP server integration?
You can connect to remote servers via SSE/HTTP, local servers via stdio, use the built-in library, or install directly from a GitHub repository URL.
Can I use different AI providers within a single workflow?
Yes, each persona in a council can use a different provider and model, including Anthropic, OpenAI, DeepSeek, Google, xAI, and more.
Does Kondi require an account or subscription fees?
No, Kondi is a free, open-source desktop app that requires no account and no fees; you bring your own API keys.
How are OAuth-protected MCP servers handled?
Kondi spawns a local Node.js proxy per server to manage PKCE browser flows, token refresh, and retry logic.