<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Aashish Gupta</title>
    <description>The latest articles on DEV Community by Aashish Gupta (@aashish_g).</description>
    <link>https://dev.to/aashish_g</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4191937%2F82929d19-93ec-4153-929d-69c82ed0c777.png</url>
      <title>DEV Community: Aashish Gupta</title>
      <link>https://dev.to/aashish_g</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/aashish_g"/>
    <language>en</language>
    <item>
      <title>I gave Claude Code a crew. Codex and Gemini found a race in the plugin that runs them.</title>
      <dc:creator>Aashish Gupta</dc:creator>
      <pubDate>Sun, 01 Nov 2026 10:54:35 +0000</pubDate>
      <link>https://dev.to/aashish_g/i-gave-claude-code-a-crew-codex-and-gemini-found-a-race-in-the-plugin-that-runs-them-10jn</link>
      <guid>https://dev.to/aashish_g/i-gave-claude-code-a-crew-codex-and-gemini-found-a-race-in-the-plugin-that-runs-them-10jn</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;TL;DR&lt;/strong&gt; crewmate is a Claude Code plugin that lets Claude hand a task to OpenAI Codex or Google Gemini, keep working, and watch every step land in the conversation. It installs with &lt;strong&gt;2 commands&lt;/strong&gt; and has &lt;strong&gt;0 dependencies&lt;/strong&gt;. When I asked it to review its own code, &lt;strong&gt;both&lt;/strong&gt; models found the same race condition, one I had decided was too rare to matter. If Codex is the only other model you use, OpenAI's own plugin is the better choice; more on that below.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/aashish-g03/crewmate" rel="noopener noreferrer"&gt;Code&lt;/a&gt; | Try it&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fi3vsw3awb4keswc4i4ab.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fi3vsw3awb4keswc4i4ab.gif" alt="A real crewmate run: I ask Codex whether sumTo in calc.js is correct; progress lines stream in (started, two shell commands, the answer) and the job ends &amp;quot;done in 15s&amp;quot;." width="720" height="315"&gt;&lt;/a&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  "Ask the other model"
&lt;/h2&gt;

&lt;p&gt;You know the move. Claude wrote something you're unsure about, so you open another terminal and paste it into Codex or Gemini. You wait, copy the answer back, and paste it into Claude.&lt;/p&gt;

&lt;p&gt;The second opinion is often worth it. The copy-paste isn't. I wanted Claude to make that hand-off itself, and I wanted three things from it:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;See progress&lt;/strong&gt; while the other model works, not just a final blob.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Nothing to babysit:&lt;/strong&gt; no server or extra terminal to keep running.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Know how it really ended:&lt;/strong&gt; done, failed, timed out, or canceled, and why.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What it does
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Hand off and keep working.&lt;/strong&gt; Each job runs in the background. Claude carries on, and the answer is waiting when the job ends, even if you closed the session.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Live progress in the chat.&lt;/strong&gt; Every file read, command and note shows up as it happens.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Clear endings.&lt;/strong&gt; A job ends &lt;code&gt;done&lt;/code&gt;, &lt;code&gt;failed&lt;/code&gt;, &lt;code&gt;timeout&lt;/code&gt; or &lt;code&gt;canceled&lt;/code&gt;, with the reason and any tools the other model was denied.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Read-only unless you say so.&lt;/strong&gt; The other model can read your code. Add &lt;code&gt;--write&lt;/code&gt; and it can edit the folder; only one writing job runs at a time.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Follow-ups.&lt;/strong&gt; &lt;code&gt;--resume&lt;/code&gt; continues the last conversation with that model.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Zero-context critique.&lt;/strong&gt; &lt;code&gt;/crewmate:critique&lt;/code&gt; sends a design doc or a diff to both models at once, and neither sees your conversation.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F2edajwkyox9x80fg1nib.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F2edajwkyox9x80fg1nib.png" alt="How it works: Claude Code calls crewmate, which starts a background runner per job. One runner drives Codex, the other drives Gemini. Each job's progress and answer are saved under ~/.crewmate, and watch --brief streams them back to Claude." width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;That last one is the command I use most. A reviewer who hasn't seen your reasoning finds the gaps you filled in mentally, and two different models find different gaps.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzgt22aj6iv6cj33kqngh.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzgt22aj6iv6cj33kqngh.gif" alt="A real critique of a diff: Codex and Gemini start together, failed steps show in red as they happen, each posts a progress summary, and both finish with &amp;quot;done&amp;quot; (Codex in 33 s, Gemini in 75 s)." width="720" height="338"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Claude decides when to use it
&lt;/h2&gt;

&lt;p&gt;You don't need a slash command. I asked Claude in plain words: &lt;em&gt;"I want a second opinion from a different model than you: does add.js handle string inputs safely? Get Gemini's view, then tell me where you agree or disagree."&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Claude picked up crewmate on its own:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Skill   crewmate
Bash    crewmate ask gemini --detach &amp;lt;&amp;lt;'PROMPT' … PROMPT
Bash    crewmate watch --brief gemini-mvxp4oxz-o0o6
Bash    crewmate result gemini-mvxp4oxz-o0o6
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It wrote Gemini's brief, watched the job, checked the answer itself, and told me where the two agreed. An agent orchestrating a bigger task can hand work to Codex or Gemini the same way, without waiting for you.&lt;/p&gt;

