We source, vet, and manage hiring so you can meet qualified candidates in days, not months. Strong English, U.S. time zone overlap, and compliant hiring built in.
.svg){kind=logo}
Agda is a dependently-typed functional programming language and interactive proof assistant developed at Chalmers University of Technology. Unlike most programming languages that check types at compile time, Agda allows you to express mathematical properties as types and then write code that proves those properties are correct. It's used for formal verification, mathematical proof development, and research in type theory and programming language design.
Agda gained prominence in academia and has found niche applications in verification-critical systems where correctness guarantees matter more than development speed. Organizations like Cardano have used Agda for formal specification of blockchain protocols. The language is less than 1% of the programming talent pool globally, making it one of the rarest in-demand skills.
The learning curve for Agda is steep. It requires understanding of dependent types, type-driven development, and mathematical notation. However, developers who master Agda gain deep expertise in formal methods and can apply those principles to other languages and systems.
If you're building systems where formal guarantees matter, financial algorithms, cryptographic protocols, or research tools that require mathematical correctness, Agda developers bring unique value. The talent pool is tiny, but highly specialized and deeply expert in their domain.
Hire Agda developers when you need formal verification of critical algorithms, particularly in cryptography, blockchain, financial systems, or safety-critical applications. Practical use cases: formal specification of blockchain consensus protocols, verification of cryptographic implementations, type-safe financial calculations where mathematical properties must be provably correct, and research systems that require publication of formal guarantees.
Don't hire Agda for typical web applications, mobile apps, or business software unless formal correctness is a core requirement. The overhead of formal verification is only justified for extremely high-stakes systems. For most projects, a carefully-vetted developer in Rust, TypeScript, or Java will be more pragmatic.
Team composition: Agda developers work best paired with domain experts in your specific application (cryptography, finance, etc.). They'll also benefit from peers who understand type theory. Most successful teams run Agda specialists alongside engineers working in faster-moving languages.
Must-have skills: Deep proficiency in Agda syntax and the type system. Understanding of dependent types, proof tactics, and interactive development. Mathematical maturity and comfort with abstract algebra or category theory concepts. Experience writing non-trivial Agda programs or proofs, not just classroom exercises.
Nice-to-haves: Experience with Coq, Lean, or other proof assistants. Understanding of formal methods and verification theory. Background in cryptocurrency, cryptography, or systems with high correctness requirements. Contributions to formal verification research or open source Agda projects.
Red flags: Developers with only theoretical or academic experience who haven't written production code in any language. Anyone uncomfortable with the slow development pace of formal verification. Lack of communication skills in explaining formal guarantees to non-expert stakeholders.
Junior (1-2 years): Can write simple Agda proofs with significant guidance. Understands basic type theory and can read others' code. Struggles with complex dependent types and type inference.
Mid-level (3-5 years): Can independently write verified algorithms and complex proofs. Understands advanced type theory concepts and can mentor juniors. Comfortable with Agda's interactive development process.
Senior (5+ years): Deep expertise in both Agda and formal verification methodologies. Can design new libraries and frameworks. Can explain formal guarantees in business terms to stakeholders. Rare and highly valuable.
Tell me about a non-trivial Agda proof or verified program you've written. What was the most difficult part? Listen for: specific technical details about the proof or program, understanding of why certain properties were hard to prove, evidence of iterative debugging. Academic papers or GitHub projects are ideal here.
Describe a time you had to explain formal verification or dependent types to someone without a math background. How did you approach it? This is critical for communication. Good answers show ability to translate formal concepts into practical business language.
Why do you want to work on formal verification rather than traditional software development? Listen for: genuine passion for correctness guarantees, understanding of when formal methods are worth the cost, not dismissal of practical concerns.
What's your experience with other proof assistants (Coq, Lean, etc.)? How does Agda compare in your view? Good answers show nuanced understanding of different tools' tradeoffs. Weak answers suggest limited breadth of formal methods knowledge.
Explain dependent types in Agda. What can you express with dependent types that you can't express with regular types? Good answers provide concrete examples (Vec, Fin, etc.) and discuss how dependent types enable proofs at the type level.
How do you handle decidability and computability in Agda? Describe a situation where you needed to prove a function is decidable. Look for: understanding of the distinction between propositions and decisions, knowledge of the Decidable type class, real examples of proving decidability.
Walk me through how you'd prove a simple property (e.g., that list append is associative) in Agda. Evaluation: Basic proof competence. The answer should show understanding of pattern matching, induction, type-driven development.
Describe Agda's type checking process. Why is Agda more computationally expensive to type-check than languages like Haskell? Good answers cover unification of dependent types, normalization, and the decidability of type checking.
Scenario: You're building a formally verified implementation of a sorting algorithm. Write an Agda function that sorts a list of natural numbers and returns a proof that the output is sorted and contains the same elements as the input.
Scoring rubric: Does the candidate write correct Agda syntax? Do they handle both the computational part and the proof parts? Can they discuss when full verification is worth the complexity?
Typical US Equivalents: Junior: $80,000-$110,000/year. Mid-level: $120,000-$180,000/year. Senior: $160,000-$240,000/year. LatAm Agda developers cost 40-60% less than US equivalents. Availability is the primary constraint, not cost.
Latin America has a small but growing community of formal methods researchers and developers, particularly in Brazil and Argentina where university research programs have strong connections to academic formal methods research. Universities like UNAM (Mexico) and USP (Brazil) have research groups working on type theory and verification.
Time zone advantage: LatAm developers are UTC-3 to UTC-5, giving 6-8 hours of overlap with US East Coast teams. This is important for collaborative proof development where synchronous discussion of complex type systems is valuable.
Cost efficiency is less relevant here since the global talent pool is so small. Finding available Agda expertise at all is the primary challenge. LatAm has a small but dedicated cohort of researchers and developers with genuine expertise, not generalists learning the language.
English proficiency is high among academic-trained developers in LatAm. Most have published papers, attended international conferences, and collaborated with English-speaking peers. They're accustomed to technical communication and documentation.
South maintains connections with formal methods researchers and developers across LatAm who have demonstrated Agda expertise. Our vetting process includes code review of published work, GitHub projects, or research contributions. For Agda roles, we prioritize depth over breadth.
Matching starts with understanding your requirements: Are you building a new formally verified system from scratch, or maintaining and extending existing Agda code? Do you need published research-grade formalization, or pragmatic verification of critical algorithms? This shapes which developers in our network are the right fit.
Most Agda placements involve interview discussions about theoretical foundations and specific properties you're trying to prove. This is more about conceptual fit than typical coding challenges. South backs every placement with a 30-day replacement guarantee. Start the conversation at https://www.hireinsouth.com/start
No, but industry adoption is still limited. Cryptocurrency and blockchain projects like Cardano have used Agda for formal specification of protocols. Financial institutions with high correctness requirements use Agda-like approaches. Most enterprise software doesn't need formal verification, but some domains absolutely require it.
6-12 months of full-time work to write simple proofs confidently. 2-3 years to handle complex dependent types and non-trivial verification. 5+ years to master the design space and contribute new techniques.
Each has tradeoffs. Agda excels at type-driven development and IDE support. Coq has a larger ecosystem and industry adoption. Lean has strong community support and modern tooling. Your choice depends on ecosystem needs and team background.
Technically yes, but it's not practical. Agda code is slower to write and type-check than TypeScript or Python. The formal guarantees aren't worth the overhead for most business logic. Use Agda only where correctness cost is very high.
Experienced Agda developers in LatAm cost $50,000-$110,000/year depending on seniority. Compare that to $160,000-$240,000+ for equivalent US expertise. Availability is the real constraint, not cost. South can usually source Agda talent within 3-4 weeks.
This is common. Many Agda developers consult part-time or work on research projects in parallel. South can facilitate part-time arrangements, project-based contracts, or advisory relationships. Formal verification projects often have clear scope and endpoints.
Not strictly, but some overlap with your working hours helps. Agda development involves collaborative proof discussion where synchronous communication accelerates progress. LatAm developers (UTC-3 to UTC-5) have 6-8 hours of overlap with US East Coast.
We review published work, GitHub repositories, academic papers, and references from other researchers. We ask detailed technical questions about dependent type systems and proof techniques. For roles, we request code samples of non-trivial Agda proofs.
Domain expertise in cryptography, finance, or blockchain is valuable. Rust or C++ expertise for systems work helps. Strong mathematical background in algebra or type theory. Experience with other proof assistants or formal methods tools.
It depends. If you're building a cryptography research project, yes. For most applications, you'll have a small core team of Agda specialists paired with developers in more practical languages (Rust, TypeScript) who implement the verified algorithms.
