100% free & open source · no account · your keys or free NVIDIA credits desktop llm orchestration · pipelines of councils

Don't prompt a model.
Convene a council.

Free and open source. Kondi is a desktop studio for assembling LLM workflow pipelines — visual graphs where every step is a deliberating council of models from any provider, wired together with human gates, mechanical checks, and loops that carry feedback. No fees and no account — bring your own API keys, or run councils on free NVIDIA credits. Built for work you need to be right, not just plausible.

Free forever · open source · macOS · Windows · Linux · run councils on free NVIDIA NIM credits

kondi — pipeline builder
Kondi's pipeline builder: a graph with a URL input node feeding a fact-extraction agent, two parallel analysis steps, a synthesis council, a word-count script, and a length gate with an amber loop-back edge; the side panel configures the URL input source and its instructions.
01 · deliberation

Steps that argue before they answer

A step isn't one prompt — it's a manager framing, consultants debating, a worker executing, reviewers checking. Every exchange lands in an auditable ledger.

02 · any provider

Mix nine providers in one graph

Claude next to GPT next to DeepSeek next to a free-tier NVIDIA NIM model — per persona, per step. Even full CLI coding agents sit inside steps as tool-wielding workers.

03 · verified

Proof over plausibility

Scripts run your tests for real. File claims are checked against git, not the model's prose. A council that fails says so — loudly.

§1The studio, at work

Real screenshots from real runs — the same pipelines published on the examples page.

assemble

Every step is a council — pick who sits at the table

Click a node and configure its deliberation: a manager on Nemotron, a worker on Claude, rounds and revisions bounded, the task and input contract explicit. Ten purpose-built step types cover councils, coding, analysis, gates, scripts, and looping conditions.

step config — council setup
A selected council step with its configuration panel: council name, max rounds and revisions, an Editor persona as manager and Writer persona as worker each with their own model, the step task, and input source.
deliberate

Watch the argument, entry by entry

Every framing, debate round, decision, and revision is a ledger entry with its persona, model, token count, and cost. Multi-step workflows show a step rail; you can drill into any step's full deliberation — and ask follow-ups after it completes.

deliberation — ledger
A completed deliberation: consultant and manager ledger entries with structured argument text, routing and token-count chips, a step rail across the top, and run stats — 25 comments, 95.4k tokens, 4 models.
verify

Results with receipts

Each step's card shows who ran it, on what models, for how long — and the actual deliverable, with the on-disk path it was saved to. Script steps show the machine's verdict, not the model's summary of it.

pipeline results — code factory
Pipeline results for the Code Factory example: an expanded implementation-plan step showing its personas and models, run duration, and the actual plan output saved to disk, followed by the gate, coding, and script stages.

§2Inside a step: the council

Chained prompts compound errors — each step trusts the last one blindly. A Kondi step runs a structured deliberation instead, and you choose which model plays each seat.

manager

Frames & decides

Turns the step's input into a precise problem statement, weighs the debate, commits to a decision, and directs the work.

consultants

Debate in rounds

Independent voices — a skeptic on one model, an advocate on another — argue positions before anything is built.

worker

Executes grounded

Delivers the output — text, JSON, files, or code — with the original source re-attached so summaries can't drift into fiction.

review

Checks & revises

The deliverable is reviewed against the declared expected output; revision rounds are bounded, never endless.

§3Control flow that argues back

Parallel branches with strict joins, human gates, shell-script checks, typed JSON between steps, real-world inputs (text, file, directory, live URL) — and conditions that loop back to an earlier step carrying exactly why it was sent back, bounded by a retry budget.

councilcodingcode_planninganalysisagent enrichreviewgatescriptcondition ↻

§4Every provider is a first-class citizen

No lock-in, no lowest-common-denominator wrapper. Each persona picks its own provider and model — credentials never silently fall over between providers.

Anthropic API Claude Code CLI OpenAI API Codex CLI DeepSeek xAI Grok Z.AI GLM Moonshot Kimi NVIDIA NIM Ollama (local)

Smart routing, per phase

Pick a budget profile instead of a model — each deliberation phase routes to a fitting tier. Profiles are editable and appear in every dropdown.

balancedqualitycheaporchestrabest-valuezainvidia

Free-credit councils

The NVIDIA NIM path serves curated Nemotron, DeepSeek, and GLM models on credit-based keys — iterate on multi-model councils without a USD meter.

CLI agents as workers

Put the actual claude or codex binary inside a step — a tool-wielding coding agent, write-contained to its working directory by a hardened guard.

§5Engineered against the confident lie

