Solutions / rag-kit

One question in. A crew at work.

Retrieval-augmented generation usually means one model, one loop, and hope. rag-kit is the other shape: a planner decomposes the request, workers run in parallel waves with recall over your own corpus and tools they are actually allowed to use, and a synthesizer merges what they found. Deterministic control flow, model-driven content — your code decides what runs, the model decides what it says.

orchestrator.run — one request, one crew
request: “What changed in our churn this quarter, and why?”
Planner
t1 pull the numberst2 read the exit notest3 explain · needs t1, t2
Wave 1
t1 · analyst
t2 · researcher
Synthesis
Churn rose 1.8 points, concentrated in month-to-month plans — the exit notes name the same onboarding gap the numbers point at, with both sources cited.
The planner’s output is validated before anything runs — an impossible plan is refused with the defect named. The two workers really do run at once, and the synthesis only ever says what some task’s output supports.
0
inference providers supported out of the box, behind one seam — and any compatible endpoint besides
0
tasks running in parallel per wave, out of the box — the plan’s structure is the concurrency
0
new infrastructure to operate — the queue, the corpus and the record all live in the database you already run
0
event types streamed per run, so progress is watched rather than awaited
Why this one

An answer is only as good as its supervision.

A single agent in a loop fails silently: it wanders, it invents, it stops early, and the transcript is the only witness. rag-kit makes the structure do the supervising — plans are validated, tools are allowlisted, budgets are enforced, and every run leaves a record.

A plan you can read

The planner’s output is a task list, not a vibe — validated before anything runs. An impossible plan is refused with the defect named: which task cites an unknown agent, which dependency loops, spelled as “a → b → a”. A named refusal is fixable; a bare one is not.

Workers run in waves

Tasks that depend on nothing run together; tasks that depend on outputs wait exactly as long as they must. The plan’s own dependency structure is the concurrency — nothing to configure, and nothing independent left waiting in line.

Grounded in your corpus

Answers are recalled from documents you ingested and ranked by meaning, not keyword overlap. No embedding provider configured? It degrades to keyword ranking and tells you it did. Degraded, never broken.

Tools on an allowlist

Each agent names the tools it may call, and the registry enforces the list — prompt text is not a security boundary. A failing or forbidden call is answered into the transcript, where the model can read it and recover, instead of crashing the run for the host to debug.

Bounded by construction

Tasks per plan, rounds per tool loop — every loop has a budget, and blowing one is a loud, typed error naming the limit. A run ends; it never spins. Every step emits an event, so a surface shows the crew working instead of a spinner guessing.

Runs that survive the process

A run is queued and claimed, never held in memory — so a deploy in the middle of one does not lose it, and a worker that dies hands its work back rather than stranding it. Retries are bounded; a run that exhausts them fails with the reason recorded, not silently. Nothing new to operate.

Where the family fits in. The portal’s own Builder is rag-kit’s first product — an agent crew that writes QuxKit applications, grounded in the kits’ documentation. Runs carry the same opaque tenant id as everything else here, so tenant-kit isolation extends to your corpus and your queue, and what a run costs can land on the meter billing-kit already runs. Like Integration-Kit, it installs into your repo and stays there, on the Postgres the rest of the family already runs on.

Give your product a crew.

Multi-agent RAG that installs like a library, runs on infrastructure you already have, and never asks you to trust a loop you cannot see into.