How Infrasity Helped MemClaw Grow Its GitHub Presence by 1,512% in Six Weeks

A step-by-step look at the distribution system, the audits, the demo repos, the Reddit engine, and the listing pipeline that turned a stalled open-source repo into a compounding growth curve. Every process in this case study is documented so you can run it yourself.

Here's results at a glance:

Total paid spend across the engagement: $0. Every star on the curve below came from an organic distribution.

About MemClaw

MemClaw is an open-source persistent memory system for multi-AI agent fleets, built by Caura AI. Most agent memory tools were designed for one agent talking to one user in one session. MemClaw was built fleet-first: dozens of agents sharing knowledge with enforced access boundaries, write-time contradiction detection, trust tiers, and audit trails.

Strong product, real architectural differentiation, and a problem a 2026 arXiv survey explicitly calls open (multi-agent memory governance). One issue: nobody could find it.

The challenge: a strong repo, invisible on every surface that matters

When MemClaw engaged Infrasity in May 2026, the main repo had around 17 stars from internal teams and had stalled at 17, adding only one or two per week. The category it launched into looked like this:

Our week-one audits (the full method is in the next section) found MemClaw invisible on all four surfaces where developers discover tools in 2026:

• AI answers. Across five high-intent buying prompts on ChatGPT, Claude, Gemini, and Perplexity, MemClaw was not ranked in a single response. Zero citations detected. Mem0, Zep, Letta, and Supermemory occupied every slot on every model.

From the baseline AI-visibility audit: MemClaw was "not ranked" or had "minimal visibility" on every tracked prompt, while five competitors filled all positions.

• Google: memclaw.net had 0 ranking keywords in the US and ~0 monthly organic traffic, despite 18 published blog posts. Mem0 ranked for 904 keywords (~600 monthly organic visits); Zep for 485 (~240). The root cause: every post was titled like product marketing copy ("We Married Claude and ChatGPT. MemClaw Was the Bestman."), so Google had no query to map it to.
• Reddit: In the five largest memory-benchmark threads on the platform ("I Benchmarked Memory Systems: Letta vs Mem0 vs Zep" and similar), four tools were ranked and compared in each thread. MemClaw appeared in none.
• Third-party validation: Not one awesome list, MCP directory, or discovery platform listed the repo.

One genuinely encouraging audit finding: the "AI agent memory" category was growing +191% year over year, and no competitor had locked up the multi-agent angle. The space was still winnable if MemClaw showed up. As we put it in our open source marketing strategy, great code dies in the dark. The fix is not a big, loud launch; it is a system that shows up repeatedly, where developers and LLMs decide what to use.

The playbook: six moves, run as one system

Below is each move with the exact process behind it. If you run growth for an open-source tool, you can follow these steps as written.

Step 1: Baseline everything before touching anything (Week 1)

Initially, we did not focus on producing content, but on producing a measurement. Here is exactly what we built, in order:

1. Defined 5 buying prompts: Not brand terms, the questions a developer actually types when choosing a memory layer: "best open source memory layer for AI agent fleets", "best Mem0 alternatives for multi-agent systems", "open source alternatives to Letta for persistent agent memory", "best self-hosted governed memory systems for AI agents", and "best shared memory for multi-agent AI systems with audit trails".
2. Ran each prompt across 4 LLMs: ChatGPT, Claude, Gemini, and Perplexity. For every response we logged which products were mentioned, in what order, and with what citation presence (high/medium/low/none), a 5×4 visibility matrix that became the scoreboard for the whole engagement.
3. Traced every citation to its source: We opened each source the LLMs cited and logged the URL. Most were Reddit threads. This step produced the single most valuable asset of the engagement: a map of 78 specific Reddit threads that ChatGPT, Perplexity, and Google AI cite when answering the five prompts (64 cited by ChatGPT, the rest by Perplexity and Google AI). These threads became the target list for Step 4.
4. Audited Reddit presence directly: Which tools were named in the big benchmark and comparison threads, and how often? MemClaw: zero mentions.
5. Audited the competitive set on GitHub: Stars, forks, latest activity, and maintenance status for Supermemory, Letta, Cognee, Zep, Graphlit, and Memori, so we knew which fights were winnable (topic pages, comparison queries) and which weren't (raw star count, yet).
6. Audited the domain against competitors: Ranking keywords, organic traffic, blog strategy, and content gaps, versus mem0.ai, getzep.com, and letta.com.

