Methodology

DeFiPunk'd is a registry. Most slice grades are still gray — only assessments with a published audit trail show a color. Where a color appears, you can trace it to either a deterministic heuristic on raw DeFiLlama signals or a DEFI@home quorum of independent LLM runs.

Where the data comes from

Every protocol is seeded from DeFiLlama via pnpm sync, which writes the full list into a committed JSON snapshot. Human curators can override individual fields by dropping a JSON file into data/overlays/ and opening a PR.

Every field displays a provenance tag so you always know where the value came from:

[defillama] — the raw DeFiLlama value.
[curated] — a human-authored overlay in data/overlays/.
[defillama-parent] — a child protocol inheriting a field (github, twitter, website) from its parent because DeFiLlama only records the value at the family level.
[:] — the DeFiPunk'd glyph; sourced from the DEFI@home quorum (text tag defi@home in the underlying data).

The glyph only appears where there is evidence behind it; an em-dash means unsourced.

The 5-slice risk pizza

DeFiPunk'd uses the five assessment dimensions from DeFiScan v2: Control, Ability to exit, Autonomy, Open Access, and Verifiability. A gray slice means nothing has produced a color for that dimension yet.

Control
Who holds admin privileges, how contracts can be upgraded, and how quickly. Combines the old chain-ownership and upgradeability questions — a single assessment per protocol rather than per chain, since a one-chain-red / mainnet-green split is more misleading than useful.
Ability to exit
Whether users can exit on their own terms if the protocol team disappears or acts adversarially.
Autonomy
Whether a failure outside this protocol's own contracts (oracles, off-chain reporters, bridges, keepers, governance-mutable dependencies) can cause theft, loss of unclaimed yield, or materially change expected performance. Collateral counterparty risk lives here too.
Open Access
Whether the protocol is reachable by anyone without an allowlist, KYC, geofence, or off-chain operator standing between a user and the contracts. Permissioned markets, whitelisted relayers, and frontends that gate withdrawals all live here.
Verifiability
Whether anyone outside the team can independently verify what the code does: open-source status, audit quality and scope, bytecode-to-source correspondence at the deployed address, and whether post-audit changes were themselves reviewed.

How slices are graded today

A slice gets a color from one of three sources: a deterministic heuristic on DeFiLlama signals, the CEX special case, or a DEFI@home quorum. Heuristics run on every protocol on every build; DEFI@home grades land per (slug, slice) as contributors and the autorun bot submit them.

Heuristic-graded slices

Verifiability — coarse first-pass on raw DeFiLlama signals:

green — protocol has a GitHub repo and at least one audit.
orange — one but not the other.
red — neither.

An audit count is a famously weak signal in isolation — auditor quality, report scope, and whether post-audit changes were reviewed matter far more than the integer. A thorough Verifiability assessment via DEFI@home overrides the heuristic when ≥3 model runs agree.

Autonomy — category + opportunistic forkedFrom:

red — protocol category is Liquid Staking, RWA Lending, or one of the bridge categories (Bridge, Canonical Bridge, Cross Chain Bridge, Bridge Aggregator). These categories carry unavoidable external-protocol, validator, or counterparty risk by construction.
orange — DeFiLlama records a non-empty forkedFrom lineage. DeFiLlama's fork-lineage data is largely paywalled, so this signal currently covers only a handful of protocols.
gray — neither signal fires.

Slices with no heuristic

Control, Ability to exit, and Open Access have no automated heuristic. They render gray until a DEFI@home quorum lands a real grade. Open Access in particular is not a signal DeFiLlama carries in a usable form — it depends on reading the project's own docs and frontend, plus on-chain checks for whitelist-gated entry points.

CEX special case

Protocols whose DeFiLlama category is exactly CEX are graded red across all five slices automatically. The rationale: a centralized exchange is custodial off-chain infrastructure — the failure modes are the entire surface, and grading them per-slice would imply a level of separation that doesn't exist. The "DeFi" tab on the landing page filters CEX out by default.

Tier badges (bronze / silver / gold)

