← Yasmeen Roumie

Red String: a graph that remembers why

Every decision an agent makes should come with a thread you can pull.

That idea became Red String, my project for Graph Hacks, the WeMakeDevs x FalkorDB hackathon.

At a glance

What I built, and why a graph

Red String is pipeline software for small creative agencies that win clients by doing the work first. Its agents screen local businesses, research and audit each one, and pitch with spec posts made for that business.

The hard part of that job isn't writing a post. It's knowing who will see it. If two of your clients reach the same parents in the same neighborhood, their content should never look alike. Businesses target audiences, audiences overlap, and posts use techniques that are rare or common. A graph holds that naturally, and the answer often sits two or three hops away.

The second reason is memory. Every agent write also records a Decision node: who decided, and based on what. So any answer in the app can be traced back to its sources. I call those traces threads, which is where the name comes from.

How the pieces work

FalkorDB is the core. Each business gets its own private graph. A shared agency graph holds only what's needed to compare clients, including fingerprints: the list of techniques a draft uses, with no copy, so client work stays private.

Three private client graphs send only fingerprints, lists of technique IDs, into one shared agency graph where Double Take compares them.
Each client's work stays in its own graph. Only fingerprints cross into the shared one.

Seven named Cypher queries do the work. They project a draft's fingerprint, find each business's signature techniques, check new leads against signed clients through overlapping audiences, check drafts for lookalikes, find open territory, trace decisions to their sources, and find drafts left stale when a goal changes.

Agents never write raw Cypher. Eight agents and one human board share the work, and each agent can only call the tools its job needs. The tools are also served over MCP.

The lookalike check, Double Take, is the part I care about most. It scores a draft by how much its rare techniques overlap with another business's, times how much their audiences overlap. At 0.35 the draft is blocked, and the agents revise it using techniques no nearby business has claimed.

Tumble Town and Wet Paint reach overlapping parent audiences. A new Tumble Town draft and a past Wet Paint post both use Stop motion and Paint smear wipe, so the draft scores 0.968 and is blocked.
The pattern Double Take looks for: two businesses that reach the same people, using the same rare moves.

You can see it three ways: the Studio, the agency's own dashboard; Analysis, which shows the math and the Cypher behind every check; and FalkorDB Browser, for the raw graph.

The 14 businesses are invented. The 251 reference videos and the research findings are real, and the README says exactly which is which.

How I built it with AI agents

I didn't write the code for Red String. My job was to explain the problem, say why it mattered, and keep pushing until the product matched what I had in my head.

Most of my prompts were spoken. I use Wispr Flow to dictate, so a prompt was often a few minutes of thinking out loud about who this is for and what felt wrong. Then I let the agents unpack it and work out what to do.

I talk through the problem, agents build it, and I judge each pull request for taste and clarity, merging it or sending it back with feedback.
My part was the two ends of the loop: the problem going in, and the judgment coming out.

Claude Code built the first working version. After that, Devin did most of the feature and interface work through pull requests, and I used Claude to review each one. For the look, I used Claude Design to mock up a redesign and reacted to it. Some of my feedback was taste, like a heading font that felt too aggressive or colors that felt cold. More of it was about whether the product made sense. Can you tell what needs a decision? Can you see why a draft was blocked? I kept pulling the work back from how it looked to what it did.

What surprised me was how much went wrong while the tests stayed green.

Partway through, I had Claude audit the codebase. All 60 tests passed, yet the audit reproduced 21 problems against a running FalkorDB. A few of them:

Claude filed these as GitHub issues in priority order. Devin fixed them, and Claude checked each fix before I merged it.

The fixes went wrong too. One tool's schema would likely have broken the first step of Claude mode, and the next fix gave it the wrong shape. Every test passed both times, because the offline agents never touch those schemas. That led to a scripted end-to-end test of Claude mode, and the suite grew from 60 tests to 116.

Then Devin ran the whole demo live in Claude mode against the real API. It finished, and still found a bug: one rewritten draft lost its link to the draft it replaced, because the model skipped an optional field. The fix was to stop asking the model for things the pipeline already knows.

Agents are fast at writing code and good at checking each other. Deciding what matters, what to merge, and whether the product is clear still came down to me.

What I would do next

Links