From the week-one domain audit: 0 ranking keywords and ~0 organic traffic against Mem0's 904 keywords, with the root cause and the +191% category-growth signal that made the space worth contesting.

Everything went into one shared tracking spreadsheet with five tabs: Engagements, Distribution Tracking, OPs, Prompts to Track, and LLM Threads, which both teams worked from for the rest of the engagement.

Here's why this is so important: a growth number without a defensible baseline is a marketing claim; a growth number with one is attribution. Every figure in this case study traces back to that week-one sheet.

Live distribution screenshots

Step 2: Sharpen positioning before amplifying it

Amplifying weak positioning just distributes weak positioning. Before a single comment or PR went out, we locked the frame. How:

• Extracted the differentiation from the architecture, not the roadmap: MemClaw's genuinely unique primitives are at the fleet level: fleet isolation, trust tiers, cross-agent access control, write-time contradiction detection, and audit trails. Competitors cannot copy the claim without rebuilding their core.
• Validated the demand side: +191% YoY category search growth; a 2026 arXiv survey explicitly calling multi-agent memory governance an open problem; third-party proof that the problem is real; useful as a citation in every piece of content.
• Wrote one line and one supporting line: "The only agent memory system built fleet-first, not adapted for fleets after the fact." Supported by: "Every other memory system was built for one agent, one user, one session. MemClaw was built for the deployment shape production actually has: dozens of agents, multiple domains, shared knowledge with enforced boundaries."
• Propagated it everywhere: The same frame ran through the repo README, every listing description, every Reddit comment, and the demo repos. Consistency is what makes positioning legible to both developers and LLMs.

Step 3: Build proof, not promises: three use-case demo repos

Developers do not trust claims; they clone repos. We designed three demo repositories using a repeatable five-step method:

1. Find the pain thread: Start from a high-engagement Reddit thread where a developer describes a production failure in their own words, e.g., the r/AI_Agents thread: "The agent starts drifting. It forgets preferences, repeats mistakes, and pulls in old context that doesn't apply anymore."
2. Extract the complaint verbatim. The repo README quotes the exact pain, so the developer who has it recognizes it instantly.
3. Design a scenario that deliberately reproduces the failure: The long-run-fleet repo injects drift deliberately: a source reports pricing at $299 on day 3, a different source reports $349 on day 9, and the user changes a preference on day 11, exactly the contradiction that breaks single-agent memory tools silently.
4. Script three "screenshot moments": Every repo is built around outputs developers will screenshot and share: the day-9 write response showing status: "superseded_prior" with the conflicting memory ID; the day-14 recall that ranks the stale fact below the current one; the end-of-run drift report (14 days · 47 writes · 6 supersessions · 2 unresolved contradictions · 3 reinforced facts).
5. Constrain it ruthlessly: Every repo runs locally in under ten minutes on a cheap model. If the proof needs a cloud account or a half-day of setup. It is not proof; it is homework.

The design card for memclaw-longrun-fleet: the architecture, the screenshot moment (a supersession response in JSON), and the verbatim Reddit pain it answers. Every repo was specced this way before a line of code was written.

The three repos ladder deliberately, each one converting a different reader:

These are conversion assets: the click path from a Reddit comment ends in a terminal, not on a landing page.

Step 4: The Reddit engine: comments aimed at threads that LLMs actually cite

This is where GitHub marketing and AI answer optimization become the same job, and it is the part most teams get wrong by treating Reddit as a place to announce things. Our process:

1. Select threads with a two-filter system: Filter one: topical fit; the thread must be about a problem MemClaw genuinely solves (fleet memory, governance, drift, isolation). Filter two: citation value; priority goes to the 78 threads from the Step-1 map that LLMs already cite for the five buying prompts. A comment in a cited thread works twice: once for the humans reading it, and again every time a model retrieves that thread to answer a prompt.
2. Tag every engagement to a prompt: Each comment in the tracking sheet is categorized against one of the five buying prompts (plus themes like "agent governance" and "fleet context"), so coverage per prompt is measurable, not vibes.
3. Write experience-first, answer-first comments: The anatomy of every comment: open from shared experience ("same issue here, root cause was…"), answer the OP's actual question with technical specifics (write-time contradiction detection vs query-time filtering, scoped access, trust tiers), and mention MemClaw only where it genuinely fits. Roughly a third of live comments don't push the product at all. No bare link drops, ever.
4. Run everything through client approval: Every comment was reviewed by the MemClaw team before publishing. The funnel: 54 comments produced, 30 live, 14 approved and queued, 8 pending review, and 2 rejected and never posted. The two rejections are a feature of the process, not a failure: the client's engineers are the last line of defense on technical accuracy and tone.
5. Publish in weekly waves, synced to shipping: 8–10 insertions per week, sequenced with the build track: week one targeted r/LocalLLaMA, r/AI_Agents, and r/AIMemory as the governance repo shipped; week two moved to r/LLMDevs and r/mcp; week three added r/LangChain and the first comparison threads. Comments always had something concrete to point to, because distribution never ran ahead of the build.
6. Draft original posts (OPs) for owned narratives: Alongside comments, three OPs were drafted from angles the audit showed nobody owned: "hit the limits of Mem0 when I went multi-agent, here's what I switched to and why", "an agent that reads its own writes will eventually gaslight itself", and "the memory layer matters more than the orchestration layer".

