Power Combos — the complete guide

→ Browse the complete combo catalog — all 705 combos, name, description, use cases, and an example for each

What is a Power Combo?

A normal chat sends your prompt to one model and gets one answer back. A Power Combo sends your prompt to several small local models at once — each one playing a specific, narrow role — and stitches their answers together into something better than any single model would produce alone.

The idea: a 1.5B model asked to do ONE narrow thing ("find bugs in this code, nothing else") is often more reliable than the same 1.5B model asked to do everything at once. Combos exploit that — instead of using one bigger, slower model, they use several small, fast, focused ones working together.

Everything runs locally — no cloud calls, no per-token cost, no data leaving your machine. A combo just orchestrates models you already have installed.

The three patterns

Every combo follows one of three execution patterns:

Parallel

All steps run at the same time, each with its own narrow instruction, and you see all their answers side by side. Use this when you want several independent angles on the same input — nobody needs to see anyone else's answer first.

Real example — Code QA Panel (coding):

You paste a function. Three models fire simultaneously:

Bug Hunter (qwen2.5-coder:1.5b) — lists only syntax errors and logic flaws

Documenter (llama3.2:1b) — writes a README for it

Security (qwen2.5-coder:1.5b) — flags only security issues

You get all three back in a few seconds, each focused on exactly one job instead of one model trying to do all three at once (and doing each worse).

Sequential

Steps run one after another, each one seeing the previous step's output as part of its own input. Use this when a task naturally breaks into stages — draft, then refine; analyze, then act.

Real example — Translator Pro (verify loop) (language):

1. Translate — turns your text into the target language

