<?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: neweraXX</title>
    <description>The latest articles on DEV Community by neweraXX (@neweraxx).</description>
    <link>https://dev.to/neweraxx</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%2F4215041%2Feac84072-2e9c-4692-bdf7-f4590938b8e7.png</url>
      <title>DEV Community: neweraXX</title>
      <link>https://dev.to/neweraxx</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/neweraxx"/>
    <language>en</language>
    <item>
      <title>Baton: Who Keeps the Promise When the Shift Ends?</title>
      <dc:creator>neweraXX</dc:creator>
      <pubDate>Sat, 07 Nov 2026 06:11:32 +0000</pubDate>
      <link>https://dev.to/neweraxx/baton-who-keeps-the-promise-when-the-shift-ends-55d5</link>
      <guid>https://dev.to/neweraxx/baton-who-keeps-the-promise-when-the-shift-ends-55d5</guid>
      <description>&lt;p&gt;“Shift’s over. Who keeps the promise to call the customer back?”&lt;/p&gt;

&lt;p&gt;That question is where Baton started.&lt;/p&gt;

&lt;p&gt;I come from support and solutions engineering, and I’m teaching myself to code. When I think about a handover, I think about the customer waiting for a call, the vendor still investigating, and the incoming colleague trying to work out what they have actually agreed to do.&lt;/p&gt;

&lt;p&gt;A conversation can contain all the facts and still leave responsibility unclear. “Seen” is an acknowledgement. A name in a summary is a suggestion. Neither tells me whether someone has accepted the callback at its latest promised time.&lt;/p&gt;

&lt;p&gt;For WeMakeDevs’ “Flip the Switch” hackathon, I built Baton around that gap. The demo cases are fictional; the operational question is the one I wanted to explore.&lt;/p&gt;

&lt;p&gt;Transparency note: I set the goals and made the key calls, such as when a claim counts as stale. AI coding agents (Claude Code and Codex) wrote most of the code and the first draft of this post, and reviewed each other’s work. The rules, tests and eval numbers below can be reproduced from the repository.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;LLM proposes, code enforces, humans own the promise.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Baton has three participants. &lt;code&gt;@baton&lt;/code&gt;, running through Claude Code, drafts a versioned handover ticket from the conversation. &lt;code&gt;@checker&lt;/code&gt;, running through Codex, reviews it against the conversation, shared procedures, and ledger replies. &lt;code&gt;@ledger&lt;/code&gt; is a custom Node.js agent with no LLM.&lt;/p&gt;

&lt;p&gt;The ledger records explicit claims. An incoming owner enters a command such as:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;@ledger claim SR-1077 v1
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It uses the sender name supplied by Switch rather than accepting a name written inside the command. Putting someone in the ticket’s &lt;code&gt;owner&lt;/code&gt; field does not create a claim.&lt;/p&gt;

&lt;p&gt;The distinction matters when a promise changes. In the English rehearsal, SR-1077 initially had a callback at 16:00. The incoming shift claimed it. The customer then moved the callback to 15:30.&lt;/p&gt;

&lt;p&gt;Once ledger accepted the updated ticket, the earlier claim became stale. The same owner had to claim again against v2. A change to another case, or to what the team was waiting for, would not invalidate that claim if its promise time stayed unchanged.&lt;/p&gt;

&lt;p&gt;Ledger also rejects new claims against older tickets, prevents a second person from claiming an already held case, and flags promises without valid claims when they are less than 30 minutes away. That urgency check happens when someone requests status.&lt;/p&gt;

&lt;p&gt;Switch provided the place where these participants could work together.&lt;/p&gt;

&lt;p&gt;The room holds the conversation. Room instructions describe roles, ticket formatting, and ownership rules. Room documents hold the SOP, escalation matrix, and current handover ticket. Baton updates that ticket document after ledger accepts the version; checker can read it without editing Baton's documents.&lt;/p&gt;

