About EVO

EVO is a reasoning system built around a simple idea: if an AI cannot show its work, you should not trust its answer.

That sounds obvious, but pure language models do not work this way. They produce confident, fluent answers from latent knowledge — patterns absorbed during training — without any way to distinguish a remembered fact from a plausible fabrication. When they are wrong, they are wrong silently.

EVO takes a different approach. Every answer it gives must be backed by evidence appropriate to the kind of question being asked. It breaks this into three concrete rules:

1. No hidden premises. If a conclusion depends on a belief that is not provable from the given facts, that belief must be named and declared openly. The system then tests which conclusions survive without each assumption, so you know exactly what the answer rests on.

2. The right tool proves the work. A factual lookup gets a web search. A computation gets Python. A logical argument gets a Prolog derivation. A mathematical proof gets the Lean 4 kernel. No single mechanism is trusted to verify everything — each tier of difficulty gets its own standard of evidence.

3. Failure is explicit. At the end of every reasoning turn, automated checks inspect the work. Were assumptions declared? Was consistency checked? Were all requirements met? If not, the answer is marked INCOMPLETE with a specific reason. The system would rather admit a gap than pretend it solved the problem.

The result is not a system that never makes mistakes — it is a system whose mistakes are visible, traceable, and fixable. You can audit the assumptions, inspect the proof traces, and see exactly where a conclusion came from. That is what the name stands for: Explicit-assumption Verification Orchestrator. State your premises. Prove your conclusions. Own your gaps.

Under the hood, EVO is a neuro-symbolic AI architecture for more reliable autonomous reasoning: instead of treating all tasks as ordinary text generation, it classifies each request into an appropriate tier such as MATHS, CODE, or REASON — with MATHS supporting four ascending rigor levels from computational through formal), then requires evidence matched to that tier, including tool output, computation, source inspection, Prolog derivations, assumption-dependence tests, or Lean 4 kernel verification. Its central design is structured epistemic accountability: assumptions are made explicit, conclusions are tied to proof traces or verification artifacts, and unsupported or under-verified answers are downgraded rather than claimed as solved. This tiered, evidence-grounded workflow improves on pure LLM reasoning not by eliminating every representation error, but by making failures more detectable, recoverable, auditable, and correctable.

The name describes what the system does, in order:

Explicit assumption — When the agent reasons, it cannot sneak in unstated premises. If a conclusion needs a belief that is not directly provable from the facts, that belief has to be named and declared openly (as an assumption/2 in Prolog). The agent then tests which conclusions fall apart without each assumption and labels them dependent or robust.

Verification — The agent cannot just say something is true. It has to prove it using the right tool for the difficulty of the task. For logical reasoning, that means Prolog actually derives the conclusions. For math, Python or SymPy computes the answer. For formal proofs, Lean 4 checks the proof. At the end, a series of gates inspects the work and downgrades the result to INCOMPLETE if evidence is missing.

Orchestrator — The agent is not one model doing everything. It is a coordinator. It classifies the request into one of three tiers, picks the right tools and scratch pad for that tier, runs external engines, and enforces the workflow rules. Each tier has its own orchestrator class in the code

For a detailed technical paper on the EVO architecture, see DeepThought AI — EVO Architecture.