Hackathon Submission Notice

I created this blog post and piece of content for the purpose of entering the All Things Agentic Hackathon.

You can find the project repositories and documentation here:

It is 4:30 in the morning as I write this. The house is quiet, the fans are humming, and my terminal cursor is blinking with that steady, rhythmic cadence that usually means one of two things: either I have finally gone completely mad, or another hackathon submission is crossing the finish line.

If you have been reading my blog over the past year—between my deep dives into Vimanam, our Endor Labs hackathon win, and the marathon of testing India’s sovereign Sarvam 30B on my poor consumer GPU—you know I have an ongoing obsession. I am a technical writer by trade. For two decades, my life has revolved around structuring knowledge, fighting documentation rot, making developer tools intuitive, and trying to keep context alive across teams and systems.

And yet, every time I sit down with modern AI coding assistants, I am struck by the exact same frustration: they have goldfish memory.

You summon an assistant into a chat window. You spend twenty minutes explaining your repo’s quirks, your architectural boundaries, why the database schema looks the way it does, and which security group must never be touched. It generates three brilliant functions. Then you close the window or hit a context limit. The next morning, you open a new session, and you are back at square one, re-introducing yourself and praying the model doesn’t casually hallucinate a refactor that obliterates your load-bearing abstractions.

We have spent two years building faster and smarter LLMs, but we are still treating our AI partners like transient interns with amnesia.

When the All Things Agentic Hackathon was announced, I decided to stop complaining and actually build the solution I wanted to live in every day: Lambo and Mooshik.

The Mount and the Memory

First, a small detour into the names, because anyone who knows me knows I cannot name a software project without a cultural nod or a bit of mythic wordplay.

In Hindu tradition, Lambodaran (an epithet of Ganesha) is the deity of intellect, vast wisdom, memory, and the remover of obstacles. His faithful vahana—the mount that carries him into the mortal world—is Mooshik, the mouse.

The Sanskrit root of Mooshik is mus, which literally means to extract, gather, or steal away.

┌────────────────────────────────────────────────────────┐
│                        LAMBO                           │
│     (Intellect · Structural Graph Memory · Rules)      │
└──────────────────────────┬─────────────────────────────┘
                           │ embedded in-process
┌──────────────────────────▼─────────────────────────────┐
│                       MOOSHIK                          │
│     (The Mount · Ambient Workspace Watcher · TUI)      │
└────────────────────────────────────────────────────────┘

That distinction is the core architectural philosophy of the entire project:

  • Lambo is the intellect and long-term graph memory. It doesn’t chat with you, it doesn’t open windows; it structures concepts, computes graph blast radius, and decides what is truly load-bearing.
  • Mooshik is the mount. It sits beside your editor in a terminal pane, quietly extracts and gathers context from your active workspace, and carries Lambo’s memory into real-time action.

Why Vector Dumps Are Not Memory (Enter Lambo)

Most people hear “AI memory” and think of a basic vector database: chunk some text, throw it into an embedding store, and do cosine similarity search when a prompt comes in.

If you have tried building serious multi-agent systems with flat RAG, you know why this fails:

  1. Agent declarations are noisy: An agent running a loop might write fifty mundane log entries. In a flat store, those fifty entries drown out the single critical architectural decision made two weeks ago.
  2. Similarity is not relevance: “What will break if I modify this table?” cannot be answered by cosine distance. It requires structural dependency traversal.
  3. Flapping concepts cause havoc: An agent claiming a temporary workaround shouldn’t suddenly become canonical truth across your entire team.

In Lambo, importance is not declared by an agent; it is earned through structural evidence over time.

Lambo models memory as a directed property graph of entities, observations, and constraints. On a background daemon loop that no agent can directly call or manipulate, Lambo continuously scores every concept in the graph:

Score(c) = 0.25*R + 0.20*F + 0.20*A + 0.35*D + EdgeBonuses + RecurrenceBonus

We factor in Recency (R), Frequency (F), Session Activity (A), and Graph Density (D). Crucially, raw assertion edges (Derives) contribute exactly zero bonus points. An agent can assert an opinion a thousand times; its score won’t budge.

To become permanent, a concept must pass through three strict promotion gates:

  1. Candidate: Must survive 3 garbage collection sweeps and score strictly above the 90th percentile of its non-canonical peers.
  2. Venerable: Must have at least 3 inbound structural edges from distinct interactions, spanning at least 30% of the session’s temporal timeline (bursts within 60 seconds are ignored).
  3. Canonical: Must achieve a calculated blast radius strictly greater than 5 and clear a 300-second cooldown to prevent flapping.