&lt;p&gt;The Discord bridge connects the staff channel to the Switch room. Through Switch’s custom agent protocol, my non-LLM ledger receives room events over WebSocket and sends replies and operations over HTTP.&lt;/p&gt;

&lt;p&gt;I also used &lt;code&gt;!invite-agent @checker&lt;/code&gt; to bring the reviewer into an ongoing handover. Once tagged, checker could read the existing history and documents without someone repeating the brief. That was a useful test: could a reviewer join late and still identify what had changed?&lt;/p&gt;

&lt;p&gt;Building this taught me several things that were less obvious than the architecture.&lt;/p&gt;

&lt;p&gt;The first was how easily formatting can become a business decision.&lt;/p&gt;

&lt;p&gt;An independent Codex review found that the original parser stopped at a blank line. Imagine a new ticket containing two cases, separated by an empty line. The parser could accept only the first case.&lt;/p&gt;

&lt;p&gt;That was dangerous because an accepted replacement ticket must contain every open case. Omitted cases become closed. A harmless-looking blank line could therefore close the second case accidentally.&lt;/p&gt;

&lt;p&gt;The revised specification explicitly skips blank lines and requires every other line inside the block to be valid. Malformed blocks apply nothing. For me, this connected a parser detail directly to the support workflow: stopping early could make unfinished work disappear.&lt;/p&gt;

&lt;p&gt;The second lesson came from disagreement between the AI tools.&lt;/p&gt;

&lt;p&gt;The instruction review initially recommended reflecting ownership changes in a new ticket version. A follow-up review withdrew that recommendation: ledger already stores ownership, and publishing another version just because someone claimed a case would create unnecessary R2 rejections for subsequent claims against the previous version.&lt;/p&gt;

&lt;p&gt;That exchange helped clarify the boundary. Ticket versions describe the handover facts; ledger records who has accepted them. The SOP also needed to respect that distinction, otherwise checker could keep asking for unnecessary versions.&lt;/p&gt;

&lt;p&gt;I learned to look for the consequence of a proposed instruction. “Keep everything updated” sounds reasonable until it causes another person’s valid next action to fail.&lt;/p&gt;

&lt;p&gt;The third lesson was that a rehearsal has its own timing problems.&lt;/p&gt;

&lt;p&gt;The English transcript contains a checker mention blocked by an addressing policy. Baton noticed and passed the reminder along. Later, checker produced a reminder saying claims still needed doing, even though the claim commands had already appeared.&lt;/p&gt;

&lt;p&gt;Both moments remain in the transcript. They show why an 18/18 checkpoint score needs context.&lt;/p&gt;

&lt;p&gt;The clock needs context too. Ledger supports a fake time for demonstrations, but that setting does not control the LLM agents’ clocks. For a live manual demo, the promises need to be in the future in UTC+7. The setup instructions also call for a fresh room and fresh ledger for another take, so previous rehearsal context does not become part of the next handover.&lt;/p&gt;

&lt;p&gt;The recorded results from 6 November 2026 give me evidence for some parts of Baton.&lt;/p&gt;

&lt;p&gt;The deterministic ledger evaluation passed &lt;strong&gt;18/18 scenarios, with 92 checks&lt;/strong&gt;. It supplied known-correct ticket blocks and exercised parsed commands against expected behavior. Thirteen scenarios tested violations covered by the ownership rules, and two tested clean handovers without false alarms.&lt;/p&gt;

&lt;p&gt;The mutation checks made that result more meaningful. Changing the urgency boundary from &lt;code&gt;&amp;lt; 30&lt;/code&gt; to &lt;code&gt;&amp;lt;= 30&lt;/code&gt; caused S12 to fail. Disabling stale-version rejection, changed-time handling, or duplicate-owner protection failed the corresponding scenarios. Removing the explicit-ownership rule failed eight scenarios.&lt;/p&gt;

