Prompt to governed delivery
YAKKL turns any AI request into governed delivery: classify the intent, choose the execution path, route work to the right model, produce durable artifacts, audit the result, hand off context, and keep the whole run searchable.
Every stage below is a real boundary in the system, not a diagram of intent.
- Prompt Raw intent enters
- Classify The workflow is determined
- Route Model fit is explicit
- Artifacts Output becomes durable
- Audit The work is checked
- Handoff The next session starts informed
- Recall Everything stays searchable
Watch the work move through the system
A request moves from prompt to classification, routing, artifacts, audit, handoff, and searchable recall. Each boundary is somewhere the run can be inspected or stopped.
Requests arrive at an intake funnel and are sorted three ways: the architecture path, the direct path, or declined. Admitted work becomes a numbered artifact and passes 7 stations.
- 1. Intake — The request arrives and becomes an artifact with an ID.
- 2. Route — The path is chosen, and so is the model that will do the work.
- 3. Spec — What the component must do, in terms that can be checked.
- 4. Plan/Phases — Phases and acceptance criteria, written before any code.
- 5. Build/Test — Code and tests, generated and run together — hundreds of cycles, not two stages. A failure here sends the work back to Route.
- 6. Audit — Every acceptance criterion is walked before close. A failure here sends the work back to Plan/Phases.
- 7. Record — final.md and its metadata are written to the store.
At Route the system also chooses which model tier does the work, and that choice travels with the artifact and is recorded against it.
The line fills three containers at once, not one after another:
Backend: Services, storage, and the edge. Everything above it depends on something in here. Persistent store, Public API surface, Identity and sessions, Domain services, Realtime transport, Edge and cloud routing, Transactional mail.
Docs: Written as the work happens, not reconstructed afterwards from what shipped. API reference, How-to guides, Decision records, Operations runbook.
Frontend: What a person touches. Every piece here consumes something the backend already provides. Interface shell, Sign-in flow, Search and filtering, Live updates, Reporting views.
Work moves on all three fronts together. The one ordering rule is that a component may only be built after whatever it consumes already exists — an interface cannot ship before the service behind it. Tests are not a separate stage; every component passes through Build/Test.
When all three containers are complete they converge on a review gate. A whole product crossing every subsystem — a person signs before it ships. From there the same line can emit a whole product, or a single feature cut from the same artifacts.
Every stop has a job
Work can move forward, stop, or route back with its failure attached. These are the boundaries the assembly line enforces.
Raw intent enters
A request starts as ordinary language — a bug report, a strategy note, a product direction. Nothing is required of you up front.
The workflow is determined
The system separates chat, planning, implementation, review, visual, research, and private or local work before anything executes.
Model fit is explicit
Deep reasoning, code, visuals, extraction, review, local privacy, and cost-sensitive work can each land on a different model.
Output becomes durable
The run produces plans, specs, phases, code, papers, diagrams, evidence, and follow-up work — files, not chat scrollback.
The work is checked
Verification, review notes, risk findings, and unresolved questions are preserved rather than buried in a transcript.
The next session starts informed
Context survives across people, agents, vendors, model changes, and restarts. Nobody re-explains the project tomorrow.
Everything stays searchable
Prompts, responses, decisions, artifacts, and evidence can be found and reused months later, by a person or an agent.
The right model for the job is a product feature
The promise is not that YAKKL uses many models. The promise is that model selection is governed, visible, and connected to the evidence for why it was chosen.
Cost follows difficulty
Frontier reasoning gets frontier models. Bulk mechanical work does not. You stop paying premium rates to rename variables.
No single vendor owns you
Routing spans vendors. A provider outage or a price change degrades one lane instead of stopping the work.
Private work stays local
Classification can pin sensitive work to a local model so it never leaves the machine — a routing decision, not a promise.
The output is not one answer — it is a deliverable graph
This is where a governed run looks unlike a vendor chat tool: the visible result is a set of reusable artifacts with lineage, not a disposable transcript.
- Idea
- Vision doc
- Component spec
- Master plan
- Phase
- Audit
- Handoff
- Paper
- Media asset
Each artifact records what produced it and what it justified. That lineage is the difference between an audit trail and a chat history. It also provides detailed visibility into the work that was done. Plus, if you have an issue, you can find the exact line of code that caused it. This is especially useful for complex projects where you need to understand the full context of the work that was done.
Governed delivery, $590/year
Orchestrator includes 250 Credit Units a month, grounded search, the unlimited Architecture Path, and BYOK (optional AI vendor keys).
Stay in the loop
Product launches, Founder's Program windows, engineering updates, and platform releases. No spam, and one-click unsubscribe.
- Early access Be first to see new launches and releases
- Pricing windows Know when downloads open and deadlines close
- No spam, ever Useful updates only, unsubscribe in one click