Crypto intelligence that tells you when, how and why, for humans and agents.

What is Decodify?

Decodify is a crypto-intelligence protocol that captures all types of events for the top crypto projects. It combines the best qualities of AI with the complexity of the human mind and social intelligence. It provides results in the form of actionable insights and customizable scores, serving them to humans through a UI and to agents through an API.

Most traders juggle five disconnected tools: CoinMarketCap for price, Nansen for on-chain, Kaito for social, TradingView for charts, and Twitter for catalysts. None of them talk to each other, none validate what they surface, and none capture the 2 a.m. partnership tweet before the market reacts. Decodify replaces that whole workflow with one accountable record, and one score you control.

Two things make it fundamentally different from every dashboard that came before it:

Crypto is drowning in price data and starving for meaning.

There is infinite data on what a price did, and almost none on why: verified, complete, and usable. The participants who understand why a token moved, and can recognise the setup forming again, hold a durable edge. Everyone else is working with four broken inputs:

• The “why” is unstructured and untrustworthy. What moves a token (listings, unlocks, governance, whale flows) is scattered across explorers, forums, exchanges, dev repos and social. Un-timestamped, unverified, impossible to query.
• Every tool sees one slice. Sentiment feeds scrape the volume of chatter, not validated cause. On-chain tools tell you a whale bought, never why. Nobody connects the dimensions into a whole.
• Scores are black boxes. A “78/100” you can’t decompose is useless to a serious trader, and unusable to a machine that needs auditable reasoning.
• And now, agents can’t be served at all. Thousands of autonomous trading agents are spinning up alongside human traders and funds. Both need structured, explainable, real-time intelligence they can act on, and nothing is built for a non-human consumer.

Two engines. One record. A score you can compare.

Decodify runs two engines side by side: an automated quant stack that measures what machines can, and a community + AI curation pipeline that captures and verifies what only humans know first.

Together they produce something that hasn’t existed before, and it’s valuable at every level:

1. Captured A complete, timestamped record of what’s happening to a project, across every dimension. The feed nobody else has.
2. Validated Confirmed true and impact-scored by AI and a stake-backed, reputation-gated crowd. Structured intelligence that can’t be faked or farmed.
3. Scored Every event rolls up into its pillar, every pillar into the project score. Nothing missed, everything weighed, and comparable across the whole market to spot what’s mispriced.
4. Shaped Served to humans (UI) and agents (API), from raw events to abstracted scores, run at Baseline or reweighted to your own thesis.

One workspace, the whole workflow

The sidebar mirrors the research workflow: Explore what exists, get Intelligence on what’s happening now, contribute and earn in the Lab, and manage your stake, referrals and positions under Personal.

Explore: what exists

Intelligence: what’s happening now

Lab: contribute and earn

The Lab runs a single pipeline, in order: Declare → Validate → Assess.

Personal: your stake & rewards

Two scores. Zero black boxes.

Each token is scored across a set of transparent pillars. Every pillar is decomposable: click “explore” and you see every metric, its raw value, and how it was computed. Financial and on-chain metrics are FDV-normalised, so the same raw number scores differently depending on a token’s valuation tier.

Some pillars score from live data today; others render the full framework while their data pipelines are wired up (see the roadmap). The “Live / Wiring up” status above reflects current state, in the app.

The pillars roll up into a composite score. A Baseline score uses neutral weights everyone shares; your Custom score uses the weights you set. The same data, your interpretation.

The intelligence layer no algorithm can replicate

The Lab is where humans add what pipelines can’t. Every community declaration flows through one accountable pipeline before it can affect a token’s score:

1. Declare A contributor submits a utility, product, category fit, or catalyst event, with a proof link.
2. AI pre-check An automated gate screens it for coherence, plausible dates and validity. Clear spam/garbage is rejected on the spot; everything else proceeds.
3. Validate A jury of trusted curators approves or rejects it. Approved → it moves to assessment; rejected → it’s dropped, and the declarer’s trust takes a hit.
4. Assess The community scores the validated declaration: validity, impact and direction. Consensus stays hidden until enough votes land, then settles.
5. Consensus The settled result flows into the token’s score, tags, narrative pulse and activity feed, and assessors who beat the crowd earn a retrospective reward.

Every data point is accountable: who declared it, when, who validated and assessed it, and what the consensus was. Unlike Twitter alpha or Discord tips, there’s reputation and credits behind every claim, and a public accuracy record for every contributor. Each stage costs credits (capacity) and is gated/multiplied by trust (track record); both are explained below.

Nothing settles on raw headcount; it settles on trust. A step locks once the combined trust of the people who weighed in is high enough (and a minimum number of distinct curators and a short open window have passed, so no single person with several wallets can decide alone):

Each voice is weighted by trust, with a cap so no single heavyweight can dominate the outcome, so results reflect the proven community, not whoever shows up loudest or holds the most.

Trust: the single gate and multiplier

Trust is your reliability as a curator: a single score that grows as you’re proven right. It does two jobs: it unlocks what you can do, and it multiplies what you earn. Everyone starts low and earns their way up, so standing reflects results, not how early you arrived or how much you hold.

Trust moves slowly, by track record: you gain it from accurate assessments, well-judged validations, and declarations that hold up, and lose it from sloppy or wrong calls. Proven curators carry far more weight than newcomers, so the people who’ve consistently been right shape outcomes the most, and it can’t be bought, only earned.

Credits: capacity to act

Credits are the throughput you spend on Lab actions, separate from trust. They’re minted daily and reset every day at 00:00 UTC with no rollover, so capacity can’t be hoarded. Verification (Twitter + Telegram) is required to mint any credits: the Sybil gate on participation.

