Discovery.AI
An AI system for constructing understanding, not just generating answers.
The Core Idea
Most AI systems follow a simple pattern:
$$ Q \rightarrow A $$
A user asks a question $Q$, the model generates an answer $A$, and the interaction ends.
Discovery.AI starts from a different assumption:
$$ Q \rightarrow M $$
where $M$ is a model of the subject.
The answer is no longer the final product. It is evidence used to construct, refine, and navigate a persistent model.
We are not trying to build an AI that simply says:
"Here is the answer."
We are trying to build an AI that helps a person ask:
- What is this system made of?
- How do these parts interact?
- Why are they connected?
- What happens if I look at it differently?
- What evidence supports this?
- What are the competing explanations?
- What should I investigate next?
The ultimate goal is a system where learning becomes an interactive process of model construction.
Inspiration
Human understanding is not a list of answers.
When we understand something deeply, we construct a structure.
For example, understanding an electric grid means understanding relationships between:
- generation
- transmission
- distribution
- substations
- power flow
- frequency
- markets
- control systems
- consumers
Understanding PayPal means understanding how it sits between:
- customers
- merchants
- banks
- card networks
- payment rails
- risk systems
- ledgers
- regulators
Understanding a smartphone photo means understanding a chain involving:
- light
- sensors
- image processing
- encoding
- storage
- networking
- protocols
- servers
- recipients
The knowledge is therefore not simply:
$$ {f_1,f_2,f_3,\ldots,f_n} $$
It is closer to:
$$ G=(V,E) $$
where:
- $V$ represents concepts, entities, processes, or abstractions
- $E$ represents meaningful relationships between them
The problem is that conventional AI interfaces usually expose only the final prose.
The structure remains hidden inside the model.
Discovery.AI tries to make that structure explicit and continuously explorable.
What Discovery.AI Does
Discovery.AI is a recursive learning and knowledge-modeling system.
A user starts with a question:
How does a smartphone turn a photo I take into a picture that someone else can receive over the internet?
Instead of producing only a paragraph, Discovery.AI investigates the question and constructs a model:
Image Capture
|
v
Image Processing
|
v
Image Encoding
|
v
Network Transmission
|
v
Internet
|
v
Recipient
The user can then interact with that model:
Go deeper into Image Processing.
Go deeper into Network Transmission.
Show me the economic perspective.
Compare Image Encoding and Network Transmission.
These are not merely new questions.
They are operations on an evolving model.
Our Theory of Learning
The central theoretical idea behind Discovery.AI is:
$$ \boxed{\text{Learning} \approx \text{Model Construction} + \text{Model Revision}} $$
A learner does not simply accumulate facts.
They construct a model of how things relate.
That model can then be:
- expanded
- decomposed
- connected
- reframed
- compared
- challenged
- supported with evidence
- revised
This gives us a recursive learning loop:
$$ Q_t \rightarrow M_t \rightarrow I_t \rightarrow E_t \rightarrow C_t \rightarrow R_t \rightarrow M_{t+1} $$
where:
- $Q_t$ = current question
- $M_t$ = current model
- $I_t$ = investigation
- $E_t$ = evidence
- $C_t$ = claims
- $R_t$ = reasoning / relationships
- $M_{t+1}$ = updated model
The next question can then be generated from the model itself:
$$ M_{t+1}=F(M_t,Q_t,E_t) $$
and:
$$ Q_{t+1}=G(M_{t+1}) $$
Learning becomes recursive.
From Question Answering to Question-Driven Modeling
A conventional AI system can be represented as:
$$ Q \rightarrow LLM \rightarrow A $$
Discovery.AI introduces an intermediate structural layer:
$$ Q \rightarrow \text{Investigation} \rightarrow \text{Model} \rightarrow A $$
But eventually the answer itself becomes secondary.
The deeper architecture is:
$$ Q \rightarrow M \rightarrow \text{Investigate} \rightarrow M' \rightarrow Q' \rightarrow M'' \rightarrow \cdots $$
This means the system can continuously learn about a subject instead of treating every question as an isolated event.
The First Major Problem: How Should a Question Be Decomposed?
A naive system could simply ask an LLM:
"Break this question into five subquestions."
But that creates an arbitrary hierarchy.
Not everything should be decomposed.
The system instead asks:
When does something deserve to become an independently investigated component?
Near-Decomposability
A useful decomposition exists when a component has substantial internal structure relative to its interaction with other components.
Let:
$$ I(S_i,S_j) $$
represent the strength of interaction between components $S_i$ and $S_j$.
A useful decomposition can exist when:
$$ I(S_i,S_i) \gg I(S_i,S_j) $$
for many $i\neq j$.
In simpler terms:
A component is worth investigating separately when its internal structure is stronger than its interactions with everything else.
For example, an electric grid naturally exposes relatively separable structures:
Generation
Transmission
Distribution
Each has enormous internal complexity, while still interacting with the others.
The decomposition is therefore a useful abstraction, not an absolute truth.
Decomposition Is a Hypothesis
When the system creates:
Electric Grid
|
+-- Generation
+-- Transmission
+-- Distribution
it is not declaring:
"Reality fundamentally consists of these three things."
It is saying:
"For this question, this is a useful way to investigate the system."
Therefore:
$$ D = D(Q,M) $$
The decomposition depends on the question and the current model.
A different question may produce:
Electric Grid
|
+-- Reliability
+-- Economics
+-- Control
+-- Regulation
Both structures can be useful.
Neither needs to be declared the one true hierarchy.
The Graph Should Represent the World, Not the Investigation
This was our largest architectural discovery.
Our original system effectively created:
Question
|
+-- Child Question
|
+-- Child Question
|
+-- Answer
This looked like a knowledge graph.
It wasn't.
It was an investigation log.
The graph described:
"What did the AI investigate?"
rather than:
"What does the AI currently understand about the world?"
Those are fundamentally different things.
We therefore separated the concepts.
Investigation
The investigation is a process:
$$ I=(Q,S,A,T) $$
where:
- $Q$ = question
- $S$ = investigation steps
- $A$ = actions
- $T$ = trace
World Model
The model is a representation:
$$ M=(V,E) $$
where:
- $V$ = nodes
- $E$ = relationships
The investigation discovers information.
The model stores the resulting understanding.
Therefore:
$$ I \rightarrow M $$
but:
$$ I \neq M $$
The investigation is a process.
The model is a state.
The World Model
Our target architecture is:
QUESTION
|
v
WORLD MODEL
/ \
Nodes Relations
\ /
Claims
|
Evidence
|
Sources
The graph is not merely a record of what happened during an investigation.
It is intended to become a model of the subject itself.
Why One Primitive: Node
During the architectural investigation, we initially considered separate primitives for entities and relations.
But real examples challenged that distinction.
Consider:
Customer
|
v
Payment
|
v
Merchant
"Payment" can itself be:
- a process
- an event
- a mechanism
- a relationship
- an abstraction
- something that can be investigated further
Therefore we found a more general primitive:
$$ \boxed{\text{Node}} $$
A Node can represent:
- an entity
- a process
- an abstraction
- an event
- a mechanism
- a contextual relation
The role of a Node can depend on the question.
This gives us a powerful recursive property:
Anything the system considers meaningful enough to investigate can become a Node.
Relations Are Contextual
Consider:
Generation -> produces -> Electricity
The relation "produces" might itself become important.
For another question:
How does generation produce electricity?
Now the relationship is no longer just an edge.
It becomes something worth understanding.
Therefore:
$$ \text{Relation} \subseteq \text{Node roles} $$
rather than requiring:
$$ \text{Relation} \neq \text{Node} $$
A relationship can have:
- its own claims
- its own evidence
- its own sources
- its own substructure
without requiring a second fundamental object type.
Contextual Identity
One of the hardest problems is deciding when two nodes are actually the same thing.
Suppose we see:
Transmission
in an electric grid,
and:
Transmission
in telecommunications.
They have the same name.
They are not necessarily the same node.
A naive identity function:
$$ ID(N)=name(N) $$
is insufficient.
We therefore explored contextual identity:
$$ ID(N)=f(name,context,abstraction) $$
For example:
Electric Grid
|
+-- Transmission₁
and:
Telecommunications Network
|
+-- Transmission₂
The names are identical.
Their contextual identity is different.
Question-Relative Semantics
One of the most important findings in the project is that relationships are not always intrinsic.
Suppose:
$$ A=\text{Network effects drive dominance} $$
and:
$$ B=\text{Regulatory capture drives dominance} $$
Their relationship depends on the question.
If the question is:
How can companies sustain market power?
the system may reasonably treat them as:
$$ A \;\text{complementary to}\; B $$
But if the question is:
Which factor primarily explains dominance: network effects or regulatory capture?
the same claims become:
$$ A \;\text{alternative to}\; B $$
Therefore:
$$ \boxed{R=f(A,B,Q)} $$
where:
- $A$ = claim/entity A
- $B$ = claim/entity B
- $Q$ = question
- $R$ = relationship
Relationships can therefore be question-relative.
Dimensions as Lenses
A question can be viewed through different dimensions.
For example:
How does PayPal work?
could be investigated through:
Technical
Gateway
Risk Engine
Ledger
Payment Engine
Network Interfaces
Economic
Transaction Fees
Participants
Costs
Incentives
Market Structure
Historical
Confinity
X.com
eBay
Digital Payments
The underlying subject is the same.
The decomposition changes.
Therefore a dimension is not simply metadata.
It is a lens over the model.
Mathematically:
$$ M_d=L_d(M,Q) $$
where:
- $M$ = underlying model
- $d$ = dimension
- $L_d$ = lens induced by that dimension
Investigation as Search
We can think of the system as performing search through a conceptual space.
Let the current knowledge state be:
$$ M_t $$
The system considers possible actions:
$$ A_t={a_1,a_2,\ldots,a_n} $$
Possible actions include:
- answer
- decompose
- investigate deeper
- compare
- change dimension
- inspect evidence
- expand a node
- revise a structure
The decision process becomes:
$$ a^*=\arg\max_{a\in A_t} U(a\mid Q,M_t) $$
where $U$ represents the expected usefulness of an action.
This is why Discovery.AI is not simply a static graph generator.
It is an active investigation system.
Recursive Investigation
Suppose:
How does a smartphone send a photo over the internet?
produces:
Photo Sharing
|
+-- Image Processing
+-- Image Encoding
+-- Network Transmission
The user says:
Go deeper into Network Transmission.
Now the system recursively investigates:
Network Transmission
|
+-- Physical Layer
+-- Data Link Layer
+-- Network Layer
Then:
Go deeper into Network Layer.
could produce:
Network Layer
|
+-- IP Addressing
+-- Routing
+-- Packet Forwarding
+-- Fragmentation
This creates recursive abstraction:
$$ N_0 \rightarrow N_1 \rightarrow N_2 \rightarrow N_3 $$
Each level represents a different abstraction scale.
Zoom Is Changing Abstraction
Zooming is not merely displaying more nodes.
It changes the abstraction level of the question.
At one level:
Internet
At another:
Routing
At another:
BGP
At another:
Autonomous System
Therefore:
$$ \boxed{Zoom = Change\ of\ abstraction} $$
rather than:
$$ Zoom = Show\ hidden\ children $$
A real-world concept can be viewed at multiple scales.
Evidence and Epistemics
One of the most important problems we discovered was that a fluent answer can contain information that was never actually investigated.
For example, a central-bank investigation could investigate:
Open Market Operations
Interest on Reserves
Standing Facilities
Reserve Requirements
while the final answer also discusses:
- bank lending
- asset prices
- exchange rates
- forward guidance
Those mechanisms may not have been investigated by the children.
The final answer can still sound confident.
But:
$$ \boxed{Confidence \neq Provenance} $$
Structural Provenance
A claim can be:
Direct
No children were required.
$$ C \leftarrow Q $$
Derived
The claim comes from one investigated child.
$$ C \leftarrow C_1 $$
Synthesized
The claim combines multiple investigated children.
$$ C \leftarrow {C_1,C_2,\ldots,C_n} $$
This is structural provenance.
It tells us:
Where in the investigation did this understanding originate?
Content Provenance
Structural provenance is not enough.
A synthesized answer may contain additional claims that weren't actually investigated.
Therefore the answer is broken into atomic propositions:
$$ A={c_1,c_2,\ldots,c_n} $$
Each proposition is classified as:
$$ origin(c_i)\in {investigated,\;uninvestigated} $$
This is intentionally done at the claim/concept level, not by sentence matching.
A single sentence may contain multiple propositions.
Therefore:
$$ sentence \neq claim $$
Claim Provenance
The emerging epistemic structure is:
Node
|
+-- Claim
|
+-- Evidence
|
+-- Source
A synthesized claim can have a derivation structure:
Claim C
/ \
Claim A Claim B
| |
Source X Source Y
A claim can depend on multiple pieces of understanding.
Therefore provenance itself can be recursive.
Evidence Is Not Truth
Another principle we learned is:
$$ Evidence \neq Truth $$
A source can be:
- irrelevant
- weak
- outdated
- contradictory
- incomplete
- highly authoritative
The system therefore needs to preserve the distinction between:
"We found a source."
and:
"This source strongly supports the claim."
During real investigation we encountered irrelevant research results. The retrieval system returned unrelated physics papers for a payment-system question.
The evidence scorer gave them extremely low confidence while relevant payment research received substantially higher scores.
This demonstrated:
Retrieval, evidence, and truth judgment are different operations.
Claims and Relationships
A relationship may be:
- complementary
- sequential
- alternative
- conflicting
- unrelated
For example:
$$ A \rightarrow B $$
could mean:
A causes B
while another relation may represent mutual reinforcement.
But relationship semantics cannot be reduced to graph topology alone.
We therefore think of a relationship conceptually as:
$$ R=(A,B,Q,T,P) $$
where:
- $A$ = first claim/node
- $B$ = second claim/node
- $Q$ = question context
- $T$ = relationship type
- $P$ = provenance/reasoning
This is why a relationship can itself become epistemically interesting.
Why the Question Is Part of the Semantics
Consider:
How do network effects and economies of scale contribute to dominance?
This asks for cooperation.
But:
Which primarily explains dominance: network effects or economies of scale?
asks for competition.
The entities did not change.
The question did.
Therefore the semantic state is not:
$$ S=f(A,B) $$
but:
$$ \boxed{S=f(A,B,Q)} $$
This is one of the foundational ideas behind Discovery.AI.
The Graph Is a Network, Not a Tree
A tree assumes:
$$ one\ parent \rightarrow many\ children $$
But real systems contain cross-connections.
For example:
Generation ---- produces ----> Electricity
| |
| v
+---- affects ----------> Frequency
^
|
Transmission ---- regulates ------+
A real electric grid is not a tree.
A real economy is not a tree.
A computer network is not a tree.
Knowledge is not a tree.
The world model therefore needs to support:
$$ G=(V,E) $$
with arbitrary meaningful relationships.
The hierarchy is only one possible view over the network.
Knowledge as a Multi-Scale Network
A deeper view is that knowledge isn't naturally a tree.
It is a network:
$$ G=(V,E) $$
but each node may itself contain another graph:
$$ v_i \rightarrow G_i $$
Therefore:
$$ G=(V,E,{G_i}) $$
This gives us recursive structure.
A city can contain:
City
|
+-- Infrastructure
|
+-- Electricity
|
+-- Generation
|
+-- Power Plant
At another abstraction level:
City
|
+-- Economy
+-- Politics
+-- Culture
+-- Geography
The graph is therefore a network of abstractions.
Learning as Bayesian Updating
A useful theoretical interpretation is Bayesian.
Suppose the system has a hypothesis:
$$ H $$
and evidence:
$$ E $$
Then:
$$
P(H\mid E)
\frac{P(E\mid H)P(H)} {P(E)} $$
The system begins with a prior model.
Investigation produces evidence.
Evidence updates the model.
Thus:
$$ M_{t+1}=Update(M_t,E_t) $$
The important point is that the model should not merely accumulate information.
It should be capable of changing when new evidence contradicts previous assumptions.
Structure Revision
A decomposition is not sacred.
Suppose the system initially creates:
Payment
|
+-- Authorization
+-- Clearing
+-- Settlement
But investigation reveals that a different abstraction is more useful for the current question.
The system should eventually be able to revise:
Payment
|
+-- Transaction Processing
Therefore:
$$ D_t \rightarrow Evidence \rightarrow D_{t+1} $$
where:
$$ D_{t+1}\neq D_t $$
if the original abstraction was inadequate.
Decomposition is a hypothesis, not a commandment.
Persistence Is an Explicit Decision
Not everything discovered during an investigation should automatically become permanent knowledge.
Therefore:
$$ Investigation\ Result \neq Persistent\ Knowledge $$
A temporary investigation can remain temporary.
A user can explicitly choose to persist knowledge.
This prevents the long-term model from filling with every speculative intermediate thought.
The Epistemic Stack
Our system increasingly separates knowledge into layers:
WORLD MODEL
|
Relations
|
Claims
|
Evidence
|
Sources
|
Investigation Trace
Each layer answers a different question.
Source
Where did information come from?
Evidence
What part of the source supports the claim?
Claim
What are we asserting?
Relation
How do claims/entities relate?
World Model
What structure do we currently believe describes the subject?
Investigation Trace
How did we arrive here?
This prevents all epistemic questions from being collapsed into one confidence number.
Confidence Is Not One-Dimensional
A number like:
$$ confidence=0.95 $$
can hide several different things.
We may actually need:
$$ C= f( evidence, coverage, agreement, source\ quality, reasoning, uncertainty ) $$
A claim can have strong evidence and high source quality while still being contested.
Another claim may have weak evidence yet be presented fluently by an LLM.
Therefore:
$$ LLM\ confidence \neq epistemic\ confidence $$
Competing Knowledge
The system should eventually be able to preserve competing explanations.
Suppose:
$$ H_1=\text{Network effects explain dominance} $$
and:
$$ H_2=\text{Regulatory capture explains dominance} $$
Instead of immediately forcing:
$$ H_1\land H_2 $$
or selecting one, the graph should be capable of representing:
$$ H_1 \leftrightarrow H_2 $$
with a relationship such as:
alternative explanation
while preserving:
- reasoning
- evidence
- sources
- question context
This is closer to scientific reasoning than simply storing one "correct" answer.
Knowledge Can Contradict Itself
A mature knowledge system should not be afraid of contradiction.
If:
$$ C_1 $$
and:
$$ C_2 $$
contradict each other, the correct operation is not necessarily:
$$ delete(C_2) $$
It may instead preserve both:
Claim A
|
+-- supported by Source X
Claim B
|
+-- supported by Source Y
A <---- conflicts ----> B
The system can then ask:
Under what conditions is A true?
Under what conditions is B true?
Contradiction can generate understanding rather than simply being treated as an error.
The Recursive Epistemic Question
Once relationships themselves have claims and evidence, a deeper question appears:
Is a relationship itself a claim?
Suppose:
A ---- causes ----> B
The statement:
A causes B
is itself a proposition.
Therefore it can have:
- evidence
- sources
- uncertainty
- competing explanations
This creates recursive epistemology:
$$ Claim \rightarrow Claim\ about\ Claim \rightarrow Claim\ about\ Relationship \rightarrow \cdots $$
We do not assume recursion everywhere merely because it is elegant.
We introduce it only when the semantics require it.
Investigation Trace vs. World Model
We deliberately preserve both.
Investigation Trace
Answers:
What did the AI do?
Question
|
+-- Decision
+-- Decomposition
+-- Investigation
+-- Evidence retrieval
+-- Synthesis
World Model
Answers:
What has the system learned?
Nodes
|
Relations
|
Claims
|
Evidence
|
Sources
The two structures are related but not identical.
Formally:
$$ I \rightarrow M $$
but:
$$ I \neq M $$
Architecture
At a high level:
USER
|
v
QUESTION
|
v
+----------------+
| Intent / Context|
+----------------+
|
v
+----------------+
| Question Engine |
+----------------+
|
v
+----------------+
| Ground Agent |
+----------------+
|
+-------------+-------------+
| | |
v v v
Decide Investigate Answer
| |
| v
| Evidence
| |
| v
| Claims
| |
+-------------+
|
v
Synthesis
|
v
WORLD MODEL
|
+-------------+-------------+
| |
v v
Neo4j Sources
|
+-----+------+
| |
Nodes Relationships
|
Claims
|
Evidence
The Recursive Loop
The entire system can be expressed as:
$$
M_{t+1}
F( M_t, Q_t, I_t, E_t, C_t, R_t ) $$
where:
- $M_t$ = current model
- $Q_t$ = user question
- $I_t$ = investigation decisions
- $E_t$ = evidence
- $C_t$ = claims
- $R_t$ = relationships
Then:
$$ Q_{t+1}=G(M_{t+1},U_{t+1}) $$
where $U_{t+1}$ represents the user's next intention.
This produces:
$$ M_0 \rightarrow Q_0 \rightarrow M_1 \rightarrow Q_1 \rightarrow M_2 \rightarrow Q_2 \rightarrow \cdots $$
The user and system participate in a continuous knowledge-construction process.
Why This Is Different From RAG
Retrieval-Augmented Generation generally follows:
$$ Q \rightarrow Retrieve(D) \rightarrow Generate(A) $$
Discovery.AI can use retrieval, but retrieval is not the final architecture.
Our target is:
$$ Q \rightarrow Investigate \rightarrow Retrieve \rightarrow Reason \rightarrow Model \rightarrow Update $$
RAG primarily answers:
What information can I retrieve for this question?
Discovery.AI asks:
How should this information change my model of the subject?
Why This Is Different From a Static Knowledge Graph
A static knowledge graph tends toward:
$$ A \rightarrow B $$
Discovery.AI moves toward:
$$ A \xrightarrow[Q]{R} B $$
The question context matters.
The relationship can have reasoning.
The relationship can accumulate evidence.
The relationship can be reconsidered.
The graph can therefore evolve.
Why This Is Different From a Chatbot
A chatbot primarily maintains a conversation.
Discovery.AI maintains an evolving model.
Chatbot
$$ Conversation_t \rightarrow Response_t $$
Discovery.AI
$$ Conversation_t \rightarrow Model_t \rightarrow Investigation \rightarrow Model_{t+1} $$
The conversation becomes an interface for manipulating understanding.
Semantic Zoom
The graph should support multiple abstraction levels.
For example:
Level 0
Internet
Level 1
Internet
|
+-- Routing
+-- Transport
+-- Application
Level 2
Routing
|
+-- BGP
+-- OSPF
+-- Forwarding
Level 3
BGP
|
+-- Autonomous Systems
+-- Route Advertisement
+-- Path Selection
This resembles hierarchical abstraction in complex systems.
A learner can move between:
$$ Macro \leftrightarrow Meso \leftrightarrow Micro $$
without losing the conceptual identity of the subject.
The System as an Active Learner
Discovery.AI can also be interpreted as an active learning system.
At every point it has uncertainty:
$$ U(M) $$
It can choose an investigation action that potentially reduces uncertainty:
$$
a^*
\arg\max_a \mathbb{E} [ U(M_t)-U(M_{t+1}\mid a) ] $$
In an ideal future implementation, the system would investigate the question that produces the greatest useful reduction in uncertainty.
This transforms investigation from:
"What should I search?"
into:
"What should I learn next?"
Information Gain
A related theoretical idea is information gain.
If uncertainty is represented by entropy:
$$
H(X)
-\sum_x P(x)\log P(x) $$
then:
$$
IG(X;E)
H(X)-H(X\mid E) $$
A future Discovery.AI could prioritize investigations according to expected information gain.
For example, if we already understand:
Generation
Transmission
Distribution
but don't understand how they remain synchronized, the next investigation might target:
Grid Control / Frequency Regulation
because that missing concept could explain relationships between several existing nodes.
Understanding as Compression
Another useful theoretical interpretation comes from information theory.
A good abstraction compresses many observations into a smaller structure without destroying the relationships that matter.
If:
$$ X=\text{many observations} $$
and:
$$ Z=\text{abstract model} $$
then:
$$ X\rightarrow Z $$
where $Z$ is significantly simpler than $X$ while retaining useful predictive information.
This suggests:
$$
\text{Good abstraction}
\text{maximum useful compression}
\text{minimum lost structure} $$
Too little decomposition:
$$ X\rightarrow Z_{\text{too coarse}} $$
Too much decomposition:
$$ X\rightarrow Z_{\text{too fragmented}} $$
The goal is an abstraction that preserves the structure relevant to the question.
Abstraction as a Lossy Transformation
Every abstraction discards information.
Let:
$$ A:X\rightarrow Z $$
be an abstraction function.
Then:
$$ Z=A(X) $$
is not identical to $X$.
The question is whether the information discarded is relevant.
Therefore abstraction quality depends on the task:
$$ Quality(A\mid Q) $$
not simply:
$$ Quality(A) $$
This provides a mathematical reason why question-relative decomposition makes sense.
The Epistemic Design Principles
The architecture is guided by several principles:
- Model the world, not the investigation.
- Treat decomposition as a hypothesis.
- Treat relationships as contextual when the evidence requires it.
- Separate provenance from confidence.
- Separate evidence from truth.
- Preserve competing explanations rather than forcing premature consensus.
- Use the smallest primitive that survives real examples.
- Let semantics win over architectural elegance.
- Test new mechanisms against real traces before trusting them.
- Do not introduce recursion merely because recursion is aesthetically attractive.
What We Actually Built
The current system already contains several working pieces.
Recursive investigation
The system can decide whether to:
- decompose
- answer
- investigate deeper
- reach a boundary
Dimension steering
The system supports contextual investigation lenses and dimension changes.
Conversational navigation
Users can interact with the model using natural language:
Show me X
Go deeper into X
Show me the economic perspective
Compare X and Y
Graph persistence
The model can be persisted into Neo4j.
Evidence gathering
Real sources can be attached to investigated claims.
Provenance
Claims can be traced through investigation structure and audited for whether their content was actually investigated.
Model-provider resilience
The system can fall back between AI providers when a provider hits rate limits or fails.
Interactive graph
The model can be explored visually rather than only through text.
Challenges We Ran Into
1. The graph looked right but meant the wrong thing
Our original graph was an investigation tree.
It looked like knowledge.
It was actually history.
This was the first major architectural realization.
2. The AI could be confident beyond its investigation
We found answers containing substantial material that had never been investigated.
This forced us to separate:
$$ confidence $$
from:
$$ provenance $$
and:
$$ coverage $$
3. Relationships were more complicated than nodes
We initially expected relationships to be straightforward.
Instead, we discovered:
$$ R=f(A,B,Q) $$
Relationships can depend on the question.
4. Identity is contextual
Two nodes can have the same name but represent different things.
Therefore:
$$ name(A)=name(B) $$
does not imply:
$$ A=B $$
Context matters.
5. LLMs are probabilistic systems
We encountered:
- malformed structured outputs
- provider failures
- rate limits
- inconsistent self-reporting
- model-specific behavior
- accidental entity duplication
This reinforced:
Never assume that because an LLM can produce a structure, it will consistently produce that structure.
The architecture must tolerate uncertainty and failure.
Accomplishments We Are Proud Of
We are proud not only that the system works, but that we discovered its architecture through real use.
We built a system capable of:
$$ Ask \rightarrow Investigate \rightarrow Build \rightarrow Explore \rightarrow Reframe \rightarrow Compare \rightarrow Expand $$
We demonstrated:
- recursive decomposition
- adaptive framing
- multi-dimensional investigation
- graph persistence
- conversational graph navigation
- evidence gathering
- provenance auditing
- model-provider fallback
- real-time interactive exploration
More importantly, we developed a methodology:
Test the semantics before implementing the abstraction.
What We Learned
The biggest lesson was:
Knowledge representation is harder than knowledge generation.
Generating a paragraph is easy.
Determining what that paragraph means structurally is hard.
The difficult questions are:
- What exactly is this thing?
- Should it become a node?
- Is this relationship causal, structural, sequential, complementary, or competitive?
- Did this claim actually come from the investigation?
- What evidence supports it?
- Is the evidence strong?
- Does the relationship depend on the question?
- Are two identically named concepts actually the same?
- Should this abstraction be permanent?
These questions transformed the project.
We stopped thinking:
"How do we make the LLM smarter?"
and started asking:
"How do we build an environment in which intelligence can construct, inspect, and revise models?"
What's Next for Discovery.AI
The next stage is to turn the prototype into a true world-model learning environment.
We want the system to eventually support:
Semantic graph editing
Add this relationship.
Remove this assumption.
Merge these concepts.
Separate these concepts.
Evidence-aware reasoning
What supports this?
What contradicts this?
How strong is the evidence?
Competing explanations
What are the major explanations?
Which evidence supports each?
Where do they disagree?
Structural revision
Was our original decomposition wrong?
Should these nodes be merged?
Should this branch be split?
Multi-scale exploration
Zoom out
Zoom in
Change abstraction
Change dimension
Autonomous learning paths
Eventually the system could identify the most informative next question:
$$
Q^*
\arg\max_Q \mathbb{E}[IG(M;Q)] $$
where $IG$ represents expected information gain.
The system would no longer simply wait for:
"What should I ask next?"
It could say:
"There is an important unexplained relationship here. Investigating it would most improve the current model."
The Vision
We do not want to build an AI that simply knows more facts.
We want to build an AI that helps humans construct understanding.
A search engine gives you information.
A chatbot gives you an answer.
A knowledge graph gives you connections.
Discovery.AI aims to give you a living model that you can question, explore, challenge, and reshape.
The final vision is:
$$ \boxed{ Human + AI + Evidence + Model + Questions \rightarrow Understanding } $$
One question creates a model.
The model creates new questions.
Those questions produce evidence.
Evidence changes the model.
The model becomes richer.
And the cycle continues:
$$ M_0 \rightarrow Q_0 \rightarrow M_1 \rightarrow Q_1 \rightarrow M_2 \rightarrow Q_2 \rightarrow \cdots $$
That is Discovery.AI:
Not an AI that tells you what to think.
An AI that helps you build something worth thinking with.
Built With
- ai
- discovery
- knowledge