&lt;h2&gt;
  
  
  The bug two models agreed on
&lt;/h2&gt;

&lt;p&gt;Late in the build, I ran &lt;code&gt;/crewmate:critique&lt;/code&gt; on crewmate's own lock: the code that stops two writing jobs from editing your files at once. Codex and Gemini &lt;strong&gt;both&lt;/strong&gt; flagged the same race.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvcdabkmbk7j318e329ha.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvcdabkmbk7j318e329ha.png" alt="The race: jobs A and B both see an old, abandoned lock. A deletes it and takes the lock. B, still acting on what it saw, deletes A's new lock and takes it too, so two jobs edit your files at once. The fix runs check-and-take under a short lock of its own." width="800" height="420"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I had decided that race was too rare to matter, and written that down in my plan. Codex quoted the line back at me. It's fixed now. That's the second opinion I built crewmate to get.&lt;/p&gt;

&lt;h2&gt;
  
  
  What it won't do
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Gemini can't run shell commands&lt;/strong&gt; in read-only jobs; it reads files instead. With &lt;code&gt;--write&lt;/code&gt; it can edit files, but still no shell.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;If your Gemini (agy) settings allow writes or commands,&lt;/strong&gt; crewmate refuses read-only Gemini jobs rather than pretend they're read-only.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;macOS is what I've tested on.&lt;/strong&gt; Linux should work; Windows isn't supported yet.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Why not just OpenAI's plugin?
&lt;/h2&gt;

&lt;p&gt;If Codex is the only other model you use, install &lt;a href="https://github.com/openai/codex-plugin-cc" rel="noopener noreferrer"&gt;codex-plugin-cc&lt;/a&gt;: it's built on Codex's own app server and has extras like a hand-off into a native Codex session. crewmate is for having &lt;strong&gt;both&lt;/strong&gt; Codex and Gemini behind one install.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;1. Install&lt;/strong&gt; (in Claude Code):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/plugin marketplace add aashish-g03/crewmate
/plugin install crewmate@crewmate
/crewmate:setup
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;/crewmate:setup&lt;/code&gt; checks everything and tells you exactly what's missing. You need Node 20+ and at least one of these, installed and signed in:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm i &lt;span class="nt"&gt;-g&lt;/span&gt; @openai/codex &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; codex login                                &lt;span class="c"&gt;# Codex&lt;/span&gt;
curl &lt;span class="nt"&gt;-fsSL&lt;/span&gt; https://antigravity.google/cli/install.sh | bash &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; agy   &lt;span class="c"&gt;# Gemini (Antigravity CLI)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;2. Use it:&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/crewmate:ask gemini Read src/ and list any exported functions nothing uses
/crewmate:critique --diff
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Or just ask Claude: &lt;em&gt;"get a second opinion from Codex on this migration."&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Next on my list: more models behind the same commands, and falling back to another model when one runs out of quota. If you try it, tell me where the second opinion surprised you.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;AI disclosure: I built crewmate with Claude Code as the implementer, working from a design and plan I directed and approved, with Codex, Gemini and fresh Claude reviewers checking the work. This post was drafted with Claude and edited by me. Every terminal frame is real output.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>claudecode</category>
      <category>ai</category>
      <category>opensource</category>
      <category>productivity</category>
    </item>
    <item>
      <title>I stopped re-explaining my work to Claude Code every time the context filled up</title>
      <dc:creator>Aashish Gupta</dc:creator>
      <pubDate>Sat, 31 Oct 2026 16:46:25 +0000</pubDate>
      <link>https://dev.to/aashish_g/i-stopped-re-explaining-my-work-to-claude-code-every-time-the-context-filled-up-1bo0</link>
      <guid>https://dev.to/aashish_g/i-stopped-re-explaining-my-work-to-claude-code-every-time-the-context-filled-up-1bo0</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;TL;DR:&lt;/strong&gt; &lt;strong&gt;handoff&lt;/strong&gt; is a Claude Code mod. When a conversation passes &lt;strong&gt;70%&lt;/strong&gt; of its context, a &lt;strong&gt;Handoff&lt;/strong&gt; button appears above the prompt. One press saves the full transcript (&lt;strong&gt;212 KB&lt;/strong&gt; on my last run) and has Claude write a &lt;strong&gt;16 KB brief&lt;/strong&gt;: the task, every open question, a pending checklist, decisions and gotchas. Press &lt;strong&gt;Start fresh&lt;/strong&gt;, and &lt;strong&gt;0.6 s&lt;/strong&gt; after &lt;code&gt;/clear&lt;/code&gt; the new conversation resumes from the brief by itself, with nothing typed. It does &lt;strong&gt;not&lt;/strong&gt; carry handoffs between machines, and I've only tested it in a macOS terminal.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/aashish-g03/claude-mods" rel="noopener noreferrer"&gt;Code&lt;/a&gt; | Install | Built on Claude Code mods (early access)&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fy8fh0q3iqwcibmyhs0h4.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fy8fh0q3iqwcibmyhs0h4.gif" alt="The handoff band: the context reaches 72% and a Handoff button appears; after pressing it the band reads Handoff saved, 8 pending; /clear runs; the next conversation is sent a resume prompt automatically and Claude reports where things stand" width="720" height="405"&gt;&lt;/a&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  "Continue from where I left off"