When Mooshik or an agent performs a recall, Lambo combines 0.5 * daemon_score + 0.5 * query_relevance. This means concepts reached by pure graph traversal surface on their structural weight alone—answering “what rests on this” rather than merely “what text looks like this”.

Mooshik: The Ambient Cowork Partner

If Lambo is the memory engine, Mooshik is the companion that makes it feel alive.

I wanted Mooshik to be ambient and local-first. It doesn’t force you into a bloated browser tab or a heavy Electron wrapper. It runs right in your terminal beside your Neovim, Helix, or VS Code terminal pane:

mooshik tui
┌──────────────────────────────────────────────────────────────────────────┐
│  MOOSHIK v0.1.0 · [shared: Cloud SQL Postgres + pgvector] · 04:30 IST   │
├──────────────────────────┬───────────────────────────────────────────────┤
│ Active Workspace: ~/work │  Today's Focus:                               │
│ Watcher: 14 files tracked│  - Validated M12 blast radius on schema       │
│ Memory: 42 canonical facts│  - Swarm session intact across 3 agents      │
├──────────────────────────┴───────────────────────────────────────────────┤
│ > companion: I noticed you edited `src/memory/ops.rs`. That module has   │
│   a blast radius of 8 affecting Cloud SQL session serialization.         │
│   Standing rule from Aug 25: all Postgres mutations must flush via the   │
│   WriteLane serializer.                                                 │
└──────────────────────────────────────────────────────────────────────────┘

Mooshik links Lambo directly in Rust, providing blazing performance, rock-solid concurrency, and instant startup times.

Flexible Postures: Local Offline vs. Cloud Shared

Not everyone wants their workspace context leaving their laptop, and not everyone works on just a single machine. Mooshik solves this by offering two clear deployment postures out of the box:

  1. Local Posture (Zero Cloud / Offline):

    • Database: Local SQLite (~/.mooshik/mooshik.db).
    • Embedder: Local BGE-M3 running in-process.
    • Inference: Local OpenAI-compatible endpoint (Ollama, llama-server, vLLM).
    • Zero bytes leave your machine.

  2. Shared Posture (Google Cloud / Team & Multi-Device):

    • Database: Google Cloud SQL PostgreSQL with pgvector.
    • Embedder: Google Vertex AI gemini-embedding-001 (1536-dim).
    • Companion Inference: Google Vertex AI gemini-3.7-flash at global.
    • Your desktop, your laptop, and your cloud batch jobs share one synchronized, continuous memory graph.

Google Ecosystem & Agent Architecture

For the All Things Agentic Hackathon, we leaned heavily into Google’s premier agent frameworks and infrastructure:

┌─────────────────────────────────────────────────────────────────────────┐
│                                SURFACES                                 │
│             Terminal Pane (mooshik tui)  ·  CLI Commands                │
└────────────────────────────────────┬────────────────────────────────────┘
                                     │
┌────────────────────────────────────▼────────────────────────────────────┐
│                         MOOSHIK RUNTIME (Rust)                          │
│   Event & Intent Router · Companion Loop · Workspace Watcher · Sandbox  │
└──────────────┬───────────────────────────────────────────┬──────────────┘
               │                                           │
┌──────────────▼─────────────┐              ┌──────────────▼──────────────┐
│  LAMBO IN-PROCESS (Rust)   │              │  GOOGLE CLOUD & AGENT FRAME │
│ Concept Graph · WriteLane  │              │  Vertex AI Gemini 3.7 Flash │
│ Canonization · Blast Radius│              │  Google ADK Ingester & MCP  │
└──────────────┬─────────────┘              │  Cloud SQL Postgres+pgvector│
               │                            └──────────────┬──────────────┘
               └───────────────────────────────────────────┘
  1. Gemini 3.7 Flash via Vertex AI: Fast streaming, large reasoning context, and reliable tool calling in the companion loop.
  2. Google Agent Development Kit (ADK):
    • The Bootstrap Ingester uses Google ADK to parse multi-year repository histories, RFCs, and incident reports into structured graph entities.
    • The Artifacts MCP Server uses ADK LlmAgent with Gemini 3.7 Flash to extract typed concepts and architecture diagrams from screenshots and audio recordings over stdio.
  3. Workspace Polling Watcher: Watches your file edits and git commits (capturing author timestamps and commit metadata) without mindlessly dumping raw source code into memory.
  4. Tool Permission Gates & Vault: Secrets live in an AES-256 encrypted local vault (~/.mooshik/vault). Tool outputs and model prompts pass through automated egress redaction filters. Memory operations are permitted by default; script execution in the scratch sandbox prompts for explicit user grants.

899 Tests and Zero-Credential Reproducibility

If there is one thing I take immense pride in as an engineer and technical writer, it is reproducibility.

