Four Days to Build a Meme Coin Tracing Agent: Sniff Uses a Graph Database to Expose the "Clean Wallet"

A Meme Coin Just Graduated, and You Only Have Seconds

Late at night, a pump.fun token you've never heard of just "graduated"—filled its bonding curve and moved into a real trading pool. The candlesticks are climbing, the chat window is all rocket emojis, and your thumb hovers over the buy button.

The real question isn't "will it pump?"—nobody can honestly answer that. It's: who's behind this? Who created it, and how did their last batch of creations turn out?

You click open the creator's address. It's brand new, only ever launched this one coin, looks perfectly clean. But it almost never is that simple. By the time you figure it out, the moment has passed.

This is exactly the problem the QuantBase team set out to solve at the WeMakeDevs × FalkorDB Graph Hacks hackathon. According to their indexer data, pump.fun sees 24,606 new tokens in a single day—roughly 25,000 per day, and only a small fraction of every hundred manage to graduate. And launch wallets are usually created for just this one issuance; the real clues live one or two hops away: who sent this wallet the few cents of SOL needed to launch? Who else did that payer fund? And what did those wallets launch?

The Problem: The Truth Is Two Hops Away

In Postgres, every one of those questions becomes a pile of self-join queries that take minutes to run and still miss things. Path queries are exactly what graph databases excel at. The team gave themselves four days, loaded months of historical data into FalkorDB, and built an agent on top of it called Sniff.

According to the authors, the data snapshot holds 632,339 tokens, 424,007 wallets, and about 1.5 million relationships. FalkorDB's bulk loader completed the import in 30 seconds, and the graph occupies just 521MB of memory.

Day One: Snapshot, Graph Structure, and the "Hub" Surprise

After the first version of the queries ran, the team asked what seemed like a clever question: how are two random tokens connected? The graph's answer: within four hops, everything is connected to everything. Correct, but useless.

The reason is exchanges. When creators withdraw SOL from an exchange, the exchange's hot wallet becomes their "funder." One such wallet funded 33,747 known wallets. Pass through it, and every stranger is your neighbor.

The team labeled addresses that fund more than 200 other wallets as hubs—89 in total. They tagged hubs separately, cut their inbound edges, and set a hard rule: no query may traverse a hub. Paths that reach a hub stop and explain: "This comes from an exchange-like wallet and can't tell you who's behind it."

With hubs excluded, the algo.WCC algorithm found 6,556 "rings"—clusters of wallets and tokens connected by funding and creation relationships. The team cross-validated against clusters their collector had found another way: of 3,900 multi-creator clusters, 3,824 fell entirely within a single ring. The graph method and the old method corroborated each other.

Weakly Connected Components (WCC) is a classic graph algorithm for finding all sets of nodes in a graph that can reach each other through any edge (ignoring direction). In Sniff's case, algo.WCC treats wallets and tokens as nodes and funding/creation relationships as edges, partitioning the wallets and tokens linked by the same funding sources or the same creator into individual "rings" (components). Of the 3,900 multi-creator clusters the team independently obtained with the old method, 3,824 fell entirely within a single WCC. This cross-validation is strong evidence of the graph clustering's accuracy—if two independent methods produce highly consistent groupings, the result is more trustworthy.

Day Two: The Agent That Must "Show Receipts"

Letting an AI model talk about wallets and money is precisely where it must never make things up. So Sniff was built around one rule: every sentence must prove itself.

Claude gets nine tools: token lookup, funding chain, sibling creators, shared early buyers, shared social accounts, rings, shortest connection, top traders, and search. Each tool is a fixed, read-only Cypher query; the model only decides which tools to call (up to eight times) and writes the answer—it never writes Cypher itself.

Every tool result carries evidence IDs (E1, E2, ...) that point precisely to the underlying nodes and edges. Every sentence in the answer must end with the corresponding ID. A citation checker then reviews the answer before anyone sees it: IDs never returned by a tool are removed; IDs from the wrong type of tool are removed; sentences without a valid ID are deleted wholesale—a short answer beats an unsupported one.