The failure mode of LLM workflows isn't crashing — it's completing with something plausible and wrong. Kondi's engine is built to make that hard.

File claims vs. git, not prose

A coding council's "files produced" comes from git status after the run — a worker that only narrated writing files means a failed council, not a completed one.

Tools matched to reality

A persona is never offered tools it can't run — the failure where a model roleplays write_file(...) as its answer is designed out at the grant layer.

Workers grounded in the source

The original input rides along beside the manager's directive, so a summary-of-a-summary can't invent the details it dropped.

No silent substitutions

Broken model or unconfigured provider → the launch fails with a precise error. Kondi never quietly swaps in a differently-priced model.

Broken models get benched

Live-call failures hide a model from every selector until proven good again — you find out at config time, not mid-pipeline.

Pre-flight validation

Misconfigured steps carry a ⚠ with the exact problems; a pipeline with warnings refuses to run until they're resolved.

§6A desktop app, deliberately

Kondi is a native app (Tauri: Rust + web UI), not a hosted service. Your keys stay on your machine and calls go direct to providers. Deliberations persist to disk past any browser quota. Pipelines operate in a working directory you choose — coding steps write real files there, script steps test them there, containment guards keep agents inside. MCP tool servers connect per step or per persona.

Assemble your first pipeline tonight — free.

Download Kondi, paste one API key (or grab free NVIDIA NIM credits), and click together a council pipeline on the graph. No account, no fees. The examples import in one click.

Free forever · open source · macOS · Windows · Linux

← kondi home

examplesFour pipelines, proven end-to-end

Run with real models, every step's output inspected and verdicted. Each dossier shows the step table (what it does + expected output), excerpts from the actual run, and what the verification process caught — the failures each example surfaced became engine fixes. The receipts ship in the repo.

01

Market Brief

VERIFIED · 3/3 STEPS

From a product README on disk to a committed positioning and a one-page market brief. A CLI worker with read tools explores the actual repo; an analysis council commits to exactly one opportunity; a writing council turns the decision into the deliverable.

  • enrich
  • analysis
  • council
  • input: file
  • models: NIM nemotron ×2 + claude CLI
StepTypeWhat it doesExpected output
Opportunity miningenrich3-persona council debates market opportunities found in the README; the worker reads the repo for evidence4–6 structured opportunities: target user, pain point, why this product wins
Positioning decisionanalysisManager-only council picks ONE opportunity and commitsA decision with rationale, rejected alternatives, top risks, acceptance criteria
Brief writingcouncilEditor + writer council produce the final documentOne-page brief: headline, target user, 3 key messages, competitive angle, 90-day plan
step 2 · the council commits — no hedging
“DECISION: Commit to building the Cost Management Dashboard as the primary market opportunity … RATIONALE: … addresses the most urgent and universal user pain point: accidental overspend during AI experimentation … REJECTED: General-purpose AI productivity tool … Developer-centric LLM IDE …”
step 3 · the brief, grounded in that decision
Stop AI Spend Surprises, Start Confident Experimentation — Real-time tracking & alerts · Zero-architecture lift (built on the existing ledger that already token-tracks every LLM call) · can automatically block LLM calls at budget limits.”
what verification caught

The final brief once contradicted the upstream decision — invented product, invented features. Workers only saw the manager's directive, two summarization hops from the real input. Kondi now re-attaches the original source material to every worker prompt. The bug was found because we read the output instead of trusting “completed”.

02

Code Factory

VERIFIED · 7/7 STEPS

Ship a small working utility with tests: plan, human gate, real implementation by the claude CLI, mechanical test verification, a retry loop, a documentation review council, and release notes. The script step actually runs the tests — a model saying “tests pass” counts for nothing.

  • code_planning
  • gate
  • coding
  • script
  • condition · loop
  • review
  • agent
  • input: text spec
StepTypeWhat it doesExpected output
Implementation plancode_planningPlanning council decomposes the spec; the plan author is a tool-capable CLI agentFile list, function breakdown, edge cases, test strategy
Plan approvalgateHuman checkpoint before any code is writtenApproval (a human clicks; scripted runs auto-approve)
ImplementationcodingCoding council — the worker is the real claude CLI writing files in a contained working dirwordfreq.js + test.js on disk, tests passing
Test runscriptExecutes node test.js — mechanical, no model judgmentALL TESTS PASS + SCRIPT-VERIFIED
Ship checkcondition ↻Requires the pass string; otherwise loops back to Implementation with the failure as feedback, then fails the runcontinue
Docs & code reviewreviewReview council — a CLI agent audits the shipped code against the specREADME.md, docs/, review.md in the working dir
Release notesagentWrites concise release notes from the verified state<200-word notes: purpose, usage, test status
step 4 · the machine's verdict, not the model's — re-run by hand afterwards, same result
ALL TESTS PASS
SCRIPT-VERIFIED
step 3 · the coding council debugged for real before handing off
“I found the issue! The test.js file is using a relative path 'wordfreq.js' which resolves relative to where the test runner is executed from … I need to fix the path to use __dirname … The fix works from any location.” — the worker, mid-debug-cycle
step 6 · the review is evidence, not vibes
“Tokenise on whitespace after removing all non-alphanumeric characters — Satisfied? Yes — Evidence: line 59: text.toLowerCase().replace(/[^a-z0-9\s]/g, ' ') …” — review.md, a per-requirement adherence table with line numbers, written to disk alongside README.md and four docs/ files
what verification caught