• Free daily grant for verified wallets, so you can try the Lab before staking.
• Staking mints more: every 100 $DECO staked = 1 extra credit/day (linear, uncapped).
• Costs: declaring (spent at the Validate step, pass or fail), validating, and assessing each consume credits per action.

That’s all staking does: mint capacity. Whether you can do an activity, and how much you earn from it, is governed by trust, not stake.

Reputation, in the open

The leaderboard ranks curators by points and trust, with a live view of each contributor’s declarations, validations and assessments and their per-event reward attribution. Standing is earned through accurate, well-validated work over time; it can’t be bought. Your declaration history shows each event’s lifecycle stage: Validation → Assessment → Finalized (or Rejected).

How contributors earn

Every action awards a permanent instant floor the moment you act; the protocol then adds retrospective bonuses once a signal settles: bonuses only ever add, never subtract. Every reward is scaled by your trust. The figures below read live from the protocol’s economy settings (pre-TGE governed by the team; post-TGE by stakers).

Retrospective rewards scale with how close your call lands to the community consensus: the closer, the more, falling off sharply with distance. Declarer rewards use your trust at the moment you declared, not when the event later concludes.

The reward pools

Rewards are funded from two recurring pools, each quoted as a percentage of supply per four weeks:

By default every activity competes for the whole points pool in proportion to the points it earned. The pool can optionally be split so each activity funds its own rewards: a governance option, off by default.

Epochs & settlement

Points accrue in rolling 7-day epochs. Points in the open epoch are this-epoch (at-risk); when the epoch settles they become claimable (banked). Unstaking during an epoch forfeits that epoch’s at-risk points (the anti-unstake deterrent) while claimable points and baseline yield are always kept.

Referrals

Invite contributors and earn a two-tier override on the points they generate: 15% from your direct recruits and 5% from their recruits, drawn from the pools (not taken from the recruit). Each referrer’s total override is capped at 30% of their own epoch points, so referrals reward active contributors, not passive recruiters.

$DECO: the coordination layer

$DECO aligns the people who produce intelligence with the people who consume it. Its core utilities:

Staking

Staking 100 $DECO mints one credit per day (linear, uncapped). That’s the one thing staking does: set your daily capacity to contribute. It does not buy trust, rank, or rewards; those come only from accurate work. Pre-TGE, staking runs on a testnet faucet so you can build a track record before the token exists; post-TGE it stakes real $DECO and also accrues the baseline pool’s passive yield.

Airdrop & TGE

The community allocation (1% of supply) goes to contributors. Pre-TGE, every point you earn accrues as your share of that allocation: your points ÷ all points × 1% of supply. At TGE the snapshot freezes and the airdrop vests linearly over 90 days. Build trust and points now; the snapshot rewards the track record you’ve already established.

$DECO launches on Virtuals

$DECO launches via the Virtuals Protocol launchpad: the home of tokenised, autonomous agents and the ecosystem best aligned with Decodify’s mission. Virtuals gives $DECO a fair, liquid launch and native rails to the agent economy.

It also positions Decodify as intelligence infrastructure for agents: the same structured, decomposable, machine-readable intelligence humans read on the dashboard is exactly what autonomous trading and research agents need. Planned ACP (Agent Commerce Protocol) integration lets agents consume Decodify’s signals programmatically: Decodify becomes a data provider to the on-chain agent economy, not just a human dashboard.

Using Decodify

1. Explore the market. Open Markets, sort by score, and click any token to open its Project page. Everything is free to view.
2. Make the score yours. On any token, open “Create your score,” set your pillar weights, and watch the Custom score diverge from the Baseline: that gap is your thesis, quantified.
3. Read the now. Check Pulse for regime, convergence and valuation extremes; ask the AI assistant a question in plain English.
4. Contribute in the Lab. Connect a wallet, declare a catalyst or assess pending signals, and start building a public accuracy record.
5. Stake to scale. Stake $DECO to mint credits, build trust through good work, and turn accurate, early intelligence into rewards.

Using the Lab, step by step

The conceptual model is in The Lab; this is the practical walkthrough: exactly what happens when you contribute.

1. Connect & verify. Connect a wallet and verify (Twitter + Telegram). Verification is the anti-Sybil gate: it’s what lets your wallet mint credits (a small free daily grant to start; stake $DECO to mint more). Credits reset daily and don’t roll over.
2. Declare. Pick a token and submit a utility, product, category, or catalyst with a clear description and a source link. Press Validate: this runs the AI pre-check and spends one declare credit whether it passes or fails (the credit pays for the check). On a pass, confirm with Declare; you earn an instant floor (× your trust) and the declaration enters community validation. Incomplete or wrong info is rejected: no reward, and it never reaches assessment.
3. Validate others (trust ≥ 0.5). On the Validate tab, approve or reject pending declarations. Each vote spends a credit and pays an instant floor; if you’re on the winning side you also earn a retrospective reward and trust. You can’t validate your own.
4. Assess (open to all). On the Assess tab, score validated declarations: validity, impact, direction. Each assessment spends a small credit and pays an instant floor; the larger reward lands later, at settlement, if you beat the crowd. You can’t assess your own.
5. Build trust & climb. Accurate work raises your trust over time, which unlocks Declare (≥ 0.2) then Validate (≥ 0.5) and multiplies every reward. Track each of your declarations through its lifecycle (Validation → Assessment → Finalized) on your history and the leaderboard.

Access tiers Planned

This is the planned post-TGE access model. Today the whole platform is open to explore. Token-gating and the tiers below activate toward TGE as the gated capabilities ship.

Tier definitions evolve toward TGE; capabilities marked elsewhere as “coming soon” unlock as they ship.

Where Decodify is going

Frequently asked