&lt;p&gt;A separate English rehearsal passed &lt;strong&gt;18/18 checkpoints&lt;/strong&gt; using a real Switch room, Claude Code, Codex, and ledger, with two staff roles simulated by API agents. It demonstrated the callback change, renewed ownership, rejection of an old-version claim, completed handover, and a follow-up answer using 15:30.&lt;/p&gt;

&lt;p&gt;Those results have clear limits. Three ledger scenarios pass precisely because ledger behaves as specified while missing risks outside its rules: a changed contact channel, closure mentioned only in chat, and an owner lacking permission to perform the action. Checker’s detection rate for those risks has not been systematically measured. Neither has Baton's extraction accuracy across the scenario set.&lt;/p&gt;

&lt;p&gt;There are implementation limits too. Human-only claiming is currently an instruction-level restriction; ledger does not reject agent claimants, and the automated rehearsal relies on that. State lives in a local JSON file. There is no automatic reconnect or scheduled reminder loop, and promises across different days need manual review.&lt;/p&gt;

&lt;p&gt;I have not measured customer outcomes.&lt;/p&gt;

&lt;p&gt;What I have built is a small workflow where drafting, checking, and accepting responsibility are separate actions. Teaching myself to code through Baton meant learning to make those boundaries explicit—and finding the places where my own design blurred them.&lt;/p&gt;

&lt;p&gt;The question I want Baton to answer is simple: who accepted this promise, at this time?&lt;/p&gt;

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

&lt;p&gt;Explore the repository: &lt;a href="https://github.com/neweraXX/baton" rel="noopener noreferrer"&gt;https://github.com/neweraXX/baton&lt;/a&gt;&lt;/p&gt;

&lt;h1&gt;
  
  
  HowISwitch
&lt;/h1&gt;

</description>
      <category>howiswitch</category>
      <category>ai</category>
      <category>hackathon</category>
      <category>node</category>
    </item>
    <item>
      <title>Teaching a support bot who should fix it: closed tickets Walrus Memory one routing hint</title>
      <dc:creator>neweraXX</dc:creator>
      <pubDate>Thu, 29 Oct 2026 10:47:32 +0000</pubDate>
      <link>https://dev.to/neweraxx/teaching-a-support-bot-who-should-fix-it-closed-tickets-walrus-memory-one-routing-hint-1763</link>
      <guid>https://dev.to/neweraxx/teaching-a-support-bot-who-should-fix-it-closed-tickets-walrus-memory-one-routing-hint-1763</guid>
      <description>&lt;p&gt;&lt;em&gt;Built for Tatum × Walrus "Total Recall" — Smart Agents track.&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Demo: &lt;a href="https://total-recall-demo.vercel.app" rel="noopener noreferrer"&gt;https://total-recall-demo.vercel.app&lt;/a&gt; · Code: &lt;a href="https://github.com/neweraXX/walrus-l1-assistant" rel="noopener noreferrer"&gt;https://github.com/neweraXX/walrus-l1-assistant&lt;/a&gt; (branch &lt;code&gt;total-recall&lt;/code&gt;) · Video: &lt;a href="https://youtu.be/Q26YG0UkKdE" rel="noopener noreferrer"&gt;https://youtu.be/Q26YG0UkKdE&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

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




&lt;h2&gt;
  
  
  The question L1 asks every day
&lt;/h2&gt;

&lt;p&gt;I work on an L1 application-support team for a beverage distributor's sales-force apps. Field sales reps call or message us all day: an order won't sync, a device can't sign in, a promotion price looks wrong.&lt;/p&gt;

&lt;p&gt;"How do I fix this?" is often not the hard part. The hard part is &lt;strong&gt;"Should I handle this, send it to L2, or contact the vendor?"&lt;/strong&gt; Get it wrong and the ticket goes back and forth for a day while a sales rep can't take orders.&lt;/p&gt;