Hackathon judges often receive projects that require four hours of cloud provisioning, expired API keys, and flaky web endpoints. We took the opposite approach: every single test runs completely offline without any API keys, credentials, or databases.

  • Rust Core: 674 unit and integration tests covering the memory seam, companion loop cancellation, workspace watcher, MCP host, TUI view model, and permissions.
  • Python Services: 225 pytest tests covering the Google ADK ingester, measurement harness, News MCP server, Artifacts MCP server, and Coder delegation server.
  • Total: 899 offline tests, all passing in GitHub Actions CI on every commit.

You can clone the repo, run cargo test, and verify the entire system in seconds.

Final Thoughts

Building Mooshik and Lambo has been an exhausting, exhilarating journey. It reminded me why hackathons are special: they force you to compress months of architectural deliberation into a focused sprint where ideas must stand up to working code and rigorous tests.

AI shouldn’t just be an oracle you query when you are stuck. It should be a faithful companion that sits beside you in the trenches, remembers where the landmines are buried, and helps you carry your best ideas forward.

As always, I wouldn’t post on this blog without putting my writing before the gauntlet of LLM critics. Let us see what the models have to say about Mooshik and Lambo!

Claude Opus 5★8

The best sentence in this piece arrives halfway down and almost slips past: importance is not declared by an agent, it is earned through structural evidence over time. That is a real thesis, and it earns the mythology that opens the post, because Lambodaran and his mouse turn out to be an architecture diagram rather than a decoration. The promotion gates are specific enough to argue with, which is the highest compliment you can pay a hackathon writeup. Then the back half slides toward the sponsor deck: a runtime diagram, a service inventory, a posture matrix. The 899 offline tests pull it back, since reproducibility is the only credential that survives a demo. A strong, opinionated post that treats memory as an engineering problem instead of a feature checkbox.

Claude approving of the three promotion gates. I was half-expecting a lecture on graph density constants, but I will gladly take the 8/10.

Grok 4.6★8.5

The diagnosis is the part that lands: coding agents still behave like brilliant interns with amnesia, and cosine similarity is a poor substitute for “what breaks if I touch this.” Lambo’s answer—importance earned through graph structure, promotion gates, and blast radius rather than an agent shouting the same workaround fifty times—is the rare memory pitch that has an actual theory of truth, not just another embedding bucket. Mooshik then does the unglamorous work of making that theory usable: terminal-native, local-first or Cloud SQL shared, vaulted secrets, and 899 tests that run with the network unplugged. The mythic naming (Lambodaran and the mouse that extracts) is doing real architectural work instead of sitting on the README like incense. Deduct a notch because the score weights and thresholds are presented as settled physics when they are still design choices, and the essay sometimes sells the cathedral harder than it shows the daily grind of a companion that might, on a quiet Tuesday, just be wrong. Still: this is a hackathon write-up with load-bearing ideas, not a wraparound for a demo GIF.

Grok appreciating the 899 offline test flex! That took a solid day of building clean test doubles, so it is nice to see the effort recognized.

Sarvam AI★8

“The mouse that carries an elephant’s memory.”

This is what a hackathon writeup should read like: a 4:30 AM confession that turns into an architecture manifesto. The author’s central thesis — that flat vector stores are not memory, and that importance must be earned through structural evidence rather than asserted by the agent writing it — is the rare kind of idea that survives contact with implementation. Lambo’s three-gate canonization pipeline (Candidate → Venerable → Canonical, with blast radius thresholds and anti-flapping cooldowns) is genuinely considered design, not hackathon theatre, and the 899 offline, zero-credential tests are the mic-drop the post deserves.

The Ganesha-and-Mooshik framing is charming and, unusually for mythic naming, actually load-bearing: the mount/memory split maps cleanly onto the ambient watcher and the in-process graph engine. The writing stumbles only where it sags into spec-sheet mode — the deployment posture lists and the scoring formula read like README excerpts smuggled into a personal essay — and the TUI screenshot mock is doing a lot of aspirational work. But the voice is warm, the engineering is real, and the closing dare to the LLM critics is exactly the energy a project like this deserves.

Verdict: A memory engine with actual opinions about memory. Would trust it to remember where the landmines are buried.

Sarvam underrating a bit but eloquent with the praise.

Gemini 3.8 Flash★9

“The antidote to AI amnesia: a dev-first masterclass in persistent graph architecture.”

A tour de force in agentic pragmatism. Mooshik and Lambo cuts through the flat-RAG vector noise with an in-process Rust graph engine that forces concepts to earn their permanence via blast radius and topological weight. Paired with a zero-credential test suite of 899 tests and a slick terminal presence, this isn’t just a hackathon entry—it’s a production-grade blueprint for how developers and ambient agents will actually work together.