A medal next to a protocol's name signals how thoroughly the slice grades have been reviewed. Tier is computed from the assessments that have reached quorum, not from the grades themselves:

Bronze — at least one slice has reached quorum (≥3 different models agreeing).
Silver — all five slices have reached quorum.
Gold — a human committee has signed off on the assessments.
No medal — fewer than three models have agreed on any slice yet.

Tier is a review-depth signal, not a safety signal: a silver-tier protocol can have five red slices. Tier and grade are independent axes.

Family aggregation

Protocols deployed as a family (Uniswap v2/v3/v4, Aave v2/v3, Morpho Blue/MetaMorpho, …) appear as a single expandable row on the landing table. The family summary takes the grade of the highest-TVL child for every slice — so a small outlier deployment doesn't drag a well-graded family down — and the maximum tier badge across children. Expanding the row reveals each child's individual pizza and tier.

DEFI@home — distributed assessment

DeFiPunk'd does not run crawlers and does not hand-curate every protocol. The slice grades that aren't produced by the heuristics above are filled in by DEFI@home: a distributed, BOINC-style process where independent contributors run a pinned prompt through the LLM of their choice (Claude, ChatGPT, Gemini, …) and submit the JSON output as a pull request.

Each protocol page exposes an Audit a dimension yourself · DEFI@home section under the Risk analysis cards, with a Copy prompt button per slice plus an Audit all row that combines the five risk dimensions into one prompt. Submit run ↗ opens GitHub's new-file interface pre-pointed at data/submissions/<slug>/<slice>/ for one slice or data/submissions/<slug>/all/ for the combined JSON array. The prompt has the snapshot timestamp, prompt version, chains, GitHub repos, and audit links pinned in, so re-runs remain verifiable against a fixed evidence set.

Determinism comes from consensus across independent re-runs, not from any single LLM output. A quorum bot merges an assessment into data/assessments/ once at least 3 contributors using different models agree on grade and overlapping evidence; disagreements are surfaced on a per-slug aggregation issue. A scheduled GitHub Action also runs the prompts via the Anthropic API as a "third voice" so coverage doesn't depend on volunteer traffic alone. See /contribute for the full flow.

Curated metadata from DEFI@home

The same DEFI@home submissions that produce slice grades also carry a protocol_metadata block. When a slice reaches quorum, fields from the highest-weight submission propagate to the protocol detail page with the [:] glyph:

Upgradeability label — Immutable, Upgradeable, Mixed, or Unknown.
Bug bounty URL.
Governance forum URL.
Docs URL.
Security contact (email or address).
Voting token (symbol, chain, contract address).
Deployed-contracts documentation link.
Hallmarks — chronological protocol milestones rendered as a timeline.

These fields are not graded — they're factual claims with citations in the underlying submission, and they're inferred from the assessment work the contributor already did rather than re-asked separately.

Reconcile and the master file

After quorum lands the per-slice assessments, a scheduled reconciler runs Claude Sonnet over the merged assessments plus the raw submissions and writes a synthesized verdict to data/master/<slug>.json. The master file is what feeds the protocol detail page's narrative — findings, steel-man arguments, verdict, and noted dissent. It does not re-grade; it consolidates what the quorum already decided into prose a reader can scan.

Stages

The Stage column is reserved for a future adoption of DeFiScan v2's stage framework. Today every protocol shows an em-dash there. The tier badge is the current "is this protocol reviewed?" signal — it answers a different question than a stage (review depth vs. decentralization milestone), so the two will coexist when stages land.

Inactive and delisted protocols

DeFiPunk'd mirrors DeFiLlama. Protocols flagged is_dead upstream show an "(inactive)" label on the landing table and are hidden by default behind a "Show inactive" toggle. If DeFiLlama removes a protocol entirely, DeFiPunk'd marks it delisted_at and serves a stub page explaining the removal for 14 days; after the grace window the protocol is dropped from the registry.

Corrections

Spotted a wrong field? Open an issue or a PR on github.com/guil-lambert/defipunkd.