&lt;/h2&gt;

&lt;p&gt;Every time a Claude Code conversation hit 75–80% of its context, I did the same five things:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fn8i0qdqig9h1fnfv3iff.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fn8i0qdqig9h1fnfv3iff.gif" alt="The old ritual in five steps: notice the context is at 78%, run /export, open a new session that knows nothing, paste a long &amp;quot;continue from where I left off, answer every question, tell me what's pending&amp;quot; prompt, then wait while it reads a 300 KB export and guesses which parts mattered" width="720" height="378"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The prompt I pasted was always some version of:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;I was working on this project in another session but I'm moving to a new one. Continue from where I left off. Answer every question we discussed. Check skills and other things so we can start. Tell me what's still pending.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;It mostly worked. But a raw export tells the next session &lt;em&gt;what was said&lt;/em&gt;, not &lt;em&gt;what mattered&lt;/em&gt;, so it re-read everything and guessed. And it was the same five steps, every time.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I built
&lt;/h2&gt;

&lt;p&gt;A band that sits above the prompt and walks through the handoff:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;You see&lt;/th&gt;
&lt;th&gt;What it means&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;Context 72%&lt;/code&gt; &lt;strong&gt;&lt;code&gt;Handoff&lt;/code&gt;&lt;/strong&gt; &lt;code&gt;Later&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Past the threshold. &lt;strong&gt;Later&lt;/strong&gt; waits another 5 points.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;Handoff saved · 8 pending&lt;/code&gt; &lt;strong&gt;&lt;code&gt;Start fresh&lt;/code&gt;&lt;/strong&gt;
&lt;/td&gt;
&lt;td&gt;Both files are on disk. &lt;strong&gt;Start fresh&lt;/strong&gt; runs &lt;code&gt;/clear&lt;/code&gt;.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;Resuming from handoff…&lt;/code&gt; &lt;strong&gt;&lt;code&gt;Skip&lt;/code&gt;&lt;/strong&gt;
&lt;/td&gt;
&lt;td&gt;The cleared conversation resumes in a few seconds.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Resumed from handoff · 8 pending&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Claude is reading the brief.&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The brief is the point. Claude writes it over the conversation it's leaving, so it knows what was decided, what was rejected and what I corrected along the way:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fg6tx9n60jkf4l8xw28as.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fg6tx9n60jkf4l8xw28as.gif" alt="A brief.md filling in section by section: Task in progress, Questions raised and their status (one OPEN, one answered), Pending checklist, Decisions, Gotchas, and Skills and memories. Beside it, a bar shrinks from the 212 KB transcript to the 16 KB brief, about 4,000 tokens" width="720" height="468"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;On the run that worked end to end, the new session read the brief, listed the open questions and all 7 pending items correctly, and waited for me before touching anything. The full transcript stays on disk next to the brief, for the rare detail the brief leaves out.&lt;/p&gt;

&lt;h2&gt;
  
  
  What a mod is
&lt;/h2&gt;

&lt;p&gt;Mods are an early-access way to change Claude Code itself. A mod is a TypeScript module that hooks engine events:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="k"&gt;export&lt;/span&gt; &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;register&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;Register&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;on&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="c1"&gt;// After every turn: how full is the context?&lt;/span&gt;
  &lt;span class="nf"&gt;on&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;session.measure&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="k"&gt;async &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;$&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;e&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;next&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c1"&gt;// e.context.percent → show the band at 70%&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;next&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;e&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
  &lt;span class="p"&gt;})&lt;/span&gt;

  &lt;span class="c1"&gt;// Draw the band above the prompt, or nothing.&lt;/span&gt;
  &lt;span class="nf"&gt;on&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;ui.render&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="na"&gt;component&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;AbovePrompt&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt; &lt;span class="p"&gt;},&lt;/span&gt; &lt;span class="k"&gt;async &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;$&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;e&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;next&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;Box&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;Button&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;Text&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;$&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;ui&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;resolve&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;e&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="c1"&gt;// …&lt;/span&gt;
  &lt;span class="p"&gt;})&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;$&lt;/code&gt; is the engine (&lt;code&gt;$.session&lt;/code&gt;, &lt;code&gt;$.model&lt;/code&gt;, &lt;code&gt;$.fs&lt;/code&gt;, &lt;code&gt;$.store&lt;/code&gt;, &lt;code&gt;$.ui&lt;/code&gt;…), and &lt;code&gt;next(e)&lt;/code&gt; hands the event to whatever comes after you. That's enough for a band with buttons, two slash commands and a timer.&lt;/p&gt;