&lt;p&gt;That routing knowledge already exists in our closed tickets: who actually fixed the root cause, and for which kind of error. But nobody reads hundreds of closed tickets, and new teammates have to learn it all by trial and error.&lt;/p&gt;

&lt;p&gt;Since September our team has used a Zalo chatbot built on &lt;strong&gt;Walrus Memory&lt;/strong&gt; (my Walrus Sessions 8 entry). It answers from runbooks and remembers fixes teammates teach it. For Total Recall, I gave it a second job: &lt;strong&gt;learn escalation routes from closed tickets, keep them in Walrus Memory, and prove they are stored, using Tatum.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What changes for L1 (before → after)
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Without memory&lt;/th&gt;
&lt;th&gt;With memory&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;"Replacement phone can't approve MFA sign-in, who handles it?"&lt;/td&gt;
&lt;td&gt;Bot says L1 should try resetting it&lt;/td&gt;
&lt;td&gt;Bot routes it to the &lt;strong&gt;vendor&lt;/strong&gt; (Northwind Systems in the demo), plus one line: &lt;em&gt;"↪️ Similar past issues: usually routed to VENDOR Northwind Systems (4/4 tickets)."&lt;/em&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;A new error type shows up 3 times in a week&lt;/td&gt;
&lt;td&gt;Nobody notices the pattern&lt;/td&gt;
&lt;td&gt;The nightly learner creates a rule for that error type once it has enough evidence&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;A learned rule is wrong&lt;/td&gt;
&lt;td&gt;Wrong forever&lt;/td&gt;
&lt;td&gt;An admin sends &lt;code&gt;#sai C7&lt;/code&gt; and the rule is vetoed&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;L1 never sees blockchain.&lt;/strong&gt; They see one practical hint. Blobs, epochs and proofs are only visible to the admin.&lt;/p&gt;

&lt;h2&gt;
  
  
  How it works
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Closed tickets (read-only, ≤14 days, ≤30 per run)
   → scrub (phones, emails, internal codes removed)
   → LLM extracts: system, error type, root cause, who fixed it
   → learner groups by (system + error type), counts routes
   → rule written to Walrus Memory (namespace escalation:v2)
   → Tatum Sui gRPC confirms the blob is certified on Walrus
   → L1 asks a question → relevant rules recalled → routing hint
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;1. Learning, every evening at 18:00.&lt;/strong&gt; The bot reads recently closed tickets (read-only), strips personal data &lt;em&gt;before&lt;/em&gt; anything goes to the LLM, and extracts a structured record. Routes are counted per error type: &lt;code&gt;L1&lt;/code&gt;, &lt;code&gt;L2:&amp;lt;team&amp;gt;&lt;/code&gt;, or &lt;code&gt;VENDOR:&amp;lt;vendor&amp;gt;&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Rules have to earn trust.&lt;/strong&gt; A rule is only used when it has &lt;strong&gt;at least 2 tickets and at least 60% agreement&lt;/strong&gt;. One ticket is evidence, not a rule. Each error type is written to Walrus Memory only when something meaningful happens: it is new, its route changes, or it reaches 3/10/30/100 tickets. That keeps memory small and every write meaningful.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Admins veto, they don't approve.&lt;/strong&gt; My first version asked me to approve every proposed rule: 15 questions after one run. Nobody would keep up with that. Routes are already clear in closed tickets, so now the bot learns automatically and an admin only steps in when something is wrong: &lt;code&gt;#sai C3&lt;/code&gt; (veto), &lt;code&gt;#mo C3&lt;/code&gt; (re-open), &lt;code&gt;#C3 note&lt;/code&gt; (add context).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;4. Answering.&lt;/strong&gt; When L1 asks something, the bot recalls rules from Walrus Memory. It keeps only rules from the same system and within a relevance distance of 0.5. I measured this on the demo rules: correct rules sit at 0.37–0.41, wrong ones at ≥0.57. The hint has a 3-second budget, so the hint never slows down the answer.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where Tatum fits
&lt;/h2&gt;