In total: 30 live engagements across 20 subreddits (r/AI_Agents, r/AIMemory, r/LLMDevs, r/LangChain, r/ClaudeCode, r/ClaudeAI, r/LocalLLaMA, r/mcp, r/microservices, r/cybersecurity, r/SaaS, and nine more), published between May 25 and June 18.

A representative engagement: a technical answer on a multi-agent orchestration thread, and the OP's response, "Appreciate you for taking the time! I'll check out MemClaw."

Step 5: The listing pipeline: get placed where developers, LLMs, and verification tools look

Listings do two jobs: developers browse them, and LLMs cite them as evidence that a tool is real. We ran this as a pipeline with statuses and follow-ups, not a one-time submission spree. The process:

1. Build the target list by surface type: Four categories, in priority order: awesome lists (permanent GitHub-native placements via pull request), MCP directories (Glama, MCP.so, Smithery, category-critical because MemClaw ships an MCP server), OSS discovery platforms (LibHunt, StackShare, Trendshift, these power "alternatives to X" pages), and newsletters (Console.dev, PeerPush).
2. Submit free, high-authority surfaces first: Paid placements (TLDR, OpenAlternative, FuturePedia) were identified, priced, and deliberately deferred; the engagement spent $0 on placement and still shipped 7 live listings.
3. Make every awesome-list PR mergeable on sight: match the list's exact entry format, maintain alphabetical order, and write a one-line description that conveys the fleet-first positioning. Maintainers merge PRs that cost them nothing to review.
4. Follow up on stale PRs: Awesome-list maintainers are volunteers; polite follow-up is the difference between "PR open" and "Live". Four of our open PRs are in active follow-up; one is pending the list's quality-score check.

The open PRs are compounding inventory: they convert to placements over the following weeks with zero additional production cost.

Step 6: Repo hygiene, comparison content, and the contributor funnel

Distribution brings developers to the repo; this step makes the repo convert and keeps the growth compounding. What we delivered:

• Naming: Recommended renaming caura-ai/caura-memclaw to caura-ai/memclaw. Every competitor uses the bare tool name (mem0ai/mem0, letta-ai/letta, getzep/zep); the prefix adds friction and breaks brand recall in lists.
• GitHub topics: The repo launched with zero topics, which means zero topic-page discovery. We specified the set: agent-memory, multi-agent, mcp, llm-memory, ai-agents, fleet-memory, pgvector, agent-governance.
• COMPARISONS.md in the repo: A factual table comparing MemClaw vs Mem0 vs Zep vs Letta on fleet-specific dimensions: fleet isolation, trust tiers, cross-agent access control, audit trail, and cross-agent contradiction resolution. Competitors don't publish this table anywhere because they don't have the features. It also gives LLMs a clean, structured source to quote.
• Content rewrite plan targeting real queries: The audit showed 18 blog posts with zero search demand. The fix: retitle and rewrite around the highest-intent terms in the category ("Mem0 alternative", "Zep alternative", "agent memory for multi-agent systems"), plus four planned posts: a self-disclosed comparison on DEV.to ("Mem0 vs Zep vs MemClaw: what's actually different about fleet-first memory"), an architecture post, a simulation post built on the day-9 contradiction demo, and a "three failure modes" compilation, published where competitors currently dominate and MemClaw had zero posts (DEV.to, Hashnode).
• Contributor funnel: Curated good-first-issue labels and listing on goodfirstissue.dev, so incoming traffic has a path from user to contributor, contributors being the strongest retention signal an OSS project has.

The results

The curve reads like a controlled experiment:

• April 28 – May 20 (pre-engagement): a small launch bump to ~15 stars, then flat. Two stars were added in the final two weeks. This is what a good repo with no distribution looks like.
• May 25 (first Reddit wave goes live): inflection within days. 17 stars become 63 by May 31.
• June (listings go live, waves two and three publish): steady compounding, no single spike. 135 stars by June 24.
• Late June: the fastest stretch of the entire period, crossing 200+ and reaching 204 by July 1.

That last point is the one worth underlining. Launch-driven growth decays within 72 hours; the MemClaw curve accelerated in week six. That is the signature of a system compounding, each comment, listing, and clone feeding the next, rather than a one-off spike wearing off.

The use-case repos grew alongside the main repo. In the most recent two-week reporting window alone:

Beyond stars, the number we care about most: over 31,000+ package downloads.

Stars are attention; downloads are developers actually running the software. And on the AI-visibility front, MemClaw now has a live, technically substantive presence inside the exact threads the LLMs cite for its five buying prompts, the leading indicator that precedes citation flips, which typically lag placement by several weeks.

The 5×4 visibility matrix from week one is re-run on a schedule, so the flip will be measured properly.

How Did These Six Moves Turn Into a Self-Reinforcing Growth Loop?

None of the six moves works on its own. Together they form a loop:

• A developer describes a real pain in a Reddit thread.
• A technical comment answers it and points to a demo repo that proves the fix in a five-minute local run.
• The developer clones, stars, and often downloads the package.
• Awesome lists, MCP directories, and GitHub topics validate the tool when they go to verify it.
• The same thread and listings become citable sources when the next developer asks ChatGPT or Perplexity, "best memory layer for agent fleets."
• That developer lands on the repo, and the loop runs again.

This is also why the work was sequenced the way it was: baselines before positioning, positioning before repos, repos before amplification. Amplification multiplies whatever exists, so what exists has to be worth multiplying.

Steal this playbook: the 10-step checklist

The condensed version, in the order we ran it:

1. Write down the 5 prompts a buyer would ask an LLM before choosing your category. Run them across ChatGPT, Claude, Gemini, and Perplexity. Log every ranking and citation.
2. Open every cited source and build your thread map. Those threads are your distribution targets, not the biggest subreddits.
3. Audit your domain vs competitors: ranking keywords, organic traffic, content gaps. If your blog titles have no search demand, that's job one.
4. Lock one positioning line competitors can't copy without rebuilding their product. Validate it with third-party evidence (category growth data, academic citations).
5. Build 1–3 demo repos, each reverse-engineered from a verbatim complaint in a real thread, each with three screenshot moments, each running locally in under ten minutes.
6. Comment in weekly waves of 8–10: experience first, answer the actual question, mention your tool only where it fits, route everything through technical approval.
7. Submit to awesome lists and directories, free and high-authority first. Match each list's format exactly. Follow up on stale PRs weekly.
8. Fix repo hygiene: bare tool name, full topic set, COMPARISONS.md with the dimensions you win on, good-first-issue labels.
9. Sync distribution to shipping. Never point a comment at something that doesn't exist yet.
10. Re-run the prompt audit monthly. Star velocity is the early signal; LLM citation flips are the payoff that follows.

What this means for your repo

If you run growth, product marketing, or DevRel for an open-source tool, four things transfer directly:

• Stars follow distribution, not code quality: The same product sat at 17 stars from their internal team, then added ~30 a week once the system ran. Nothing about the code changed.
• Reddit is now an AEO channel: Choose threads by whether LLMs cite them, not by subscriber count. Your comment today is a ChatGPT citation for next quarter.
• Demo repos out-convert landing pages: Reverse-engineer them from real complaint threads so the value is obvious to the person who wrote the complaint.
• Compounding beats spiking: A front-page launch decays in days. A distribution system posted its fastest growth in week six.

Work with Infrasity

Infrasity runs this exact motion, audits, positioning, demo repos, Reddit engagement, listing pipelines, and AI answer visibility for AI infrastructure and developer-tool teams. The work is done by engineers, measured against baselines, and reported in numbers like the ones above.

Explore the service: GitHub Marketing · Reddit Marketing · AI GEO Optimization

Go deeper: Open Source Marketing Strategy: Turning Public Repos Into Active Pipeline · OSS Launch Visibility Checklist (free tool) · More case studies

Launching or relaunching an open-source repo this quarter? Book a free consultation, and we'll audit your AI answer visibility for your top five buying prompts, just as we did with MemClaw.