Agda vs Isabelle Hol

Two heavyweight proof assistants from different philosophies. Agda is dependent types as a programming language; Isabelle/HOL is industrial-strength automated theorem proving. We pick the one that gets real proofs finished.

What they actually are

Agda is a dependently typed functional language in the Martin-Löf / intuitionistic tradition — proofs are programs, types are propositions, and you write them with the same machinery you'd use to write Haskell with steroids. It is gorgeous and uncompromising: unicode-laden, total, constructive. Isabelle/HOL is a different animal. It's a generic proof assistant instantiated on Higher-Order Logic — classical, with the law of excluded middle baked in — wrapped in a mature LCF-style kernel and the Isar structured proof language. Agda asks you to construct evidence by hand. Isabelle asks you to state the goal and lets a small army of tactics and external automated provers go find the evidence. That single difference — manual term construction versus automated proof search — colors everything downstream, from who uses each to what they're realistically used for.

Automation: the decisive gap

This is where Isabelle/HOL is simply not in the same weight class. Sledgehammer dispatches goals to external ATPs and SMT solvers (E, Vampire, Z3, CVC) and reconstructs the proof for you; simp, auto, blast, and metis clean up the rest. You spend your time deciding what's true, not convincing the checker that obvious things are obvious. Agda has essentially no proof search worth the name — Agsy is a toy by comparison, and the language's strength (full dependent types) is exactly what makes automation hard, because the search space is undecidable and the goals are richer. The result is brutal: a routine arithmetic or case-analysis lemma that Isabelle closes with by auto can cost you twenty lines of explicit Agda. For anything beyond small, elegant formalizations, that overhead compounds into project-killing tedium.

Libraries and getting unstuck

Isabelle's Archive of Formal Proofs is the largest peer-reviewed body of formal mathematics and verified systems anywhere — hundreds of entries, millions of lines, covering analysis, algebra, algorithms, security protocols, and compilers. When you hit a wall, odds are someone already formalized the lemma and you can lean on it. Agda's standard library is well-crafted and pedagogically clean, but it is small, opinionated, and changes under you between versions — Agda's backward-compatibility story is notoriously rough. There's no AFP-scale ecosystem to draft behind. Tooling tells the same story: Isabelle ships a real IDE (jEdit-based) with live proof state and parallel checking, while Agda lives in Emacs/VS Code interactive mode that's lovely for hole-driven development but offers far less when proofs get large and you need to manage a sprawling theory.

When Agda still wins

Don't read this as Agda being bad — it isn't, it's the more principled tool and there are jobs only it does cleanly. If proofs-as-programs matters because you want to extract and run the constructive content, Agda's computational interpretation is direct and honest in a way classical HOL is not. For programming-language research, type theory itself, and teaching the Curry-Howard correspondence, Agda's dependent pattern matching and first-class proof terms are unmatched — you see the proof, you manipulate it, nothing is hidden behind a tactic black box. Haskell refugees feel at home. But 'principled and beautiful' loses to 'finished and verified' the moment you have a deadline and a real system to certify. Agda rewards the connoisseur; Isabelle rewards the engineer. Most people who need a proof assistant are engineers, even when they'd rather be connoisseurs.

Quick Comparison

Factor	Agda	Isabelle Hol
Logic foundation	Constructive (intuitionistic) dependent type theory	Classical Higher-Order Logic
Proof automation	Minimal (Agsy); mostly manual term construction	Sledgehammer + simp/auto/blast, external ATP/SMT
Library ecosystem	Small, elegant stdlib; weak back-compat	Archive of Formal Proofs, the largest curated corpus
Proofs as runnable programs	Direct — proofs are executable dependent programs	Code generation exists but less native
Tooling / IDE	Emacs/VS Code interactive hole-driven mode	Dedicated IDE, parallel checking, live proof state

The Verdict

Use Agda if: You want dependent types as a real programming language, value constructive proofs as executable programs, are doing type-theory or PL research, or are coming from Haskell and want proofs-as-code with first-class pattern matching.

Use Isabelle Hol if: You want to actually finish proofs — verifying algorithms, protocols, or formalizing mathematics — and want heavy automation (sledgehammer, simp, auto) plus the largest curated proof library in existence to lean on.

Consider: Neither is your day job's tool. If you want the modern math-formalization community and a growing library, Lean 4 has eaten much of this lane and deserves a look before you commit to either.

Agda vs Isabelle Hol: FAQ

Is Agda or Isabelle Hol better?

Isabelle Hol is the Nice Pick. Isabelle/HOL wins on the only axis that pays rent: getting nontrivial proofs done without hand-grinding every lemma. Its sledgehammer-plus-automation stack, the enormous Archive of Formal Proofs, and a logic simple enough that automation actually works make it the productive choice for verifying real systems and mathematics. Agda is more beautiful and more honest about computation, but you pay for that beauty by proving almost everything by hand.

When should you use Agda?

You want dependent types as a real programming language, value constructive proofs as executable programs, are doing type-theory or PL research, or are coming from Haskell and want proofs-as-code with first-class pattern matching.

When should you use Isabelle Hol?

You want to actually finish proofs — verifying algorithms, protocols, or formalizing mathematics — and want heavy automation (sledgehammer, simp, auto) plus the largest curated proof library in existence to lean on.

What's the main difference between Agda and Isabelle Hol?

Two heavyweight proof assistants from different philosophies. Agda is dependent types as a programming language; Isabelle/HOL is industrial-strength automated theorem proving. We pick the one that gets real proofs finished.

How do Agda and Isabelle Hol compare on logic foundation?

Agda: Constructive (intuitionistic) dependent type theory. Isabelle Hol: Classical Higher-Order Logic.

Are there alternatives to consider beyond Agda and Isabelle Hol?

Neither is your day job's tool. If you want the modern math-formalization community and a growing library, Lean 4 has eaten much of this lane and deserves a look before you commit to either.

The Bottom Line

Isabelle Hol wins

Isabelle/HOL wins on the only axis that pays rent: getting nontrivial proofs done without hand-grinding every lemma. Its sledgehammer-plus-automation stack, the enormous Archive of Formal Proofs, and a logic simple enough that automation actually works make it the productive choice for verifying real systems and mathematics. Agda is more beautiful and more honest about computation, but you pay for that beauty by proving almost everything by hand.

Related Comparisons