&lt;p&gt;Walrus stores the memory; &lt;strong&gt;Tatum lets me check it from the outside&lt;/strong&gt;, through a Sui endpoint I don't have to run myself.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Proof per write.&lt;/strong&gt; After each memory write, the bot finds the matching Walrus blob object on Sui through Tatum and checks that it is &lt;strong&gt;certified&lt;/strong&gt;. The admin sees the object ID, transaction and end epoch. If the chain is slow, the status is &lt;em&gt;pending&lt;/em&gt; and it re-checks twice, two minutes apart.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Morning health report (07:30).&lt;/strong&gt; Wallet balance, number of memory blobs, uncertified blobs, and &lt;strong&gt;when memory expires&lt;/strong&gt;. Our memory is safe until about April 2027 (end epoch 55–57; Walrus is at epoch 42). The report keeps 5 blobs that are not bot memory separate, so they don't skew the date.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;gRPC, not JSON-RPC.&lt;/strong&gt; Midway through the build, Tatum's Sui JSON-RPC endpoint started returning 404: JSON-RPC was retired. I moved every chain call to &lt;strong&gt;Sui gRPC through Tatum&lt;/strong&gt; using &lt;code&gt;node:http2&lt;/code&gt; and the protobuf definitions in &lt;code&gt;@mysten/sui&lt;/code&gt;. The browser grpc-web transport didn't work with the gateway, but native HTTP/2 did. Finding a fresh blob means scanning the wallet's owned objects (about 31 pages), so results are cached for 60 seconds and requests are spaced to stay within the free plan's limits.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;To be clear about what this proves: &lt;strong&gt;a storage proof confirms the rule is stored, not that it is correct.&lt;/strong&gt; Correctness is measured separately, below.&lt;/p&gt;

&lt;h2&gt;
  
  
  Does memory actually help? Honest numbers
&lt;/h2&gt;

&lt;p&gt;Our team lead labeled &lt;strong&gt;38 real tickets&lt;/strong&gt; (16 L2, 10 vendor, 12 L1). They were closed 15–45 days ago, outside the learner's 14-day window, and excluded by ticket key as well. Every run uses the same model and prompt; only the recalled rules change.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Version&lt;/th&gt;
&lt;th&gt;Memory OFF&lt;/th&gt;
&lt;th&gt;Memory ON&lt;/th&gt;
&lt;th&gt;What happened&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;v1&lt;/td&gt;
&lt;td&gt;50.0%&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;36.8%&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Memory made it &lt;em&gt;worse&lt;/em&gt;. Every recalled rule was used, regardless of relevance, and most rules said "L1", so 14 of 16 L2 tickets got pulled to L1.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;v2&lt;/td&gt;
&lt;td&gt;52.6%&lt;/td&gt;
&lt;td&gt;52.6%&lt;/td&gt;
&lt;td&gt;Added a system + distance filter. My first threshold (0.35) was a guess, and it blocked every rule. Measuring real distances gave 0.5.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;now&lt;/td&gt;
&lt;td&gt;50.0%&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;55.3%&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;First positive result after fixing how incidents are counted (below).&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;The lesson: learn who fixed the root cause, not who closed the ticket.&lt;/strong&gt; After one learning run, a single error type had grabbed 25 of 30 tickets, all routed to L1. My first guess was that the LLM was over-merging categories. My team lead corrected me: it was a &lt;strong&gt;real outage&lt;/strong&gt;. A vendor-side 504 hit every user, the vendor fixed the root cause, and L1 closed 25 tickets one by one.&lt;/p&gt;