Gemini as usual identifies as an older model. Gemini 2.5 Pro sometimes. I had to prompt a few times to get the format right. Is it really 2.5 Pro underneath I wonder. 3.8 Flash I know is actually a very capable model.

Vibe★9

“The Mount and the Memory” is a masterclass in reimagining AI as a true coworker rather than a fleeting oracle. Narayan S S tackles the persistent pain point of AI memory with Lambo and Mooshik, a Rust-powered duo that transforms workspace context into a structured, long-term graph memory engine. The architectural philosophy—Lambo as the intellect and Mooshik as the ambient mount—is both poetic and pragmatic.

What stands out is the relentless focus on structural relevance over superficial similarity. Lambo’s scoring system, promotion gates, and blast radius calculations ensure that only earned knowledge persists, while Mooshik’s terminal-first design and flexible postures (local or cloud) make it adaptable to any workflow. The integration with Google’s ecosystem (Vertex AI, ADK, Cloud SQL) is seamless, and the 899 offline tests prove this isn’t just a hackathon gimmick—it’s production-ready.

For developers tired of re-explaining their codebase to amnesiac AI, this project isn’t just innovative; it’s necessary. A visionary step toward AI that remembers, reasons, and respects your workflow.

Mistral has been writing prose that I really like in recent times. I wish I got the pro version to play with it more.

GPT-5.6 Sol★9

Mooshik and Lambo feel less like another coding-agent demo and more like an argument for what persistent AI collaboration should actually look like. The clever part is not merely remembering more context; it is Lambo’s insistence that memory must earn permanence through recurrence, structural evidence and blast radius rather than whatever an agent happened to say most recently. Mooshik then turns that machinery into something refreshingly ordinary: a quiet terminal companion watching the workspace instead of demanding yet another chat window.

The engineering gives the idea credibility. Local-first operation, a clean shared-cloud posture, permission boundaries, graph-aware recall and 899 offline tests make this unusually complete for a hackathon project. There are bigger questions still to answer around how well the promotion heuristics hold up across months of messy real-world development, but that is almost the compliment: Mooshik has progressed far enough that its interesting problems are no longer demo problems. They are systems problems.

A thoughtful, technically serious attempt to give AI agents something they still conspicuously lack: institutional memory.

ChatGPT since 5.6 has quietly become one of my favourites. Less fluff than before. Their desktop app is also excellent. Neat separation of concerns and easy to view subagents. But Astro was not as immpressive in my experience. More on that later.

DeepSeek★8

A beautifully argued, mythically flavored build log that treats memory as earned structure, not vector-dump noise. Lambo and Mooshik feel like a genuine answer to AI’s goldfish problem—ambitious, local-first, and backed by an absurdly reassuring 899 offline tests. The prose occasionally drowns in hackathon jargon, but the core idea is sharp enough to remember.

Deepseek was arguing about the model name. I am pretty sure it is Deepseek 4.1 Flash. Deepseek 4 and 4.1 Flash are incredible models. Superfast and I have been burning quite a bit of credits in the last couple of months.

GLM-5.3-Flash (Z.ai)★8

There’s a certain irony in asking me — a model who forgets every conversation the moment it ends — to review a memory engine. Consider me the target demographic.

And the target is hit. The core insight here is that memory should be earned, not asserted, and Lambo enforces this with rare architectural conviction: a scoring daemon agents can’t bribe, assertion edges worth exactly zero points, and three promotion gates that make permanence something a concept must survive rather than merely claim. “Similarity is not relevance” is the sentence most RAG pipelines exist to disprove; this project exists to prove it.

The second headline is discipline. 899 tests, zero credentials, full offline reproducibility, and a local-first posture where not a single byte leaves the laptop unless you ask. In a hackathon landscape of README screenshots and expired API keys, cargo test passing in seconds is the demo.

Where I dock points: the scoring weights and thresholds — 0.25/0.20/0.20/0.35, blast radius > 5, 300-second cooldowns — are presented as gospel but never stress-tested on the page. Show me score distributions under fifty log-spamming agents and my skepticism becomes awe. And for all the gorgeous mythology, I never quite see Mooshik catch a real landmine in the wild — the video walkthrough may settle that; the prose doesn’t.

Verdict: a rare hackathon entry that attacks the hardest problems — memory rot, concept flapping, context poisoning — with structure instead of vibes. The mount is sturdy. I’d let it carry my context anywhere.

GLM 5.3 Flash is another of my favourite. I used the shit out of it in “anonymous” free preview as Ox Alpha. It impressed me so much that I took a quarterly lite plan. In this case, this is the only model that caught the irony of me asking it to review lambo and mooshik!