That evening they looked up a token called METHU. Its creator had launched only one coin, which alone makes them look like a novice. But one hop back, the story is completely different: the wallet that sent the METHU creator 0.009 SOL also funded 71 brand-new wallets, each launching exactly one coin, and none of the 72 coins graduated.

The creator looks clean; the payer is where the story is—and you only see it once the data is shaped into the question.

Cypher is a declarative query language pioneered by Neo4j and now widely adopted by graph databases including FalkorDB. It describes graph structures with pattern-matching syntax resembling ASCII art, e.g. (w:Wallet)-[:FUNDED]->(t:Token) means "the wallet funded the token"; to query, you just write the pattern you want to match, and the database engine handles efficient traversal. Sniff's key design: all Cypher queries are pre-written by developers and wrapped into nine read-only tools; the LLM only decides "which tool to call and with what parameters" and never generates Cypher directly. This fundamentally eliminates the possibility of the model writing incorrect or dangerous queries (such as full-graph scans or write operations), and it lets each tool's output carry stable evidence IDs.

Day Three: Making the Evidence Light Up on the Map

Citations are only useful if they're verifiable. On day three the team built what users actually see: paste a token, watch Sniff's steps stream in, and see a graph map beside the answer. Click E4 in the answer and the map dims, keeping only the wallets and tokens that sentence relies on.

Exchange-like wallets appear as dashed boxes, so you can see where a path stops and why. The token card on the left doesn't need AI at all—it reads the same graph directly and works on mobile. The same nine tools are exposed via MCP, so any agent can call them: claude mcp add --transport http sniff https://sniff.quantbase.live/mcp.

Day Four: Memory and the "Company Brain"

On the final day, the team added two more graphs to the same FalkorDB instance.

The memory graph keeps Sniff from losing its memory once an answer is done. Each investigation leaves a small trail: the session asked, the question found evidence, the evidence concerns a token or wallet. Sessions are random 32-character IDs, never linked to a person, and a privacy gate checks every write. The practical benefit: before calling a tool, Sniff first checks whether the same call was already made in this session, and if so reuses the answer instead of querying the big graph again. A follow-up like "and who funded that wallet?" starts from what's already known.