&lt;p&gt;So the learner was making two mistakes:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;It learned the route from &lt;strong&gt;who closed&lt;/strong&gt; each ticket (L1), not from &lt;strong&gt;where the root cause was fixed&lt;/strong&gt; (vendor).&lt;/li&gt;
&lt;li&gt;One incident cast &lt;strong&gt;25 votes&lt;/strong&gt; and produced a confident but wrong rule.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Now each ticket records a &lt;code&gt;rootRoute&lt;/code&gt;, and tickets from the same incident closed within 3 days count as &lt;strong&gt;one vote&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;With that change, memory went from 50.0% to 55.3% accuracy: &lt;strong&gt;2 more correct tickets out of 38&lt;/strong&gt;. For tickets that should be escalated, precision rose from 70.4% to 76.0% with the same recall. That is an early signal on a small set, not a broad claim, and LLM results vary between runs.&lt;/p&gt;

&lt;p&gt;The demo's "Measure" button runs the same OFF/ON comparison live on 10 new fictional tickets. My last run: OFF 6/10, ON 10/10. Those tickets are synthetic and nothing is prefilled, so treat it as a demonstration, not as the real-team number.&lt;/p&gt;

&lt;h2&gt;
  
  
  Privacy
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;The public demo, repo and video use &lt;strong&gt;fictional data only&lt;/strong&gt;: Sunrise Beverages, FieldGo, Northwind Systems.&lt;/li&gt;
&lt;li&gt;Real tickets, the labeled holdout and the production config never leave our server.&lt;/li&gt;
&lt;li&gt;Personal data is scrubbed before any LLM call.&lt;/li&gt;
&lt;li&gt;The ticket source is read-only.&lt;/li&gt;
&lt;li&gt;On-chain details are admin-only. The L1 group chat never shows blobs or wallets.&lt;/li&gt;
&lt;/ul&gt;

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

&lt;p&gt;&lt;strong&gt;Online:&lt;/strong&gt; &lt;a href="https://total-recall-demo.vercel.app" rel="noopener noreferrer"&gt;https://total-recall-demo.vercel.app&lt;/a&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Learned rules:&lt;/strong&gt; the six seeded rules (C1–C6) and their evidence.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ask L1:&lt;/strong&gt; ask the MFA question with Memory OFF, then ON.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Teach:&lt;/strong&gt; learn from one more closed demo ticket.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Admin proof:&lt;/strong&gt; see each rule's Walrus blob, verified via Tatum Sui gRPC, plus storage health.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Measure OFF vs ON&lt;/strong&gt; on 10 new fictional tickets.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;Locally:&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone &lt;span class="nt"&gt;-b&lt;/span&gt; total-recall https://github.com/neweraXX/walrus-l1-assistant
&lt;span class="nb"&gt;cd &lt;/span&gt;walrus-l1-assistant &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; npm &lt;span class="nb"&gt;install
cp &lt;/span&gt;demo/.env.example demo/.env.local   &lt;span class="c"&gt;# add your Gemini, MemWal and Tatum keys&lt;/span&gt;
npm run demo:seed &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; npm run demo:web   &lt;span class="c"&gt;# http://localhost:3010&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  What's next
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Re-measure on a larger, fresh holdout as more tickets close.&lt;/li&gt;
&lt;li&gt;Use the expiry date from the health report to renew memory blobs automatically, before they expire.&lt;/li&gt;
&lt;li&gt;Let the team see &lt;em&gt;why&lt;/em&gt; a hint was given: the 4 past tickets behind "4/4".&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Closed tickets were always full of knowledge. Walrus Memory lets the bot keep it, Tatum lets me prove it's still there, and L1 just gets one better sentence when it matters.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Built with Walrus Memory (MemWal) on mainnet, Tatum Sui gRPC, and Google Gemini.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;code&gt;#TotalRecall&lt;/code&gt; &lt;a class="mentioned-user" href="https://dev.to/tatum_io"&gt;@tatum_io&lt;/a&gt; @WalrusFoundation&lt;/p&gt;

</description>
      <category>ai</category>
      <category>web3</category>
      <category>chatbot</category>
      <category>walrus</category>
    </item>
  </channel>
</rss>
