You Don’t Need AGI, You Need ADC

AGI is always five years away. Artificial Domain Competence is available right now.

Clone a repo. Pull it from HuggingFace. Point your model at it. You have domain competence — not in five years when the next architecture breakthrough lands, but today, with whatever model you already have.

The Problem AGI Doesn’t Solve

Organizations don’t need a model that can do everything. They need a model that knows their thing. Their products. Their architecture. Their compliance requirements. Their 12,000 internal processes that no training run has ever seen.

The industry is spending billions chasing general intelligence. Meanwhile, the practical problem — making models competent in specific domains — is solvable with structured knowledge bases and existing models. No breakthrough required.

What Artificial Domain Competence Looks Like

ADC is what you get when you give a general-purpose model access to a reviewed, justified knowledge base for a specific domain. The model provides reasoning. The knowledge base provides the expertise. Together, they produce domain-competent answers.

expert-service query "How should I handle crash recovery in my LSM-tree?" \
  --expert ddia-expert

The expert repo contains a belief network — thousands of reviewed, justified beliefs about a domain, each tracing back to source documents through derivation chains. Not chunks of text thrown at an embedding model. Reviewed knowledge that survived multiple rounds of adversarial analysis.

This is not RAG. RAG retrieves text and hopes the model figures out what matters. ADC retrieves beliefs that have already been validated — the hard work of determining what matters has been done before query time.

The Numbers

We tested this across five domains:

Expert	Domain	Beliefs	What happened
Enterprise products	IT processes	12,731	88% A-grade vs 33% without the knowledge base
Platform architecture	Ansible	237	47% cheaper, 2x faster, +13pp recall
Algorithms	LeetCode	1,641	Found 17 bugs that passed all test suites
Distributed systems	DDIA	1,405	Found 30 implementation bugs across 3 rounds
Product routing	Dataverse	~500	100x faster, +8pp accuracy

The smallest Claude model with a knowledge base matches the largest Claude model without one. You don’t need a bigger model. You need a better knowledge base.

Why Not Fine-Tune?

Fine-tuning takes knowledge and compresses it into weights. It costs $10K–$100K+. And you lose everything that makes knowledge useful:

You lose provenance. Ask a fine-tuned model “where did you learn that?” and you get nothing. Ask an ADC expert and every belief traces back to its source document.

You lose reviewability. You cannot read what a fine-tuned model knows. You can read every belief in an ADC expert — they’re plain text with justifications.

You lose retractability. Finding an error in a fine-tuned model means retraining. Finding an error in an ADC expert means retracting one belief — the correction cascades automatically through everything that depended on it.

You lose portability. Fine-tuned weights are locked to one base model. Switch providers and you start over. An ADC knowledge base works with any model that can read text.

Building an ADC expert costs $10–$300. It’s usable from the first belief, not after training converges. And when you find an error, you fix one line of text instead of burning GPU hours.

If you’ve already built the knowledge base and it works, fine-tuning the same knowledge into weights is strictly worse. You’re taking a lossless artifact and lossy-compressing it. Fine-tuning is for skills and behaviors — reasoning patterns, tool use, output formatting. For knowledge, just use the knowledge base.

How the Knowledge Gets Built

Each domain expert is built through a pipeline that extracts and verifies knowledge systematically:

1. Propose — an LLM reads source documents and extracts candidate beliefs
2. Review premises — a second pass checks each belief against the source: “Does this document actually say this?”
3. Accept — human reviews the surviving candidates
4. Derive — the system builds reasoning chains: “If A and B, then C”
5. Review derivations — adversarial evaluation catches bad reasoning (13–37% retraction rate per round)
6. Repair — retract errors, cascade corrections, re-derive

Each stage catches different errors. The proposer fabricates plausible details (8% error rate). The derivation step over-generalizes (13–37% caught by review). The review step activates knowledge the derivation step missed — same model, different question, different knowledge surfaced.

After 3–5 rounds, the surviving belief network has been pressure-tested from multiple angles. The same model that generated a claim has challenged that claim. The result is knowledge you can trust — not because any single step is perfect, but because the pipeline’s stages catch each other’s errors.

The Community Model

The EEM Hub is where domain experts share their knowledge bases:

1. Build — use the pipeline to extract beliefs from your domain’s documentation
2. Refine — run derive-review-repair cycles until the knowledge base converges
3. Publish — push to the hub so anyone can use it
4. Compose — combine experts across domains for cross-cutting questions

One team builds the distributed systems expert. Another builds the Kubernetes expert. A third builds the compliance expert. Any model can query all of them. The knowledge compounds across the community, and none of it is locked to a single model provider.

Knowledge bases are also available on HuggingFace — download one and start querying it immediately.

AGI vs ADC

	AGI	ADC
Available	Five years away (always)	Now
Domain depth	Broad but shallow	Deep where you need it
Knowledge updates	Retrain	Edit a belief
Inspectable	No	Yes — read the text
Correctable	Retrain or hope	Retract and cascade
Model lock-in	Is the model	Uses any model
Cost	Billions in research	$10–$300 per domain

The AGI bet is that eventually a single model will know everything about every domain. The ADC bet is that you can build domain competence today with structured knowledge and existing models — and that reviewed, justified, portable knowledge beats knowledge compressed into weights.

One of these bets pays off today. The other might pay off someday.

Get Started

The tools are open source:

• expert-agent-builder — the pipeline that builds domain experts from documentation
• ftl-reasons — the engine that manages belief networks with justifications and retraction cascades
• expert-service — the retrieval layer that serves beliefs to any model
• EEM Hub — pre-built experts you can clone and use today

Stop waiting for AGI. Build domain competence now.

---

Previously: Your LLM Knows More Than It’s Telling You, Stop Fine-Tuning, Start Remembering, The Dirty Pipeline.