2. Back-translate — translates that result back into English, blind to the original (this is the trick: it can't just "agree" with itself)

3. Final — compares the original, the translation, and the back-translation, and fixes anything that drifted in meaning

A single translation pass can silently drift ("bank" → wrong sense of the word, idiom translated literally). This catches that by translating back and checking, the same sanity-check a human translator would do.

Judge

Two (or more) steps run in parallel to produce competing answers, then a final judge step reads both and picks (or synthesizes) the best one. Use this when there's no obviously-correct single approach and you want the system to pick a winner instead of you comparing two outputs yourself.

Real example — Code Generator Duel (coding):

Coder A (qwen2.5-coder:3b) writes a solution

Coder B (starcoder2:3b, a different model family) writes its own

independent solution to the same request

Judge (qwen2.5-coder:3b) reads both, picks the cleaner one, cleans

it up, and that's what you get

Different model families have different blind spots. Racing two of them and having a third pick the winner catches mistakes a single model would make confidently and silently.

Free vs. Premium, and the three backends

Free (base) tier — 150 combos, reachable to every AI Cockpit user, no

account needed: 50 for Ollama, 50 for LocalAI, 50 Dual (mixing both backends in one combo).

Premium tier — 555 combos, gated behind a Content-tier subscription:

185 more for each of Ollama/LocalAI/Dual.

Dual combos are the interesting case — a single combo's steps can be tagged to run on either backend, so you get genuine engine diversity in one combo, not just model diversity.

Real example — Python Code Reviewer (Dual) (coding):

Bug Hunter — runs on Ollama (qwen2.5-coder:1.5b)

Idiom Checker — runs on LocalAI (gemma-3-4b-it)

Performance — runs on Ollama (llama3.2:1b)

Same parallel-panel idea as Code QA Panel above, but now two genuinely different inference engines are reviewing your code, not just two models on the same engine. If Ollama and LocalAI happen to have different quirks or biases in how they read code, this catches that too.

Why Dual Mode on Card 3 might be the whole point

Everything above works with a single backend (Ollama-only or LocalAI-only combos). Dual mode is different: it runs Ollama and LocalAI at the same time, in the same combo. This is the part of AI Cockpit that genuinely has no equivalent elsewhere — most local-AI tools pick one inference engine and live with it. Cockpit lets you run both simultaneously, per-step, in one orchestrated pipeline.

Why this matters in practice:

Different engines have different quirks. Ollama and LocalAI don't always produce

identical output for the same model+prompt — different default sampling, different context handling, different quantization pipelines. Running a step on each backend surfaces disagreements a single-engine setup would never show you.

Real hardware utilization. If your GPU/VRAM is the bottleneck for one engine but not

the other (e.g. Ollama is busy serving one model while LocalAI's slot is free), Dual mode lets you actually use both halves of your machine instead of queuing everything through one engine.

Resilience. If one backend is misbehaving (a model crashed, a server hung), a Dual

combo's other steps — running on the other backend — keep working. A single-backend combo has no such fallback.

It's the only way to compare backends on the same task without doing it by hand. The

Python Code Reviewer (Dual) example below runs the exact same category of review split across both engines in one click — no manual copy-pasting between two separate chat windows to compare.

How to turn it on: Supplier Slots (Card 3) → pick Dual — Ollama + LocalAI as the local provider. Once set, Card 3's model list and combo panel both show entries from both backends together, and any combo whose steps are tagged with a specific runner will actually execute on that backend. Switch back to plain Ollama or plain LocalAI any time — Dual-tagged combos still show (as long as their content works on the single backend you're viewing), but the mixed-runner behavior only kicks in while Dual is selected.

Real examples per domain

Every domain below has real combos in every tier — free, premium, Ollama, LocalAI, and Dual. Several worked examples each, with concrete usage scenarios:

Coding

Code QA Panel (parallel) — paste a function, get bugs + docs + security issues back at once, each from a model that only had to focus on one job. Use it when: reviewing your own code before a commit, or getting a second opinion fast without opening a full code-review tool.
Bug Triage (sequential) — paste an error/log, and the combo works through it like a real triage process: root cause first (1-2 sentences, no guessing at fixes yet), then a concrete fix built on that diagnosis, then a specific test that would catch the bug if it regressed. Use it when: you have a stack trace or error message and want a structured path to a fix instead of guessing.
Dev Pipeline (RAG) (sequential, uses your Knowledge Library) — a "Librarian" step first reads your attached documentation/codebase context and extracts only the relevant syntax rules and signatures (explicitly told not to write any code), then a "Coder" step writes the actual code using only those extracted rules. Use it when: you're coding against an API or library you have docs for, and want the model grounded in your real docs instead of guessing from training data.

Office

Meeting Minutes (parallel) — paste a raw meeting transcript, get back a summary, a list of decisions made, action items (as structured JSON, with owner if stated), and who was mentioned — all at once. Use it when: you recorded/transcribed a call and don't want to re-read the whole thing to extract what actually needs to happen next.
Spreadsheet Formula (parallel) — describe what you need in plain English, get back the actual Excel formula, the Google Sheets equivalent (they're not always identical syntax), and a plain-English explanation of what it computes — all at once. Use it when: you know what you want a spreadsheet to do but don't remember the exact formula syntax.
Proposal Writer (sequential) — idea → outline → full draft → 3-sentence executive summary, each step building on the last. Use it when: starting a business proposal or pitch from scratch and want the whole shape of it, not just a blank-page draft.

Language

Translator Pro (verify loop) (sequential) — see the Sequential pattern example above (translate → back-translate → fix drift). Use it when: the translation actually matters (a client email, a public post) and you want more confidence than a single-pass translation gives you.
Multilingual Broadcast (parallel) — one piece of text goes out in Hebrew, Spanish, Arabic, and French simultaneously, each from its own step. Use it when: posting an announcement to an audience that spans languages and you need all versions at once, not one at a time.
Subtitle Translator (sequential) — translates subtitle lines while explicitly preserving line breaks/timecodes, then a tidy-up pass keeps each line short enough to actually work as a subtitle (not just grammatically correct). Use it when: localizing video subtitles, where a technically-correct translation that's too long to fit on screen is still a failure.

Image

Image Prompt Studio (parallel) — describe an idea, get back three ready-to-use image-generation prompts in different styles (photoreal, illustration, cinematic) at once, so you can pick the direction you want before spending time generating actual images. Use it when: you're not sure what visual style fits your idea yet.
Prompt + Negative + Params (sequential) — builds a complete, ready-to-paste image-gen setup: the main prompt, then a negative prompt (what to avoid) built from that prompt's specifics, then suggested CFG scale/steps/size as JSON. Use it when: using a real image generator (Stable Diffusion, etc.) and want all three inputs prepared for you instead of guessing generation parameters yourself.
Logo Concepts (parallel) — one brand description produces three genuinely different logo directions at once: a minimalist mark, an emblem/badge style, and a typographic wordmark — each with its own ready-to-use image prompt. Use it when: starting logo exploration and want real stylistic range instead of three variations on the same idea.

Learning

Explain 3 Levels (parallel) — ask about any concept, get it explained three ways at once: ELI5 (for a child), intermediate (knowledgeable beginner), and expert (full nuance, no hand-holding). Use it when: you're learning something new and want to gauge how deep to go, or explaining something to someone else at a level you're not sure fits them.
Flashcards (sequential) — extracts the key facts from any text, then turns them into ready-to-use Q/A flashcards as structured JSON. Use it when: studying from your own notes/reading and want spaced-repetition-ready cards without manually writing them.
Debate + Judge (judge, 3-way) — three specialists each propose a solution from a different angle (creative/unorthodox, logical, minimalist), and a judge synthesizes one clean answer combining the best of all three — without even mentioning which candidate contributed what. Use it when: facing a decision with no single obviously-right approach and want a genuinely considered answer, not just the first idea that came to mind.

Data

Fact-Check Interrogator (parallel) — paste a claim-heavy text, get back a skeptic's list of dubious/unsupported claims, a chronological timeline of every date/event mentioned (as JSON), and 5 related topics worth checking. Use it when: reading something that sounds persuasive but you want a second, more skeptical pass before trusting it.
CSV / Data Cleaner (parallel) — messy tabular text gets a schema guess (as JSON), a cleaned/normalized CSV version, and a bullet list of rows/values that look wrong — all at once. Use it when: you have data copy-pasted from somewhere inconsistent (a PDF table, an email) and want it usable without manual cleanup.
Research Digest (parallel) — an article gets summarized, its main claims extracted, plausible counterpoints/limitations listed, and specific facts worth independently verifying flagged — four angles on one article at once. Use it when: doing real research and want a structured first pass before deciding what's worth digging into further.

Creative

Sci-Fi Worldbuilder (parallel with a seed step) — give one idea, a seed step first establishes a shared premise (place, era, tone), then four specialists build on that same premise simultaneously: environment, society/factions, available tech, and three NPC profiles. Use it when: starting a story, game, or campaign setting and want a fleshed-out world fast instead of a blank page.
Storyteller's Workshop (sequential) — a rich first draft, then an editing pass for consistency and flow, then a final pass that wraps the whole thing in clean semantic HTML (headings, paragraphs) ready to publish. Use it when: writing something you'll actually post/publish and want it to go from idea to publish-ready in one pipeline.
Story Continuation (sequential) — give a premise, get an outline for the next chapter, then the actual chapter written from that outline, then a one-paragraph cliffhanger ending. Use it when: you're stuck mid-story and want a real continuation, not just "what happens next" as a one-liner.

Accessibility

Accessibility Pass (parallel) — paste HTML/UI text, get back real accessibility issues (missing labels/alt/roles/contrast risks), non-color ways to convey any color-only cues, and ready-to-use alt text for images/icons — all at once. Use it when: building or reviewing a web page and want a first accessibility pass before (or in addition to) a real audit tool.
Keyboard Navigation Pass (sequential) — scans HTML/UI text specifically for keyboard-navigation issues (citing the actual element), then a second step suggests a concrete markup/attribute/CSS fix for each one found. Use it when: someone using your app entirely by keyboard (no mouse) matters — a real accessibility requirement, not an edge case.

How to actually use one

Open Card 3 in AI Cockpit, pick Ollama / LocalAI / Dual as the Supplier Slot.
The combo panel shows every combo available for that backend, grouped by

category — click one to select it.

Type your prompt as normal and send — the combo runs its steps (in

parallel/sequential/judge order) and shows you the results as it completes.

Don't like the built-in ones? Click + new to build your own combo —

same steps/pattern/role system, saved locally, and publishable to the Marketplace for others to download if you want.

Where they come from

The free 150 ship with a fresh install (in cockpit_data/combos_ollama.json, combos_localai.json, combos_dual.json). The premium 555 live in the in-app Marketplace (Card 3 → 🌐 storefront icon → Power Combos filter) — Content-tier subscribers can download any/all of them, with a bulk "Get all shown" button so you don't have to click 555 times individually.