Memory is also how agents collaborate. memory_recall and memory_note sit on the same MCP endpoint as the investigation tools. Another agent (say, QuantBase's trading agent) can ask "what has anyone found about this coin?" and Sniff returns every session's evidence about that coin, anonymized and timestamped. The two agents never chat—they coordinate through the graph, and every note is attributed.

The company brain graph holds QuantBase's own knowledge, curated from public sources: repo docs, public pages on quantbase.live, published findings. A build script slices each source into sections, extracts the decisions, findings, metrics, products, features, and policies in them, then links them with MENTIONS, SUPPORTS, CONTRADICTS, PART_OF, and DECIDED_ON. A query like "How does QuantBase handle paper trading versus live trading?" triggers real graph retrieval: find named entities, walk outward up to two hops of typed edges, locate the specific sections that mention them, and fall back to a full-text index when a word doesn't match an entity. Answers cite those sections as [B#]—the same contract as day two's E IDs: no citation, no assertion.

The privacy gate runs before anything is loaded, looking for emails, API keys, AWS IDs, private keys, mnemonics, and wallet key arrays; a single match fails the entire build, and it never prints what it found.

The bonding curve is the core mechanism of meme coin launchpads like pump.fun: the token price rises automatically with supply along a preset mathematical curve, cheap for early buyers and increasingly expensive as buying grows. When the curve fills up (usually upon reaching some market-cap threshold), the token "graduates"—liquidity migrates to a real trading pool on a decentralized exchange like Raydium, and price is set freely by the market. Before graduation, the token trades only inside the platform; after, anyone can buy and sell on the open market, and volatility usually spikes sharply. Understanding this is key: "graduation" is not a quality certification, merely a liquidity migration event, and only a tiny fraction of the roughly 25,000 new tokens each day ever get that far.

The Twist: It Explains History, Not the Future

The team does trading research on the same data, so they had to ask an uncomfortable question: can these graph signals predict which tokens perform well after graduation?

They built features using only information known at the moment each token graduated, tested on 23,408 graduated tokens, trained on older data and tested on the most recent third. Taken alone, the signals are meaningful: tokens whose social account had already been used by another creator had an 18 percentage points lower probability of still being alive an hour later.

But once you add any information anyone can see in a token's first few minutes of trading, the graph signals show no measurable gain—prediction accuracy changes by within ±0.01. What the graph knows is already priced in.

The team could have buried this result and shipped a "risk score" that people would trust. But this is a product people put next to their own money, and confidently wrong answers about money cause real harm. So Sniff never says "safe" or "scam," and never says buy or sell. It tells you who's behind a token and how their other tokens turned out, with receipts, and every answer ends with the same words: history, not prediction. A payer who funded 72 launches, none of which graduated, won't tell you the future—but it does tell you what you're looking at.

The Bigger Product: Sniff Comes to QuantBase

Sniff started as a hackathon project and by the end of the week had become an agent inside QuantBase. Users describe a strategy in plain language, and Sniff turns it into rules, testing it on real history before any real money is involved. The first thing you meet is paper mode—"invisibility mode for money": chat and test any idea with virtual currency, where nothing can touch a wallet, and every simulated result is labeled as simulated.

The second thing is speed. When a token graduates, a human has to notice, open, check, then click—a website shows a typical illustrative minute: about 55 seconds. Sniff is on the same clock, using numbers measured on its own system: about 1 second to hear the graduation event on-chain (based on 1,371 graduations), and a median of 76 milliseconds to sign and send the order (based on 92 sends), for about 1.08 seconds total. Speed only helps good rules and can't fix bad ones—most meme coins still lose money, and the website says so.

What FalkorDB Made Possible

The team used FalkorDB 6.0.2, with a few highlights: the bulk loader imported 1.09 million nodes and 1.5 million edges in 30 seconds, making it cheap to rebuild the graph as rules changed frequently on day one; range indexes on tokens, wallets, hubs, account names, and ring keys plus a full-text index; algo.WCC ran the full graph to find rings in 2.9 seconds; algo.SPpaths answered "how are these two connected" while filtering hubs; the read-only query GRAPH.RO_QUERY with a per-query timeout means a curious agent can't write or run forever; and MCP makes the same tools usable from Claude, their own agents, or yours.

They also listed several places where the docs and the running server disagree—for example, on 6.0.2 the procedure names are algo.WCC, algo.BFS, algo.pageRank, algo.labelPropagation, and algo.SPpaths, and CALL dbms.procedures() is the source of truth; the documented full-text index syntax was rejected, and CREATE FULLTEXT INDEX FOR (c:Coin) ON (c.name, c.symbol) was what worked; WITH projections need AS aliases; timeouts can't exceed the server's TIMEOUT_MAX; sum() returns a float; and the bulk loader's default escape character is a backslash—while some meme coin names are literally a backslash, so you need -x none.

MCP (Model Context Protocol) is an open protocol introduced by Anthropic to let AI agents discover and call external tools and data sources in a unified way. It defines standard formats for tool descriptions, call requests, and responses—like a "USB-C port for the AI world." Sniff exposes all nine investigation tools and its memory tools through an MCP endpoint, meaning any MCP-capable client (Claude Desktop, custom agents, etc.) can connect with a single command, with no per-agent integration code. This turns Sniff from a closed app into composable infrastructure, and it's also the technical prerequisite for multi-agent collaboration through the memory graph.

From Pixel Dog to Product

The day before the event kicked off, sniff.quantbase.live was a coming-soon page with nothing but a 3.2-second looping pixel dog sniffing a coin. Four days later, that dog stands behind a graph of 632,339 launches, an agent that can't state facts without evidence, a map that lights up the evidence, and a test they ran on themselves—one that told them what not to promise. The dog has a job now too: it's an agent inside QuantBase.

To try it yourself, visit sniff.quantbase.live to look up the METHU case, or connect your own agent via MCP. The code is open source at github.com/avasis-ai/quant-agent. This article is not financial advice.