&lt;h2&gt;
  
  
  What didn't work
&lt;/h2&gt;

&lt;p&gt;The first version passed its tests and then failed in real use four different ways. These were the most useful part of building it.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. The button would never have appeared
&lt;/h3&gt;

&lt;p&gt;The button is meant to come up before auto-compact runs. I worked out the auto-compact point over the &lt;em&gt;compaction&lt;/em&gt; window, but the fill Claude Code reports is over the &lt;em&gt;model's&lt;/em&gt; window. When those differ, it breaks:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fca9igq3tpmim069p66dv.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fca9igq3tpmim069p66dv.gif" alt="Two context bars on a 1M-token model with a 200k compaction window. First version: auto-compact really happens at 16%, but the button waits at 70%, so the conversation is compacted and no button ever appears. Fixed: the button appears at 11%, five points before compaction at 16%" width="720" height="414"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The fix was one denominator. The test for it uses exactly that setup.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. A security plugin skipped my hook
&lt;/h3&gt;

&lt;p&gt;My first design slipped the brief into the next conversation's system prompt with a &lt;code&gt;prompt.compose&lt;/code&gt; hook. The first live load printed:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;handoff: its prompt.compose hook was skipped. "cc-plugin-sec-default" runs first and sent the event on past it.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A security plugin loaded ahead of mine sends prompt-shaping events past personal mods. Fair enough, and yours may well do the same, so don't build on those events.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. The brief arrived 45 ms too late
&lt;/h3&gt;

&lt;p&gt;Next I added the brief as a hidden note at the start of the turn. The band said &lt;strong&gt;Resumed&lt;/strong&gt;, so I asked "what's pending?", and Claude answered about a completely different branch. The session log showed why:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fg4t5x4hnkf3svpkcfzts.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fg4t5x4hnkf3svpkcfzts.png" alt="Two timelines. Hidden note: you send &amp;quot;what's pending?&amp;quot; at 0 ms, the request goes to the model at 0 ms, the brief is stored at +45 ms and misses the request, and Claude answers about a different branch. Fix: /clear at 0 s, the mod sends a resume prompt at +0.6 s, Claude reads brief.md, lists 7 pending items and waits" width="800" height="480"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  4. The fix was the simplest version
&lt;/h3&gt;

&lt;p&gt;After &lt;code&gt;/clear&lt;/code&gt;, the mod just sends a normal prompt, as if I'd typed it: &lt;em&gt;"Resume from my handoff… Read the brief at &lt;code&gt;&amp;lt;path&amp;gt;&lt;/code&gt; first."&lt;/em&gt; Claude reads the file itself, which doesn't depend on timing or need any special access.&lt;/p&gt;

&lt;p&gt;One last catch: I'd set that delay to 500 ms, which made the &lt;strong&gt;Skip&lt;/strong&gt; button impossible to press. It's 4 seconds now. The prompt waits until the session is idle anyway, so it never interrupts you.&lt;/p&gt;

&lt;h2&gt;
  
  
  Tests that catch real bugs
&lt;/h2&gt;

&lt;p&gt;Halfway through I read &lt;a href="https://x.com/RayFernando1337/status/2103279689615958062" rel="noopener noreferrer"&gt;Ray Fernando's post&lt;/a&gt; about deleting 60,984 lines of "test slop": unit tests written after the code restate the code and catch nothing. I had 13 tests and deleted the 2 that only restated the implementation.&lt;/p&gt;

&lt;p&gt;The 9 left each pin a way the mod has actually failed or could fail:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;a compaction window smaller than the model's window&lt;/li&gt;
&lt;li&gt;a brief that fails, and a file write that throws&lt;/li&gt;
&lt;li&gt;resuming exactly once after &lt;code&gt;/clear&lt;/code&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Skip&lt;/strong&gt;, stale handoffs, and a refused resume prompt&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The real checks were the live runs.&lt;/p&gt;

&lt;h2&gt;
  
  
  What it touches
&lt;/h2&gt;