An earlier run failed the exact-string gate, looped, and failed again — the retry's feedback was just the test output, which read as success (✓ All tests passed!), so it fixed the wrong things. Loop feedback now leads with the condition's expression and verdict; the next run passed the gate on the first attempt. An agent once claimed it wrote a file that didn't exist — text-output agents are no longer offered write tools, so the deliverable lands in the artifact where the pipeline can check it.

03

Policy Debate

VERIFIED · 3/3 STEPS

A genuinely adversarial council: a chair, an advocate, and a skeptic debate a real question over two rounds — should a 40-person software company adopt a 4-day work week? — then a guard verifies a recommendation exists before an agent distills the executive summary.

  • council · 4 personas · 2 rounds
  • condition
  • agent
  • input: text question
  • models: NIM nemotron super + nano
StepTypeWhat it doesExpected output
Council deliberationcouncilChair frames; opposed consultants debate two full rounds; rapporteur synthesizes; consultants review the draftA clear recommendation with conditions and dissent acknowledged
Recommendation guardconditionPass-through check that an actual recommendation exists in the outputcontinue — with the deliberation flowing through untouched
Executive summaryagentDistills the full deliberation for an executive readerHalf-page summary: recommendation, conditions, dissent
the debate was real — positions opposed, dissent recorded
“Consultant A argued … structured expert communication reduces dominance bias … Consultant B cautioned that its iterative, time-intensive nature makes it unsuitable for urgent decisions …” — opposing consultants, round 2, before the chair's decision
what verification caught

Conditions and gates used to replace the data flowing through them with bookkeeping text (“Condition evaluated: TRUE”), so the summary step summarized the bookkeeping. They are now pass-through nodes: upstream content flows on, the evaluation rides in metadata.

04

Content Refinery

VERIFIED · 6/6 STEPS · 1 REAL LOOP-BACK

A live URL in, a length-controlled explainer out. An agent extracts strict JSON from a fetched Wikipedia summary; two analysis lenses run in parallel on individual JSON fields; a council synthesizes; a script counts words; a condition loops the synthesis back — with the measured count as feedback — until the length lands.

  • agent · json
  • analysis ×2 · parallel
  • council
  • script
  • condition · loop
  • input: url · live fetch
StepTypeWhat it doesExpected output
Fact extractionagent → jsonExtracts key facts from the fetched page as strict JSON; downstream steps address fields as {'{{input.definition}}'}Valid JSON: topic, definition, origin, key steps
Practitioner lensanalysis ∥Parallel: when should a team actually use this method?Grounded when-to-use guidance
Historian lensanalysis ∥Parallel: where did it come from, how did it evolve?Origin and evolution context
Explainer synthesiscouncilWeaves both lenses into a plain-language explainer350–450 word neutral explainer
Length checkscriptwc -w — the word count is measured, not assertedLENGTH OK (n words) or the actual count
Length gatecondition ↻Out of range → loop back to synthesis with the measured count as feedback (≤3 tries)continue
step 1 · strict json — and factually right beyond the fetched page
{ "topic": "Delphi method",
  "origin": "Developed in the 1950s by Olaf Helmer, Norman Dalkey,
             and Nicholas Rescher at the RAND Corporation …", … }
the loop fired for real
[log] ↻ Looping back to "Stage 3" (iteration via Length gate)
LENGTH OK (446 words)
what verification caught

Models offered tools they can't run will roleplay them — the extractor once emitted a fake fetch call as its “output”. Tool advertising is now matched to what a persona can actually execute.

Every example ships in the repo under examples/ — full pipeline.json (importable via Pipelines → Import), every step's real output, and an honest per-step VERIFICATION.md. The failures each example surfaced became engine fixes — the examples are the test suite that hardened the product.

Browse the verification dossiers →

← back to kondi home