Agda vs Isabelle/HOL: Which Proof Assistant Wins
A decisive verdict on Agda versus Isabelle/HOL — dependent-type programming language versus the automation-heavy classical proof workhorse. We pick the one that actually closes goals.
The short answer
Isabelle Hol over Agda for most cases. For getting real theorems proved and maintained, Isabelle/HOL wins on automation, libraries, and tooling — sledgehammer plus the Archive of Formal Proofs does.
- Pick Agda if doing dependent-type theory research, constructive mathematics, or want proofs that double as runnable, type-checked programs with full programmability of the language itself
- Pick Isabelle Hol Which Proof Assistant Wins if want to actually prove things — verifying algorithms, protocols, and classical math — with heavy automation, a huge curated proof library (AFP), and the least manual grinding
- Also consider: Lean 4 if you want modern tooling, a fast-growing math library (mathlib), and dependent types with strong automation — it increasingly eats both of these lunches.
— Nice Pick, opinionated tool recommendations
What they actually are
Agda is a dependently typed functional programming language that happens to be a proof assistant — proofs are programs, types are propositions, and you write everything by hand in a Haskell-flavored syntax with Unicode galore. It is gorgeous and uncompromisingly constructive. Isabelle/HOL is a generic proof assistant instantiated with higher-order logic — classical, with the law of excluded middle and choice baked in — built around an LCF-style trusted kernel and an enormous tactic and automation layer. The philosophical split matters: Agda treats proving as type-directed programming; Isabelle treats it as interactive goal-state manipulation backed by automated reasoners. If you came expecting a like-for-like swap, you didn't. One is a language you compute in; the other is a theorem-proving environment you drive. That distinction decides almost everything below, including who you hire and how long the project takes.
Automation: the decisive gap
This is where the comparison stops being close. Isabelle/HOL ships sledgehammer, which fires your goal at external ATPs and SMT solvers (E, Vampire, Z3, cvc5) and hands back a reconstructed, kernel-checked proof you paste in. Combined with auto, simp, blast, and metis, it discharges a staggering fraction of routine obligations with no manual term construction. Agda has essentially none of this. There is Agsy (auto) and some reflection-based tooling, but in practice you build every proof term by hand, case-splitting and pattern-matching your way through. For a constructive-type-theory exercise that is the point. For verifying a 5,000-line algorithm it is a slog. The honest summary: Isabelle automates the boring 80% so you spend effort on the hard 20%; Agda makes you earn all 100%. If throughput on real proof obligations is your metric, this is a knockout.
Libraries and ecosystem
Isabelle has the Archive of Formal Proofs — hundreds of peer-reviewed, continuously maintained entries spanning analysis, algebra, security protocols, compilers, and data structures. It is the single largest curated body of mechanized mathematics outside mathlib, and it is genuinely reusable. Agda's standard library is well-engineered and a joy to read, but it is a fraction of the size and far more oriented toward type-theory foundations than toward 'I need a verified red-black tree today.' Cubical Agda is a real differentiator — proper univalence and higher inductive types that Isabelle simply cannot express — so for homotopy type theory Agda is the only serious choice. But measured by breadth of off-the-shelf, battle-tested formalizations you can stand on, Isabelle's ecosystem is deeper and more practically loaded. You will reinvent fewer wheels.
Tooling, learning curve, and pain
Isabelle ships its own jEdit-based IDE with continuous checking, a polished structured proof language (Isar) that reads like real mathematics, and excellent counterexample finders (nitpick, quickcheck) that save you from chasing false goals. Onboarding is steep but well-trodden, with the Concrete Semantics textbook as a paved road. Agda lives in Emacs (or VS Code) with superb interactive hole-driven editing — the goal-and-context refinement loop is honestly the best in the business — but the surrounding experience is rougher, error messages get cryptic fast, and termination/positivity checkers will fight you. Agda's pain is conceptual and self-inflicted by its constructivism; Isabelle's pain is upfront and then it flattens. Neither is beginner-friendly, but Isabelle rewards persistence with productivity, while Agda rewards it with deeper understanding of type theory and a lingering sense that you're proving things the artisanal way.
Quick Comparison
| Factor | Agda | Isabelle Hol Which Proof Assistant Wins |
|---|---|---|
| Proof automation | Minimal — Agsy/auto only; hand-built proof terms | Sledgehammer + ATP/SMT, auto, simp, blast |
| Library breadth | Elegant stdlib, type-theory focused, smaller | Archive of Formal Proofs — huge, curated, reusable |
| Logic foundation | Constructive dependent type theory; Cubical/HoTT | Classical higher-order logic (excluded middle, choice) |
| Interactive editing | Best-in-class hole-driven, type-directed refinement | Solid jEdit IDE + readable Isar structured proofs |
| Time-to-verified-system | Slow — manual grind on every obligation | Fast — automation discharges routine goals |
The Verdict
Use Agda if: You are doing dependent-type theory research, constructive mathematics, or want proofs that double as runnable, type-checked programs with full programmability of the language itself.
Use Isabelle Hol Which Proof Assistant Wins if: You want to actually prove things — verifying algorithms, protocols, and classical math — with heavy automation, a huge curated proof library (AFP), and the least manual grinding.
Consider: Lean 4 if you want modern tooling, a fast-growing math library (mathlib), and dependent types with strong automation — it increasingly eats both of these lunches.
For getting real theorems proved and maintained, Isabelle/HOL wins on automation, libraries, and tooling — sledgehammer plus the Archive of Formal Proofs does in minutes what Agda makes you grind by hand. Agda is the more beautiful language and the better vehicle for constructive type theory, but beauty doesn't discharge your proof obligations. If your job is verifying systems and math, not researching type theory, Isabelle gets you there faster.
Related Comparisons
Disagree? nice@nicepick.dev