&lt;p&gt;Mods run with Claude Code's own permissions and aren't sandboxed. This one:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;reads the current conversation and asks Claude for the brief (billed like any turn)&lt;/li&gt;
&lt;li&gt;writes two files under &lt;code&gt;~/.claude/handoffs/&lt;/code&gt;, never inside your repos&lt;/li&gt;
&lt;li&gt;remembers, per folder, which handoff is waiting&lt;/li&gt;
&lt;li&gt;sends the resume prompt and runs &lt;code&gt;/clear&lt;/code&gt; when you press the button&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It makes no network calls of its own and starts no processes. It's &lt;a href="https://github.com/aashish-g03/claude-mods/blob/main/handoff/hooks/register.tsx" rel="noopener noreferrer"&gt;one file, about 300 lines&lt;/a&gt;, so read it before you install it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Install:&lt;/strong&gt; at a Claude Code prompt, run &lt;code&gt;/plugin install handoff --marketplace aashish-g03/claude-mods&lt;/code&gt;, then pick the &lt;strong&gt;user&lt;/strong&gt; scope so it runs in every project.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Use:&lt;/strong&gt; keep working until the band appears at 70%, press &lt;strong&gt;Handoff&lt;/strong&gt;, then &lt;strong&gt;Start fresh&lt;/strong&gt;. You can also type &lt;code&gt;/handoff&lt;/code&gt;, and &lt;code&gt;/handoff-skip&lt;/code&gt; starts clean.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Read the code:&lt;/strong&gt; &lt;a href="https://github.com/aashish-g03/claude-mods" rel="noopener noreferrer"&gt;github.com/aashish-g03/claude-mods&lt;/a&gt;, with the tests and a full README.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Next, I want to check that the new-window path resumes as reliably as &lt;code&gt;/clear&lt;/code&gt; does, and to try a pending pane that lets you tick items off while you work.&lt;/p&gt;

&lt;p&gt;If you have your own ritual for running out of context, I'd like to hear it in the comments.&lt;/p&gt;

&lt;h2&gt;
  
  
  AI disclosure
&lt;/h2&gt;

&lt;p&gt;I built this with Claude Code as a coding assistant, and Claude helped draft this post and make its diagrams. The design decisions, the bugs and the fixes described here are mine to explain and defend.&lt;/p&gt;

</description>
      <category>claude</category>
      <category>ai</category>
      <category>productivity</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Same AI, with and without memory: a FalkorDB graph took issue routing from 18% to 74%</title>
      <dc:creator>Aashish Gupta</dc:creator>
      <pubDate>Sun, 18 Oct 2026 11:41:12 +0000</pubDate>
      <link>https://dev.to/aashish_g/same-ai-with-and-without-memory-a-falkordb-graph-took-issue-routing-from-18-to-74-3812</link>
      <guid>https://dev.to/aashish_g/same-ai-with-and-without-memory-a-falkordb-graph-took-issue-routing-from-18-to-74-3812</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;TL;DR:&lt;/strong&gt; Handoff Graph is an issue-routing agent that remembers &lt;strong&gt;who hands which issues to whom&lt;/strong&gt; in a FalkorDB graph. I tested the same AI model and the same decision code with and without that memory, on two held-out periods of &lt;strong&gt;real microsoft/vscode triage&lt;/strong&gt; (4,197 issues), each run once. In the summer period, without memory it hands &lt;strong&gt;66%&lt;/strong&gt; of issues to a human and picks the right owner first time &lt;strong&gt;18%&lt;/strong&gt; of the time. With memory: &lt;strong&gt;4%&lt;/strong&gt; and &lt;strong&gt;74%&lt;/strong&gt; (spring is similar: 64% to 7%, and 15% to 58%), within a few points of Microsoft's purpose-built triage classifier, with no training. It does &lt;strong&gt;not&lt;/strong&gt; beat that classifier, and I show why.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://handoff-graph.up.railway.app" rel="noopener noreferrer"&gt;Live demo&lt;/a&gt; (no sign-up) | &lt;a href="https://github.com/aashish-g03/handoff-graph" rel="noopener noreferrer"&gt;Code&lt;/a&gt; | &lt;a href="https://handoff-graph.up.railway.app/mcp" rel="noopener noreferrer"&gt;MCP server&lt;/a&gt; | Built for Graph Hacks (WeMakeDevs x FalkorDB), Track 2: Agent Memory and Coordination&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/zMDPJWjogcw" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;




&lt;h2&gt;
  
  
  "Not me, ask them"
&lt;/h2&gt;

&lt;p&gt;A ticket is assigned to you, it isn't yours, and you pass it on. Every engineering team does this many times a week. Microsoft's own research found that reassigned incidents can take up to 10× longer to triage. A 2009 study of Mozilla and Eclipse found that 37 to 44% of bugs got passed between developers. Ticketing tools count these reassignments, but they don't learn from them.&lt;/p&gt;

&lt;p&gt;I used &lt;strong&gt;microsoft/vscode&lt;/strong&gt; because it's very active and its triage is public. Between June and mid-October 2026, 11,734 issues were filed. A triage bot made 65% of the first assignments. 1,678 issues were handed on to someone else, and four out of five of those handoffs started with the bot's pick.&lt;/p&gt;

