Meet FarkiBot

AI that answers from your model.

Paste your architecture into a chatbot and it'll tell you something. Fluent, confident, and impossible to check — because you can't tell which bits came from your model and which came from the ten thousand architecture documents it was trained on.

FarkiBot is built the other way round. It answers from your model, or it tells you your model doesn't say. It uses your LLM, not ours — so there's no lock-in, no markup on tokens, and your models never pass through our servers.

Try it freeRead the tutorial

Five Things It Does

All of it grounded in the actual model — the structured, metamodel-validated one, not a picture of one.

Ask
“Which business capabilities have no supporting application?” “What breaks if we retire this system?” Because the model is structured data, questions about coverage, counts, and connections get answered precisely rather than approximately.
Report
An answer is something you read. A report is something you hand over. Model overviews, gap & risk assessments, reference documentation, executive summaries — written from the model, saved as Markdown. Revise them like a colleague's draft.
Generate a metamodel
Describe the modeling language you wish existed and FarkiBot designs it — element types, relationships, notation, constraints. Attach the standard you're implementing and it'll stick to it rather than reconstructing it from memory.
Generate a model
Feed it a PRD, a spec, a strategy doc, a case study — Markdown, text, PDF or Word — and get a real model that conforms to your metamodel. Not a diagram. A model, with types, properties and relationships that validate.
Modify a model
“Add a Subscriptions subject area.” “Rename these to the new glossary terms.” You review the change as a diff — removals first, in red — and a snapshot is saved before anything is replaced.
And one thing it won't
Make things up. If your model doesn't record system owners, FarkiBot says so — it won't produce a tidy table of plausible names. Less impressive in a demo. Considerably more useful on a Tuesday.
BYOLLM

Bring Your Own LLM

Most tools bundle an AI, mark up the tokens, and quietly decide on your behalf which model you get — forever. We think that's backwards. FarkiBot runs on your provider key. One OpenRouter key gets you 300+ models from every major lab, including free ones, and switching between them is a dropdown.

No lock-in
GPT, Claude, Gemini, Kimi, DeepSeek, Llama, and whatever ships next month. If a better model appears, you switch to it in a dropdown — not in a support ticket, and not in your next renewal negotiation.
No markup, ever
You pay your provider directly, at their price. We never touch the transaction, so we can't take a cut — which also means we have no incentive to make FarkiBot chatty. A feature that earned per token would be designed differently, and you'd be able to tell.
Free models actually work
Not a token gesture. In our own testing a free model produced a perfectly good Business Model Canvas from a case study document, at $0.00. You can reach the flagship capability without spending anything.
Use the account you already have
Already pay Anthropic, OpenAI or Google? Add that key inside OpenRouter's BYOK settings and those models bill to your existing account, at your existing rate limits. No second card. Or connect Anthropic and Gemini directly, with OpenRouter out of the path entirely.
Or run it locally
Point FarkiBot at any OpenAI-compatible endpoint — Ollama, LM Studio, or your organisation's internal LLM gateway. If your models can't leave the building, they don't have to.
Cap it and forget it
Create a dedicated key with a spend limit — $10, reset daily — and the worst case of any mishap is a number you chose yourself. Takes about a minute, and it's the one control that holds no matter what else goes wrong.

The honest cost of this decision: setting up FarkiBot takes about five minutes and an account with somebody else. We think that's the right trade for a tool that reads your architecture — but it's a trade, and we'd rather say so than pretend it's free of friction.

Your models never pass through our servers

This isn't a privacy policy. It's an architectural fact, and you can check it in about thirty seconds.

Your API key and your model content go directly from your browser to the provider you chose. Farkitect's servers are never in the path. Open your browser's network inspector and run a question: you'll see requests to your provider, and none to us carrying your content.

We invite that inspection deliberately, because it converts a promise into something checkable — which is the same principle the whole feature is built on.

Underneath, it's enforced by a strict Content-Security-Policy — a browser-level allow-list of which hosts the app may contact at all. Farkitect can reach its own backend and the AI providers, and nothing else. The browser itself refuses the rest. There's a permanent test in our codebase that fails if anyone widens that list, because the likeliest way this guarantee dies is a well-meaning developer “fixing” a network error.

And if you ask FarkiBot to remember your key, it's stored encrypted (AES-256), wrapped by a key your browser holds internally that no website code — including ours — can export. It's never written in the clear. Most BYOK web tools just drop your API key into plaintext browser storage. We think that's a bit rubbish.

The honest limit, because there always is one: no browser or desktop app can protect a secret from malicious code running as the app itself. Nothing can. What still holds in that case is the CSP — a stolen key has nowhere to be sent — and the spend cap you set on the key. That's why we keep recommending the cap.

Nothing gets written until you say so

“Undo” is a worse guarantee than “it never happened”, and a review you perform after the fact is a review most people skip.

It has to be valid
A generated model is checked against the real importer andagainst your metamodel — element types must exist, relationships must satisfy your constraints. Failures go back to the LLM for repair, up to three attempts. It isn't accepted unless it actually conforms, which is why generated models tend to be correct rather than merely plausible.
You read it first
Results arrive as a staged package your project hasn't seen. Review it as a tree — every element, relationship and diagram, with references resolved to names instead of internal ids — or as raw source. It's the same bytes either way, so what you reviewed is provably what you imported.
Changes get a diff
Modifying a model shows you exactly what changed, with removals listed first and in red — because a removal on a request that asked only for additions is precisely the failure worth catching. Then a freshness check, an explicit confirmation, and a snapshot saved before anything is replaced.

If that snapshot doesn't save — you cancel it, or it fails — FarkiBot stops and tells you nothing has been replaced. It doesn't proceed on the assumption you probably meant to. A safety net you believe in but that isn't there is worse than no safety net at all.

What does it actually cost?

Real numbers from our own testing, so you have a sense of scale rather than a marketing adjective.

$0.16

A valid model from Kimi K3, first attempt — roughly a tenth of frontier pricing, and faster

$0.00

A Business Model Canvas from a free model, built from a case study document

300+

Models reachable from one key, swappable per task and per question

Here's the trick worth knowing: generating a metamodel is much harder than generating a model. A metamodel has to invent a whole structure and its notation; a model just fills in a structure that's already there. So build the metamodel once with a strong model, then build models on it for free or nearly free. You pay only where the difficulty actually is.

Give it a go

Farkitect is free while we work out whether we've built something worth paying for. FarkiBot needs a provider key, which is also free to start — a five-minute detour to OpenRouter and you're generating models. Tell us what happens; we genuinely want to know.

Get StartedSetup guideHow it works