The grant evaluation gap

The gap

DAOs have become good at governance execution - voting, signalling, discussion, proposal formatting, allocation.

But much weaker at: evaluating downstream outcomes, tracking whether goals happened, learning from governance decisions etc. There are far fewer systems for answering questions such as: “Did this actually work?”, “What changed afterward?”, “Would we do this again?”, “What unintended effects emerged?”. Closing this gap could work towards turning governance into a learning system.

Grants as the test case

Proposals vary massively, and it’s difficult to understand the impact of that changing a risk parameter had on the protocol, without first isolating every other factor that could influence outcomes.

Instead let’s focus on grant proposals. Grant-giving DAOs (like Gitcoin, Optimism, and Uniswap Grants) dominate this space because they have a direct financial incentive to solve the evaluation problem. If they fail to measure impact, they waste their treasury. Other types of DAOs, especially smaller DAOs, face completely different governance dynamics that make real-world evaluation less of a priority: they tend to fund and forget.

Attribution, evaluation, accountability

So if we were to look at this from the lens of three questions:

1. ATTRIBUTION — who caused the value?
2. EVALUATION — how much did they deliver vs promise?
3. ACCOUNTABILITY — does future funding change based on (1) and (2)?

Much of the work today in Web3 has mostly been building strong infrastructure for selecting and distributing grants (quadratic funding, reputation based voting etc). The infrastructure for closing the loop - answering the evaluation questions of: did it work, what changed, are mostly tied to the lifecycle of the grant itself and are generally weaker, especially for smaller funders and non-software work.

Deep funding

A fascinating example of answering the question of ‘who caused the value’ comes from deep funding. Instead of ‘how much did project x contribute’, ask ‘if outcome y happened how much credit belongs to dependency x?’. Dependency graphs trace that value back through a chain of dependencies.

Software has a hidden map: app a, uses library b, which uses tool c, which sits on protocol d. Deep funding treats this as a graph:

Nodes = repos, libraries, tools, protocols Edges = “things that depend on the thing”

Each edge is given a weight: how much downstream value should credit this upstream dependency? E.g. if ethereum ‘succeeds’, what share goes to foundry vs hardhat vs a specific library. AI models compete to propose weights across the whole graph (the best model by jury alignment wins). Weights continually update. Payments are tied to continuance relevance in the graph, not one-off milestone reports. The question of ‘should we fund again’, gets answered in the process.

What’s still open

If governance is going to learn, it needs all three loops: who caused value, what was delivered vs promised, whether funding changes next time. Deep funding is the most interesting attempt at attribution I’ve seen — but it only works where dependencies are legible (software graphs). For everything else: events, research, community work — we’re still mostly guessing.