&lt;p&gt;Each of those handoffs carries knowledge: &lt;em&gt;this kind of issue, given to this person, ends up with that person.&lt;/em&gt; Some engineers act as hubs. One engineer (call them A) received 405 issues from the bot between June and October, kept 238, handed 75 to one colleague and 64 to another. That pattern is invisible in any single issue, and obvious in a graph:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foh2jbdpukhd3kijki76r.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foh2jbdpukhd3kijki76r.png" alt="One engineer's handoff memory in FalkorDB: of 405 issues the bot gave them, they kept 238, handed 75 to B, 64 to C, and a few to others" width="800" height="802"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The hackathon's tagline is "agents are only as good as the context they work with." I wanted to measure that claim instead of asserting it. Routing is a good test, because an agent has to make the same decision thousands of times, and history says who was right.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I built
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwbu1k3vw7hf1yoww6uqv.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwbu1k3vw7hf1yoww6uqv.png" alt="Architecture: a learner agent writes HANDED_OFF edges into FalkorDB; a read-only router agent reads memory as of time t, asks Jev one question per candidate, then routes, asks a human, or keeps the bot's pick" width="800" height="842"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Handoff Graph&lt;/strong&gt; has two agents that share one FalkorDB graph.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The learner&lt;/strong&gt; turns every reassignment event into a timestamped edge, &lt;code&gt;(:Person)-[:HANDED_OFF {issue, at, kind}]-&amp;gt;(:Person)&lt;/code&gt;. It's the only component that writes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The router&lt;/strong&gt; is read-only. When an issue arrives for the bot's pick A, it asks the graph who A has handed similar work to, and how often A kept it. That gives it a short candidate list and a prior. Then it asks a decision model, &lt;a href="https://docs.typesafe.ai" rel="noopener noreferrer"&gt;TypeSafe Jev&lt;/a&gt;, one narrow yes/no question per candidate: does this issue look like the ones A kept, or the ones A passed to B?&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The decision rule lives in code, not in a prompt.&lt;/strong&gt; If an alternative clearly wins, route to them. If it's too close to call, ask a human and say why. Otherwise, keep the bot's pick.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Every decision comes back with the graph path that justifies it. Here's the live page making a real call. The bot would give this WSL bug to one engineer; memory says that engineer has passed issues like it to a colleague, and the text agrees:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fw2oojquyg7b0t0w5ld5h.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fw2oojquyg7b0t0w5ld5h.png" alt="The live demo routing a real VS Code issue: the bot's pick handed 5 of 151 similar issues to another engineer, so the agent routes there, showing every candidate's probability and evidence issues" width="620" height="772"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;(The live demo shows public GitHub handles because every path cites public issues. This post uses letters instead.)&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The model never writes Cypher. It gets a fixed set of tools over parameterised queries, exposed through an MCP server, so Claude Code or any MCP client can call it. Each repository gets its own graph. The core query is small, and its one important detail is the timestamp filter:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cypher"&gt;&lt;code&gt;&lt;span class="k"&gt;MATCH&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="ss"&gt;(&lt;/span&gt;&lt;span class="py"&gt;a:&lt;/span&gt;&lt;span class="n"&gt;Person&lt;/span&gt; &lt;span class="ss"&gt;{&lt;/span&gt;&lt;span class="py"&gt;login:&lt;/span&gt; &lt;span class="n"&gt;$first_pick&lt;/span&gt;&lt;span class="ss"&gt;})&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="ss"&gt;[&lt;/span&gt;&lt;span class="py"&gt;h:&lt;/span&gt;&lt;span class="n"&gt;HANDED_OFF&lt;/span&gt;&lt;span class="ss"&gt;]&lt;/span&gt;&lt;span class="o"&gt;-&amp;gt;&lt;/span&gt;&lt;span class="ss"&gt;(&lt;/span&gt;&lt;span class="py"&gt;b:&lt;/span&gt;&lt;span class="n"&gt;Person&lt;/span&gt;&lt;span class="ss"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;WHERE&lt;/span&gt; &lt;span class="n"&gt;h.at&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="n"&gt;$t&lt;/span&gt; &lt;span class="ow"&gt;AND&lt;/span&gt; &lt;span class="n"&gt;h.at&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="n"&gt;$since&lt;/span&gt; &lt;span class="ow"&gt;AND&lt;/span&gt; &lt;span class="n"&gt;h.kind&lt;/span&gt; &lt;span class="ow"&gt;IN&lt;/span&gt; &lt;span class="ss"&gt;[&lt;/span&gt;&lt;span class="s1"&gt;'forward'&lt;/span&gt;&lt;span class="ss"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;'reassign'&lt;/span&gt;&lt;span class="ss"&gt;]&lt;/span&gt;
&lt;span class="k"&gt;WITH&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="ss"&gt;,&lt;/span&gt; &lt;span class="nf"&gt;count&lt;/span&gt;&lt;span class="ss"&gt;(&lt;/span&gt;&lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="ss"&gt;)&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;times&lt;/span&gt;&lt;span class="ss"&gt;,&lt;/span&gt; &lt;span class="nf"&gt;max&lt;/span&gt;&lt;span class="ss"&gt;(&lt;/span&gt;&lt;span class="n"&gt;h.at&lt;/span&gt;&lt;span class="ss"&gt;)&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;last_at&lt;/span&gt;&lt;span class="ss"&gt;,&lt;/span&gt;
     &lt;span class="nf"&gt;collect&lt;/span&gt;&lt;span class="ss"&gt;(&lt;/span&gt;&lt;span class="n"&gt;h.issue&lt;/span&gt;&lt;span class="ss"&gt;)[&lt;/span&gt;&lt;span class="m"&gt;0&lt;/span&gt;&lt;span class="o"&gt;..&lt;/span&gt;&lt;span class="m"&gt;5&lt;/span&gt;&lt;span class="ss"&gt;]&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;examples&lt;/span&gt;
&lt;span class="k"&gt;RETURN&lt;/span&gt; &lt;span class="n"&gt;b.login&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;login&lt;/span&gt;&lt;span class="ss"&gt;,&lt;/span&gt; &lt;span class="n"&gt;times&lt;/span&gt;&lt;span class="ss"&gt;,&lt;/span&gt; &lt;span class="n"&gt;last_at&lt;/span&gt;&lt;span class="ss"&gt;,&lt;/span&gt; &lt;span class="n"&gt;examples&lt;/span&gt;
&lt;span class="k"&gt;ORDER&lt;/span&gt; &lt;span class="k"&gt;BY&lt;/span&gt; &lt;span class="n"&gt;times&lt;/span&gt; &lt;span class="k"&gt;DESC&lt;/span&gt;&lt;span class="ss"&gt;,&lt;/span&gt; &lt;span class="n"&gt;last_at&lt;/span&gt; &lt;span class="k"&gt;DESC&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  How I measured it
&lt;/h2&gt;

&lt;p&gt;Honestly, most of my time went here. It's easy to fool yourself on a task like this.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fv7krqku6dbgqqv1lbk44.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fv7krqku6dbgqqv1lbk44.png" alt="Evaluation timeline: summer data split into learn, tune, develop and a held-out period run once; spring data in its own graph with learn, tune and a held-out period run once" width="800" height="590"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Time-ordered replay.&lt;/strong&gt; Each historical issue is routed at the exact moment VS Code's bot first assigned it. The learner advances day by day, and every router query filters &lt;code&gt;at &amp;lt; $t&lt;/code&gt;, so a decision can never see a later handoff.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No label leakage.&lt;/strong&gt; VS Code issues gain area labels over time, often from the same person who later reassigns them. Only about one handoff in five had an area label at the moment of routing. So the router only sees labels that existed at that moment, and otherwise relies on the issue text.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A fair comparison.&lt;/strong&gt; "Without memory" means the &lt;em&gt;same&lt;/em&gt; Jev model and the &lt;em&gt;same&lt;/em&gt; decision code. Only the candidates and prior come from somewhere else: the people most often assigned in the previous two weeks.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Frozen design, held-out data, run once.&lt;/strong&gt; I did all design work on a development window. Then I froze the design, committed the exact command, and ran it once on a held-out period (summer: Aug 25 to Sep 15, 1,133 issues). Later I fetched a second, completely separate period (spring: Apr 1 to May 15, 3,064 issues), built its own graph and ran it once too.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The result
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1hvqxopm8qkaf21uole6.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1hvqxopm8qkaf21uole6.png" alt="Results: without graph memory the agent asks a human 66% and 64% of the time; with memory 4% and 7%. Right owner first time rises from 18% and 15% to 74% and 58%, against VS Code's classifier at 77% and 62%" width="800" height="635"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Same model, same decision code&lt;/th&gt;
&lt;th&gt;Has to ask a human&lt;/th&gt;
&lt;th&gt;Right owner, first try&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Without graph memory&lt;/td&gt;
&lt;td&gt;66% / 64%&lt;/td&gt;
&lt;td&gt;18% / 15%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;With FalkorDB graph memory&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;4% / 7%&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;74% / 58%&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;VS Code's dedicated triage classifier, for scale&lt;/td&gt;
&lt;td&gt;0%&lt;/td&gt;
&lt;td&gt;77% / 62%&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;em&gt;(summer / spring)&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Without memory, the agent is nearly useless. It hands two-thirds of issues to a human, and it picks the right owner first time less than one time in five. With memory, it asks for help on about one issue in twenty, and its first-try accuracy lands within 2 to 4 points of Microsoft's purpose-built classifier. That classifier runs on its own model with a hand-maintained ownership file, and the VS Code team corrects it by hand. Mine has no training and no per-repo model. Both held-out periods tell the same story.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is FalkorDB doing real work?
&lt;/h2&gt;

&lt;p&gt;The hackathon's rules say the graph has to do real work, and this is the cleanest test I could design for it: take the graph away and keep everything else the same. Same model, same prompts, same decision code. What collapses is exactly what the graph provides: who handed what to whom, as of that moment. Escalations go from 4% to 66%, and first-try accuracy goes from 74% to 18%.&lt;/p&gt;

&lt;p&gt;How the project maps onto Track 2:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Track 2 asks for&lt;/th&gt;
&lt;th&gt;In Handoff Graph&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Persistent memory&lt;/td&gt;
&lt;td&gt;Every handoff is an edge with a timestamp; nothing is forgotten, and every read is "as of time t"&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Shared state between agents&lt;/td&gt;
&lt;td&gt;The learner writes, the router reads; they coordinate only through FalkorDB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Handoffs&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;HANDED_OFF&lt;/code&gt; edges are the memory, and every routing decision cites them as its path&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Separate memory per tenant&lt;/td&gt;
&lt;td&gt;One FalkorDB graph per repository (&lt;code&gt;hg:&amp;lt;owner&amp;gt;:&amp;lt;repo&amp;gt;&lt;/code&gt;)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Memory that changes behaviour&lt;/td&gt;
&lt;td&gt;The same agent routes, keeps, or asks a human depending on what the graph remembers&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  What didn't work, and why that's interesting
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;It doesn't beat Microsoft's classifier on a single first guess.&lt;/strong&gt; On the issues my agent chooses to route, the two are right equally often (within 0.2 points). I also pre-registered a stricter attempt: at least +2 points of precision while escalating at most 15% of issues. It looked good on development data (+3.8) and failed on the unseen spring period (+0.5). That gap is the classic sign of tuning to noise, and I'd rather show it than hide it.&lt;/p&gt;

&lt;p&gt;So I checked the ceiling. Suppose a system knew &lt;em&gt;exactly&lt;/em&gt; which issues would be handed on, and sent each one to the person's most common recent handoff target. Even that only reaches about 85%, against the bot's 78%. The prize is seven points, and you'd have to know which issue gets forwarded. Knowing who tends to forward isn't enough. I tested every signal I had for that: the issue text (AUC 0.57, close to a coin flip), the person's recent forwarding rate (AUC 0.74, but no override rule that came out ahead), and who filed the issue (no help). The median handoff happens about a day after routing. It depends on workload, leave and conversations that nobody can see when the issue arrives.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Memory about people goes stale fast.&lt;/strong&gt; On development data, the memory's best alternative named the eventual owner of 38% of bounced issues. A month later, on the summer held-out period, it named 13%. Who passes what to whom changes within weeks. To me that's the strongest argument for a graph that keeps learning online over a classifier trained once.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;One thing memory sees that the bot doesn't.&lt;/strong&gt; When an engineer forwarded their last three issues in a row, the bot's next pick for them was right only 3 times out of 12. They were usually away. The graph notices that streak; the bot keeps assigning to them. It's rare (under 1% of issues), but it's exactly the kind of judgement that only a memory of past behaviour makes possible.&lt;/p&gt;

&lt;h2&gt;
  
  
  Smaller findings (identified after the results, so treat them as descriptive)
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;The agent's top three suggestions contain the eventual owner 81% / 69% of the time, against 77% / 62% for the classifier's single pick. That's useful if a human triager picks from suggestions.&lt;/li&gt;
&lt;li&gt;When the agent asks for a human, the classifier's pick really is more likely wrong: 36% / 47% of the time, against 23% / 38% overall. "I'm not sure" turns out to be a useful bounce-risk signal.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What I learned
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Measure the context layer against the same agent without it. Comparing against a production system made my project look like a loss; comparing against the same AI without memory showed what the graph actually does. Report both.&lt;/li&gt;
&lt;li&gt;Time is the hard part of agent memory. Every leak I found came from the future sneaking in: labels added later, handoffs recorded after routing. Timestamps on edges, plus a &lt;code&gt;$t&lt;/code&gt; filter in every query, fixed it.&lt;/li&gt;
&lt;li&gt;Let the model judge, and let the graph traverse. Jev is good at one narrow question ("does this issue look like what this person kept?") and weak at multi-hop reasoning and dates. The graph does the hops; code does the dates; the model does one judgement per candidate.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;In the browser:&lt;/strong&gt; &lt;a href="https://handoff-graph.up.railway.app" rel="noopener noreferrer"&gt;https://handoff-graph.up.railway.app&lt;/a&gt;. Route a real VS Code issue live, explore the handoff memory, or step through the recorded held-out decisions.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;From Claude Code:&lt;/strong&gt; &lt;code&gt;claude mcp add --transport http handoff-graph https://handoff-graph.up.railway.app/mcp&lt;/code&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reproduce the numbers:&lt;/strong&gt; the repo includes the recorded held-out results and the cached decision-model answers. After fetching the public issue data, &lt;code&gt;--offline&lt;/code&gt; re-runs the replay without an API key.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;What I'd do next is change the job, not the model. Instead of competing with the bot on the first guess, the router would step in only after an issue sits untouched with its assignee for a few hours, as a second triager. That's where memory of who actually takes what should matter most.&lt;/p&gt;

&lt;h2&gt;
  
  
  AI disclosure
&lt;/h2&gt;

&lt;p&gt;I built this solo with Claude Code as a coding assistant. The design, data model, evaluation protocol and results are mine to explain and defend. Engineers are pseudonymised in this post; the live demo shows public GitHub handles because the routing paths cite public issues.&lt;/p&gt;

</description>
      <category>graphhacks</category>
      <category>falkordb</category>
      <category>wemakedevs</category>
      <category>ai</category>
    </item>
  </channel>
</rss>
