Coder Legion - Recent posts tagged hackathon

️ CymbalMart Shopping Agent: Intelligent Event Planning & Budget Curation

Fri, 18 Sep 2026 09:44:43 +0000

This is a submission for the MLH x DEV Writing Challenge ✨

"Transforming chaotic party preparation into an effortless, intelligent, and real-time budgeting experience."

Introduction & Inspiration

Planning events can often feel stressful, chaotic, and hard to budget. Whether you are organizing a corporate team-building event, a children's birthday party, or an outdoor wedding, keeping track of guest counts, item inventories, and expenses usually ends up in a messy, overwhelming spreadsheet. ❌

Why Build CymbalMart?

Traditional event planners force users to manually hunt for items, calculate bulk quantities, and manually adjust expenses row-by-row when things change. I wanted to design an application that acts like a proactive co-pilot—taking natural language prompts, instantly structuring inventories, mapping items to store aisles, and recalculating the total budget dynamically.

To solve this, I built the CymbalMart Shopping Agent ✨—an intelligent, interactive party planning and shopping assistant designed to convert event requirements into curated, budget-conscious shopping lists with real-time adjustments and voice integration.

Core Features Overview

Feature Name	Description	Impact
Smart Event Curation	Instantly generates tailored shopping lists based on party type, theme, guest count, and budget constraints.	Eliminates manual planning guesswork and speeds up initial setup.
Interactive AI Assistant	Features a built-in conversational chat interface (`CymbalMart Assistant`) for on-the-fly modifications.	Allows natural, human-like adjustments during the planning phase.
Dynamic Budget Recalculation	Automatically updates and recalculates total expenses and item quantities in real time.	Keeps event planners strictly within their target budget thresholds.
Hands-Free Voice Control	Integrated voice command capabilities to navigate menus and add items without touching a keyboard.	Offers accessibility and seamless multi-tasking while planning.

Demo & Application Showcase

Here is a visual walkthrough of how the application modules are structured, designed, and executed:

1. CymbalMart Shopping Agent Dashboard

The central hub where users initiate event curation, theme configuration, and guest count parameters.

2. Interactive Shopping Mart Views

Browse through curated store inventories and item selections tailored specifically to your event theme.

And

3. Dynamic Shopping Lists & Budget Tracking

Automatically updates expenses, quantities, and item availability in real time as modifications are made.

Organizes items by store aisles and resource categories to make physical or online shopping seamless.

5. Batch Recipes & Curation

Bundle recipes and ingredients efficiently for food and beverage planning.

6. Hands-Free Voice Control

Navigate menus, add items, and adjust parameters entirely hands-free using integrated voice commands.

7. Event Planning Timeline

Keep track of milestone tasks leading up to the event date to ensure nothing gets missed.

Explore the Codebase: You can check out the full source code, component architecture, and documentation directly on the Cymbal Shopping Agent

️ Tech Stack & Architecture Deep Dive

To build a fast, responsive, and intelligent agent interface, I utilized a modern, robust tech stack engineered for high performance and smooth client-side reactivity.

⚙️ Technology Stack Breakdown

Layer / Component	Technology Used ️	Implementation Details ⚙️
Frontend Architecture	`React`, `TypeScript`, `Tailwind CSS`	Ensures a modular, component-driven UI with responsive design systems and custom interactive modals.
AI & Agent Integration	LLM Agent Frameworks, Natural Language Prompts	Powers the conversational assistant to parse loose user text and map it to structured inventory arrays.
State Management	React State hooks & TypeScript interfaces	Handles asynchronous budget recalculations instantly whenever quantities shift or items are added.

Architectural Patterns Used

Component-Driven Modular Design: The app is broken down into clean, isolated components (components/ directory) handling specific concerns like modals, chat drawers, dynamic list grids, and timeline trackers.
Deterministic State Derivation: Instead of storing duplicate calculated values (like total aggregate costs), the state relies on immutable array reducers that compute subtotals, taxes, and quantity tiers on the fly.

Working with these technologies taught me a lot about synchronizing complex state management with natural language processing pipelines, ensuring that the user experience remains lightning-fast and error-free. ⚡

Engineering Challenges & Solutions

Building an agentic shopping assistant from scratch came with unique design hurdles. Here is how I tackled them:

Challenge Faced	Solution Implemented ️
Real-Time Budget Sync	Used deeply typed TypeScript state management to listen for quantity modifications and instantly trigger recalculation hooks without lag.
Natural Language Parsing	Configured context-aware prompt templates that map unstructured user prompts into clean item and category objects.
Responsive UI Layouts	Implemented Tailwind CSS grid systems to ensure clean presentation across mobile, tablet, and desktop viewports.

Overcoming State Propagation Latency

When users interact with the CymbalMart Assistant to alter guest quantities (e.g., jumping from 20 to 50 guests), updating every dependent recipe ingredient and store aisle subtotal simultaneously could cause UI stutter. To fix this, I implemented optimized React state hooks that batch updates and memoize expensive lookup arrays using custom calculation helpers.

Future Enhancements & Roadmap

To take the CymbalMart Shopping Agent to the next level, here are a few exciting features planned for future updates:

Future Milestone	Objective & Description
Multi-Store Price Comparison	Integrate live retail APIs to compare item prices across different local supermarkets automatically.
Collaborative Shared Rooms	Enable real-time multi-user editing so families or event planning teams can manage lists simultaneously via WebSockets.
Export to PDF & Calendar	Allow users to download formal itemized budget sheets and export milestone reminders straight to Google Calendar.

Hackathon Experience

Building the CymbalMart Shopping Agent was an intense and deeply rewarding journey! Bringing an agentic AI application from a rough concept into a fully functional, interactive web app pushed me to refine my skills in React state management and UI/UX design.

The biggest highlight was successfully integrating the hands-free voice control and watching the dynamic budget recalculate instantly when interacting with the AI assistant. It really highlighted how powerful modern web technologies and AI agents can be when combined to solve everyday friction points.

Thanks for reading! If you have any feedback, questions, or want to collaborate on agentic web applications, drop a comment below. Don't forget to leave a ❤️ and share this post! ✨

Building KOS: A Journey Through Zero Dependencies (And the Bugs That Taught Me Everything)

Tue, 08 Sep 2026 12:13:13 +0000

I didn't set out to reject go get. I just wanted to build something clean. But somewhere between the first snapshot corruption and the fourth complete rewrite, I realized: zero dependencies wasn't a constraint. It was a feature.

This is the real story of KOS—what I built, what broke, why I fixed it the way I did, and how you can use it yourself.

What is KOS?

KOS is a portable, encrypted version control system. It's not trying to replace Git. It's trying to be something Git isn't:

Single file: Everything lives in one main.go (~2000 lines)
Zero dependencies: 100% Go standard library
Encrypted: AES-256-CFB with HMAC-SHA256 integrity
Portable: Runs from a USB stick, no installation
Simple: kos init → kos save "message" → kos view

It stores your project snapshots in a global vault (~/.kos-global/) indexed by UUID. No Git databases. No complex merge logic. Just snapshots and timelines.

Getting Started: How to Use KOS

Installation

git clone https://github.com/kosmoscpp/kos
cd kos
make install  # Linux/Mac
# or: build.bat  # Windows

That's it. One binary. No dependencies to install. You can even compile it on a machine without Go and ship the binary to another machine.

Basic Workflow

Initialize a project:

kos init
# ✓ Initialized empty KOS repository in /home/user/.kos-global/abc123...
# Project UUID: abc123-def456-ghi789-...

Create snapshots:

kos save "Initial commit"
kos save "Added authentication"
kos save "Fixed bug in auth flow"

View your timeline:

kos view

Output:

╔══════════════════════════════════════════════════════════╗
║                     KOS TIMELINE                         ║
╚══════════════════════════════════════════════════════════╝

  ● abc1e2f1 ┃ Jan 08, 14:32 (just now) ┃ Fixed bug in auth flow
  │           ┃  42 files
  │
  ● a2d3f4b5 ┃ Jan 08, 14:15 (15 mins ago) ┃ Added authentication
  │           ┃  41 files
  │
  ● 8c7e9a0b ┃ Jan 08, 12:00 (2 hours ago) ┃ Initial commit
  │           ┃  40 files
  └── (End of history)

Compare snapshots:

kos diff abc1e2f1 a2d3f4b5
# Shows: + Added (0), ~ Modified (2), - Deleted (0)

kos diff abc1e2f1 a2d3f4b5 auth.go
# Shows line-by-line diff for auth.go

Tag releases:

kos tag v1.0
kos tag stable abc1e2f1  # Tag a specific snapshot

Restore your work:

kos checkout abc1e2f1                    # Restore entire snapshot
kos checkout abc1e2f1 src/main.go        # Restore single file
kos checkout v1.0                        # Restore by tag
kos checkout HEAD~3                      # Go back 3 commits

Encrypted snapshots:

kos save --encrypt "Secret credentials"
# Password: ****
# Confirm: ****
# 🔐 Saved encrypted snapshot: Secret credentials (15 files)

kos share abc1e2f1  # Export as snap_abc1e2f1.tar.gz.enc
# Can email/USB/cloud this file. Recipient loads with:
kos load snap_abc1e2f1.tar.gz.enc
# Password: ****

Project management:

kos projects           # List all projects in global store
kos rename "my-blog"   # Rename current project
kos stats              # Show project statistics
kos search "refactor"  # Search commit messages

The Bugs (And Why They Matter)

This is where it gets real. Because building from scratch means building through everything.

Bug #1: HEAD Recognition Fails (The Identity Crisis)

Early on, I implemented KOS to share and diff by snapshot ID. Simple, right?

kos share HEAD        # Error: Snapshot 'HEAD' not found
kos diff v1.0 v1.1   # Error: Snapshot 'v1.0' not found

Only raw IDs like 18d03947 worked. Tags and HEAD references were rejected.

The root cause: I wrote separate lookup functions that did direct ID matching instead of using a reference resolver:

// WRONG: Direct lookup, doesn't handle special refs
func findSnapshot(id string) *Snapshot {
    for i := range manifest.Snapshots {
        if manifest.Snapshots[i].ID == id {
            return &manifest.Snapshots[i]
        }
    }
    return nil
}

The fix: I extracted reference resolution into a single function that handles all cases:

// CORRECT: Handles IDs, tags, HEAD, and HEAD~N
func resolveRef(ref string) *Snapshot {
    snaps := manifest.Snapshots
    if ref == "HEAD" {
        return &snaps[len(snaps)-1]
    }
    if strings.HasPrefix(ref, "HEAD~") {
        parts := strings.Split(ref, "~")
        var offset int
        fmt.Sscanf(parts[1], "%d", &offset)
        idx := len(snaps) - 1 - offset
        if idx >= 0 && idx < len(snaps) {
            return &snaps[idx]
        }
    }
    for i := range snaps {
        if snaps[i].ID == ref || snaps[i].Tag == ref {
            return &snaps[i]
        }
    }
    return nil
}

Now every command uses resolveRef(). Git-like references work everywhere.

What I learned: Centralize your logic. Don't repeat the same lookup in ten places. You'll catch edge cases faster and users won't hit weird state machines.

Bug #2: Encryption Produces Garbage (The Defer Nightmare)

Encrypted snapshots were completely corrupted. Trying to load them:

Error: unexpected EOF when trying to decrypt

I was encrypting an incomplete file.

The root cause: In cmdSave(), I used defer for everything:

// WRONG: Defer happens at function exit, but we encrypt before that!
file, err := os.Create(filepathTar)
defer file.Close()

gzw := gzip.NewWriter(file)
defer gzw.Close()

tw := tar.NewWriter(gzw)
defer tw.Close()

// ... add files to tar ...

if encrypt {
    encryptFile(filepathTar, encPath, password)  // File still open!
    // Defer hasn't run yet. File is incomplete. We're encrypting garbage.
}

The file was still being written when I tried to encrypt it. The tar writer hadn't flushed. The gzip writer hadn't compressed. The file wasn't closed.

The fix: Explicit close order before encryption:

// CORRECT: Close in dependency order before encryption
tw.Close()      // Tar closes first
gzw.Close()     // Gzip flushes compression
file.Close()    // File closes last

if encrypt {
    encryptFile(filepathTar, encPath, password)  // Now it's complete
}

This was a painful lesson in writer layering. Each writer depends on the one below it. You have to close from the top down.

What I learned: Don't let defer fool you into false security. When you have layered resources (writer → compressor → file), you need explicit, ordered cleanup. defer is great for simple cases. For complex ones, be explicit.

Bug #3: Encrypted Load Shows Zero Commits (The Skip Logic Backfire)

When loading encrypted snapshots:

kos load snap_abc123.tar.gz.enc
# ✓ Loaded encrypted project successfully!
# Commits: 0  ← WRONG! Should be 5

All the commits disappeared.

The root cause: The extract function had smart logic to skip .kos/ metadata when extracting:

// This is correct for normal use
if strings.HasPrefix(header.Name, ".kos/") {
    continue  // Skip metadata files
}

But the encrypted load code needed to read .kos/manifest.json to show how many commits existed. Since it was being skipped, the manifest was empty.

The fix: Use a different extraction function for encrypted loads that doesn't skip:

// extractFileFromTar reads directly from tar without skip logic
manifestContent, err := extractFileFromTar(decryptedPath, ".kos/manifest.json")
json.Unmarshal([]byte(manifestContent), &embeddedManifest)

Now encrypted snapshots preserve their full history.

What I learned: When you have branching logic (normal extract vs. encrypted load), they need different paths. Don't let one code path's assumptions break another's.

Bug #4: Password Masking Without x/term (The Syscall Journey)

I wanted masked password input (asterisks instead of plaintext). The easy way: golang.org/x/term. But that breaks zero dependencies.

So I went low-level. POSIX syscalls. SYS_IOCTL. Terminal state manipulation.

func readPassword() string {
    fd := int(os.Stdin.Fd())
    oldState, err := getTerminalState(fd)
    if err != nil {
        // Fallback if we can't control terminal
        var password string
        fmt.Scanln(&password)
        return password
    }
    
    newState := oldState
    newState.Lflag &^= syscall.ECHO  // Disable echo
    setTerminalState(fd, newState)
    defer setTerminalState(fd, oldState)
    
    var password []byte
    buf := make([]byte, 1)
    for {
        n, err := os.Stdin.Read(buf)
        if err != nil || n == 0 || buf[0] == '\n' {
            break
        }
        if buf[0] == 127 || buf[0] == 8 {  // Backspace
            if len(password) > 0 {
                password = password[:len(password)-1]
                fmt.Print("\b \b")  // Visual backspace
            }
        } else {
            password = append(password, buf[0])
            fmt.Print("*")
        }
    }
    return string(password)
}

func getTerminalState(fd int) (syscall.Termios, error) {
    var state syscall.Termios
    _, _, errno := syscall.Syscall6(
        syscall.SYS_IOCTL,
        uintptr(fd),
        uintptr(syscall.TCGETS),
        uintptr(unsafe.Pointer(&state)),
        0, 0, 0,
    )
    if errno != 0 {
        return state, errno
    }
    return state, nil
}

The tricky part: One wrong flag bit and users see their passwords on screen. The POSIX terminal model is finicky. This code works on Linux. Windows POSIX layer might have issues (but that's acceptable for a hackathon).

What I learned: Sometimes the "easy" dependency exists for a reason. But understanding the low-level mechanism? That's worth more than convenience. Now I know how terminal echo works. I know what TCGETS and TCSETS do. I know the bitfield layout of Termios.

Bug #5: The PBKDF2 Myth (And Correcting a Senior Engineer)

During review, someone asked: "Why SHA256 for key derivation instead of PBKDF2?"

They said: "It's in the standard library."

It's not.

crypto/pbkdf2 doesn't exist in stdlib. It's in golang.org/x/crypto, which is external. I had to correct them.

// This is what I use (stdlib)
func deriveKey(password string) []byte {
    hash := sha256.Sum256([]byte(password))
    return hash[:]
}

Felt weird correcting a senior engineer, but I was right. I triple-checked. go doc crypto/pbkdf2 returns nothing.

The choice: SHA256 is fast. PBKDF2 is slower (which is good for passwords—more resistant to brute force). But for a hackathon tool, the trade-off is acceptable. And it keeps zero dependencies.

What I learned: Don't assume. Don't trust memory. Actually verify what's in the standard library. And sometimes you do know things that others don't.

Bug #6: Ghost Projects In ~/.kos-global/ (The Cleanup Problem)

After months of testing:

ls ~/.kos-global/
abc123-def456-...
import-test-1
import-test-2
my-awesome-project-v1
my-awesome-project-v2
test-uuid-alpha
test-uuid-beta
... fifteen more orphaned directories

Each test run created new UUIDs. Each UUID got added to projects.json. But I never deleted old ones.

The root cause: During testing, I created projects, then deleted them locally, but their entries in projects.json remained. Then their directories stayed in the global store, orphaned and forgotten.

The fix: Had to manually:

rm -rf ~/.kos-global/test-uuid-*
rm -rf ~/.kos-global/import-test-*
vim ~/.kos-global/projects.json  # Remove orphaned entries

Then rebuild the index.

What I learned: Testing creates state. State accumulates. You need cleanup procedures or eventual garbage collection. In production, KOS should have a kos gc (garbage collect) command to clean up orphaned projects.

The Real Lessons

1. Writer Layering Matters

Gzip writes to a tar writer. The tar writer writes to a file. You have to close them in order: tar → gzip → file. Not all at once with defer.

2. Centralize Reference Resolution

Don't lookup snapshots in ten places. Do it in one place (resolveRef). Now HEAD works everywhere. Tags work everywhere. No weird edge cases.

3. Skip Logic Can Break Assumptions

Your extract function skips .kos/ files? That's correct for normal use. But encrypted loads need them. Different paths for different use cases.

4. Syscalls Teach You Real Things

Using golang.org/x/term is easy. Using syscall.Syscall6 with TCGETS is harder. But now I understand terminal echo at the OS level. That knowledge sticks.

5. Test State Accumulates

Build testing cleanup into your workflow. Delete projects between tests. Clean up projects.json. Otherwise you end up with fifteen ghost projects.

Why Zero Dependencies Was Worth It

I could have used:

github.com/urfave/cli for CLI parsing
golang.org/x/term for password masking
github.com/fatih/color for colors
github.com/google/uuid for UUIDs
github.com/sergi/go-diff for diffs

Each would have saved time on that specific feature. But:

I wouldn't have understood how any of them work
The binary would be much larger
The attack surface (for a security tool!) would be huge
I wouldn't have learned anything
Deployment would be more complex

Instead, I built a 4.2 MB binary that runs anywhere. I understand every line. I can audit it myself. I can deploy it to air-gapped networks. I can ship it on a USB stick.

How to Try It

# Clone and build
git clone https://github.com/kosmoscpp/kos
cd kos
go build -o kos .

# Initialize a project
mkdir my-project
cd my-project
../kos init

# Save some work
echo "Hello, KOS" > readme.md
../kos save "Initial commit"

# See the timeline
../kos view

# Make a change
echo "Hello, KOS with updates!" > readme.md
../kos save "Updated readme"

# View timeline again
../kos view

# Check what changed
../kos diff <snapshot-id-1> <snapshot-id-2>

# Restore a version
../kos checkout <snapshot-id>
cat readme.md  # Back to original

The Takeaway

Building KOS taught me that constraints aren't prison walls. They're focusing tools.

When I couldn't reach for go get, I had to understand my problems deeply. I had to learn about terminal I/O, writer layering, reference resolution, and encryption. I had to debug by understanding, not by reading someone else's code.

The result isn't just a tool. It's a tool I completely understand. It's a tool that's portable and secure. It's a tool that can run where nothing else can run.

That's worth the bugs. That's worth the deep dives. That's worth saying no to convenience.

Try KOS. Use it. Break it (please report issues). Learn from it.

And maybe, just maybe, build something with zero dependencies yourself. You'll be surprised what you learn when you can't go get your way out.

GitHub: kosmoscpp/kos

Quick Start:

git clone https://github.com/kosmoscpp/kos && cd kos && make install
kos init
kos save "My first snapshot"
kos view

That's it. No setup. No config. No dependencies. Just version control, zero friction.

Handles, Screen Names, and the Developer Identity

Mon, 07 Sep 2026 23:03:56 +0000

Before real‑name profiles and professional developer portfolios became standard, people chose usernames simply because they wanted something that sounded cool. Developers and aspiring hackers took this much more seriously. A handle was not just a login. It was a personal identifier that carried weight inside technical communities. Choosing the right name mattered, and many spent real time crafting something distinctive that reflected their style, their interests, or the image they wanted to project. In early coding and hacker culture, a handle became an essential part of one’s identity.

Although usernames eventually became common in gaming, that culture was separate from the world of developers and early internet hackers. In technical communities, a handle carried meaning. It represented experience, reputation, and continuity across different platforms. It was not created for entertainment or casual play. It was chosen with intention, and it became part of how others recognized you.

Notable Handles in Early Technical Culture

Among the earliest online communities, certain handles became recognizable far beyond the forums and bulletin boards where they first appeared. These names were not chosen for entertainment. They represented identity, reputation, and continuity in spaces where real names were rarely used.

Captain Crunch
John Draper adopted this handle after discovering that a toy whistle from a cereal box could manipulate telephone systems. His name became synonymous with early phreaking culture and remains one of the most widely recognized aliases from that era.

Phiber Optik
Mark Abene used this handle during his involvement in the hacker group Masters of Deception. His name appeared frequently in discussions about security, intrusion, and the ethics of early hacking communities.

The Mentor
Known for writing “The Hacker Manifesto,” The Mentor became a symbolic figure in early digital culture. His handle represented a philosophical voice within a community that was still defining itself.

Eric Bloodaxe
A prominent figure in the underground bulletin board scene, Eric Bloodaxe’s handle became associated with technical skill and leadership within early hacker networks.

These names were not accidental. They were crafted identities that carried meaning inside communities where reputation was built through contribution, insight, and technical ability.

Handles That Transitioned Into Professional Identity

As the internet matured, some developers continued using their handles even as their work became public and professional. These names evolved from aliases into recognizable signatures within open source and software development.

jwz
Jamie Zawinski used this handle across mailing lists and early Netscape development. It became a shorthand for his contributions to software and open source culture.

esr
Eric S. Raymond’s handle appeared frequently in discussions about open source philosophy and software engineering. It became part of his professional identity and is still used in technical circles.

geohot
George Hotz adopted this handle during his early work in hardware modification and security research. It later became a widely recognized name in both hacking and artificial intelligence communities.

moxie
Moxie Marlinspike used this handle throughout his work in cryptography and secure communication. It became a respected identity associated with expertise in privacy and security.

These names demonstrate how a handle can evolve from a simple alias into a lasting professional identity. In many cases, the handle became more recognizable than the person’s legal name.

The Influence of Fictional Handles

Although fictional handles introduced a dramatic and exaggerated version of hacker identity, they also helped shape how many people first imagined the idea of a digital persona. Real technical communities, however, built their identities through meaningful aliases that carried history, reputation and continuity. Whether a name came from early bulletin boards, open source mailing lists or professional development work, a handle often became a lasting part of a person’s presence in the technical world.

With that in mind, it is worth asking a simple question. What was a handle that you used or one that you still remember from those early days of the internet?

From 4,000+ Applications to 250 Builders: Building a Multi-Agent Video Pipeline at the Google DeepMind Bangalore Hackathon

Wed, 19 Aug 2026 06:27:37 +0000

TL;DR

Got selected out of 4,000+ applicants for the Google DeepMind Bangalore Hackathon 2026 (250 builders made it in). My teammate and I merged two hackathon tracks — Conversational Video & Motion with Omni Flash and Local-First Agents with Gemma 4 — into one pipeline: a multi-turn conversational video orchestration agent that asks clarifying questions and iteratively refines its output, backed by on-device reasoning for state management. No trophy this time, but a working prototype and a lot of lessons. Here's the build.

The selection

Google DeepMind and Cerebral Valley ran this hackathon in Bangalore, and the numbers alone made it feel different from the college-circuit events I'd been doing: 4,000+ applications, 250 seats. Getting the acceptance email didn't fully register until I was actually in the room — this wasn't a campus event anymore, it was a room full of people who build for a living.

The idea: merging two tracks instead of picking one

The hackathon offered several tracks. Two stood out to me and Rohan:

Conversational Video & Motion with Omni Flash — generate and iterate on video through natural conversation
Local-First Agents with Gemma 4 — on-device reasoning and autonomous decision-making

Instead of choosing one, we asked: what if the video generation system was the agent? So we built a pipeline where:

Gemini Omni Flash + NB2 Lite handle multi-turn conversational video orchestration — the system doesn't just take a prompt and spit out a video. It asks clarifying questions, holds context across turns, and iteratively refines the output based on what the user actually meant.
Gemma 4 runs on-device for state management and decision-making — tracking where the conversation is, what's already been generated, what still needs clarifying, and deciding the next action locally instead of round-tripping everything through a heavier model.

The result was an agent that blends reasoning, local intelligence, and multimodal generation into a single loop, rather than three separate systems bolted together.

What building under a deadline like this actually felt like

Tight deadlines are a hackathon constant, but the density of the room changes the pressure. Every table around us was shipping something legitimately interesting, which is equal parts motivating and intimidating. Having a partner who's good at both brainstorming and debugging (thanks, Rohan) mattered more here than in any hackathon I'd done before — there wasn't time to context-switch between "figuring out the architecture" and "fixing why the state manager is out of sync."

The outcome

We didn't place. No trophy this round. But we left with:

A working end-to-end prototype of the conversational video + local agent pipeline
Direct exposure to how a team like DeepMind's frames the "agentic + multimodal" problem space
Genuinely useful conversations with other builders working on adjacent problems
Insights from Amit Vadi and Ray Del Vecchio, who spoke at the event

Why I'm writing this up

Hackathons are noisy — you build for 24-48 hours, present, and the artifact usually dies in a GitHub repo somewhere. Writing it up is partly documentation for myself (what worked, what I'd do differently) and partly a way of tracking how the kind of problems I'm choosing to work on has shifted — from single-model chatbots to multi-agent, multimodal, local-first systems.

If you're building anything similar — conversational video generation, on-device agent state management, or just curious about how Omni Flash and Gemma 4 play together — I'd genuinely like to compare notes. Drop a comment or find me on GitHub.

This is part of an ongoing hackathon log — you can find the earlier entries (including two first-place wins and a near-miss with a legal-aid kiosk built on a multi-agent swarm) on my blog.

🐾 Cat Guardian — Protect. Identify. Find.

Mon, 17 Aug 2026 15:12:42 +0000

I live with seven cats: Kiara, Golia, Meias, Vaquinha, Tigrinha, Peluda, and Gamora.

They all have different personalities, different appearances, and different routines.

And, like many pet owners, there is one thing that has always worried me:

What if one of them gets lost?

That question became the starting point for Cat Guardian.

What I Built

Cat Guardian is a privacy-first digital safety passport for cats.

The idea is simple: give each cat a digital identity containing the information that could actually help if they ever go missing.

The platform provides:

🐈 Digital identity for each cat
🩺 Health records and vaccination tracking
🧠 AI-assisted visual identification
🏷️ Dynamic QR collar tags
🚨 Lost Mode
📱 Public rescue passport
🔐 Privacy-preserving contact between finder and owner
🌎 English and Brazilian Portuguese localization

The problem

When a pet goes missing, useful information is often scattered across photos, veterinary records, paper documents, and the owner's memory.

Traditional collar tags can also expose personal information such as phone numbers or addresses.

I wanted a different approach.

The QR code attached to the collar doesn't expose the owner's contact information.

Instead, when someone finds the cat, they can scan the QR code and access a public rescue profile.

If the owner has activated Lost Mode, the finder can submit a sighting.

The owner is then notified through a secure backend relay.

Owner
  │
  ▼
Cat Guardian
  │
  ├── Digital Identity
  ├── Health Records
  ├── AI Profile
  └── QR Collar Tag
          │
          ▼
      Lost Mode
          │
          ▼
     Finder scans QR
          │
          ▼
    Public Rescue Card
          │
          ▼
     Submit Sighting
          │
          ▼
       Owner notified

The goal isn't to replace GPS trackers or microchips.

It is to make the information surrounding a lost pet available, structured, and safer to share.

Why AI?

I didn't want to add AI simply because this was an AI-related challenge.

I wanted to use it where it could provide practical value.

Gemini is used to analyze visual characteristics such as coat patterns, eye color, and distinctive markings and generate a structured identification profile.

The application also provides informational preventive wellness guidance, while explicitly keeping medical diagnosis and treatment outside its scope.

AI-generated profiles are also localized according to the user's language.

Demo

🌐 Open the Live Demo →

The application includes a Demo Mode, so you can explore the main experience without creating an account.

The demo contains my seven cats:

Kiara · Golia · Meias · Vaquinha · Tigrinha · Peluda · Gamora

Try the Lost & Found flow with the demo data and explore how a finder would interact with a cat's public rescue passport.

Key flows

1. Register a cat

Create a digital identity and add health information.

2. Generate a QR collar tag

The QR code points to the cat's public safety passport.

3. Activate Lost Mode

The owner can mark the cat as missing.

4. Finder scans the QR code

The finder sees the relevant rescue information without seeing the owner's private contact details.

5. Submit a sighting

The finder can send information about where and when the cat was seen.

6. Owner receives the notification

The backend relays the sighting to the owner through Resend.

Code

💻 GitHub Repository →

The project is open source and built with:

React 19
Vite 6
TypeScript
Supabase PostgreSQL
Supabase Auth
Row Level Security
Gemini
Ollama
Mistral 7B
OpenCoder 8B
Resend
i18next / react-i18next
Vitest
React Testing Library
ESLint

How I Built It

This project was also an experiment in AI-assisted software engineering.

I used my own AI Software Engineering Framework 2.0 to orchestrate the development process.

The goal was not simply to ask an LLM to generate the application.

Instead, I treated AI agents as specialized members of an engineering workflow.

Human Supervisor
       │
       ▼
Chief of Staff
       │
       ▼
   Risk Router
    /   |   \
   ▼    ▼    ▼
Mistral OpenCoder Gemini
   \    |    /
    \   |   /
      Jidoka
         │
         ▼
   Human Approval
         │
         ▼
       Merge

Risk-based agent routing

Simple and low-risk tasks were delegated to local models running through Ollama.

🟢 Mistral 7B

Used for tasks such as:

documentation
simple UI changes
repetitive work

🟡 OpenCoder 8B

Used for:

CRUD
forms
implementation tasks

🔴 Gemini

Used for higher-risk tasks such as:

authentication
Row Level Security
AI integrations
architectural decisions

This allowed me to keep the more capable model focused on tasks where it provided the most value.

Jidoka Quality Gate

Every implementation had to pass a validation pipeline:

Lint
  ↓
Typecheck
  ↓
Tests
  ↓
Build
  ↓
Human Approval

If a validation step failed, the workflow stopped instead of allowing the problem to propagate.

This follows the Jidoka / Andon Cord principle from my framework:

When an anomaly is detected, stop the process and fix it before continuing.

The final release candidate passed:

Gate	Result
ESLint	✅ PASS
TypeScript	✅ PASS
Vitest	✅ 21/21 PASS
Production Build	✅ PASS

Privacy-first architecture

The public rescue passport deliberately does not expose:

owner's email
phone number
physical address

The finder communicates through a backend relay.

Sightings are persisted in PostgreSQL and the owner is notified through the Resend API.

This creates a simple separation:

Finder
  │
  ▼
Public Rescue Passport
  │
  ▼
Sighting
  │
  ▼
Backend
  ├── PostgreSQL
  └── Resend
          │
          ▼
        Owner

The finder can help without gaining direct access to the owner's private contact information.

Internationalization

English is the default language, with Brazilian Portuguese as a secondary locale.

I also wanted AI-generated information to respect localization.

The localized AI profiles are stored in PostgreSQL using JSONB:

{
  "en": {
    "description": "...",
    "personality": "..."
  },
  "pt-BR": {
    "description": "...",
    "personality": "..."
  }
}

This keeps the cat's identity data together while allowing the presentation to adapt to the user's language.

Design System

The application uses a custom Midnight Guardian design system.

The visual language combines:

Midnight Navy
Lavender
Emerald
Amber
Coral

The goal was to make the application feel like a safety product rather than a generic pet CRUD application.

🔐 Privacy & Safety

Privacy was treated as a product requirement rather than an afterthought.

The public QR page is intentionally limited to information that can help identify and recover the cat.

Owner PII is not rendered publicly.

The system also does not attempt to provide veterinary diagnosis.

Cat Guardian provides informational preventive wellness guidance and does not replace professional veterinary advice.

🚧 Current Limitations

Cat Guardian is a hackathon prototype.

It does not currently provide:

real-time GPS tracking;
GPS collar hardware integration;
veterinary diagnosis;
guaranteed pet recovery.

These could be explored in future versions.

For this challenge, I intentionally focused on the digital identity, QR-based rescue flow, privacy-preserving communication, and AI-assisted identification.

🎯 What I Learned

The biggest challenge wasn't building the features.

It was deciding what not to build.

It would have been easy to add GPS, maps, mobile applications, IoT devices, blockchain, push notifications, and many other features.

But the core idea was much simpler:

Give a cat a digital identity that can help protect, identify, and reunite them with their owner.

Everything else had to support that idea.

And the project became much stronger because of that constraint.

🐾 Built for seven cats

Cat Guardian started with a very personal question:

What information would I want to have if one of my cats disappeared tomorrow?

I would want their photo.

Their identifying characteristics.

Their health information.

Their vaccination history.

Their microchip information.

And, most importantly:

I would want the person who found them to have a safe way to contact me.

That's Cat Guardian.

Built for:

Kiara · Golia · Meias · Vaquinha · Tigrinha · Peluda · Gamora

🐾

Prize Categories

I'm submitting Cat Guardian for:

🏆 Best Use of Google AI

Gemini is used meaningfully in the application for:

AI-assisted visual identification profiles
feline characteristic analysis
preventive wellness assistance
localized AI-generated content

Google AI is also used as the high-risk agent in the AI-assisted engineering workflow.

🔗 Links

🌐 Live Demo

💻 GitHub Repository

My First Global Hackathon: What I Learned Building Moonsu Link

Sat, 04 Jul 2026 02:55:05 +0000

This was my first global hackathon, with 500+ participants from around the world, and although I didn’t win, I’m honestly proud of how much I learned from the experience.

I worked on Moonsu Link, a project I care about deeply. It wasn’t just about building something technical. It was about trying to solve a real problem and pushing an unfinished idea all the way into something more complete, more usable, and more meaningful.

Like many hackathon projects, Moonsu Link came with its own challenges. There were moments of uncertainty, moments where the product needed more structure, and moments where it would have been easy to slow down or stop. But I kept going because I believed the idea was worth finishing.

The Power of Collaboration & Community

What made this experience special was the teamwork. Building with others, sharing ideas, dividing responsibilities, and trying to keep the momentum alive taught me a lot about collaboration. A hackathon is not just about code. It is also about communication, trust, iteration, and resilience.@alchemycodes @yvesdylane

I also learned that progress matters, even when the final result is not a win. Finishing something, improving it, and learning through the process can be just as valuable as a prize.

One of the things I’m happy about is that I received a badge from the DEVPost community. That recognition means a lot to me because it reflects the effort, growth, and persistence behind the project.

Key Takeaways

This hackathon reminded me that:

First attempts are still valuable – Every expert was once a beginner. Starting is half the battle.
Teamwork makes a huge difference – Bouncing ideas off others and distributing tasks accelerates growth.
Challenges are part of the process – Friction and bugs are inevitable; navigating them builds engineering maturity.
Not winning does not mean losing – The knowledge and connections gained are permanent assets.
Learning and finishing count – Shipping a complete product cycle is a victory in itself.

Moving Forward

Moonsu Link may not have taken the top prize, but it gave me something important: experience, confidence, and a stronger mindset for the next challenge.

I’m grateful for the opportunity, grateful for the people I worked with, and grateful that I chose not to give up.

Have you ever participated in a global hackathon? What was your biggest takeaway from your first dev challenge? Let's connect in the comments below!

What If Your Repository Could Explain Itself?

Mon, 22 Jun 2026 13:02:34 +0000

🚀 Built: GitLab Knowledge Navigator

Over the last week, I've been building GitLab Knowledge Navigator for the GitLab AI Hackathon 2026.

The idea started from a common developer problem:

You join a project, open an issue, and suddenly need to understand years of architecture decisions, merge requests, dependencies, ownership history, and code relationships.

The information exists, but it's scattered everywhere.

GitLab Knowledge Navigator transforms GitLab Orbit's knowledge graph into actionable repository intelligence.

Demo Video:- https://youtu.be/xLBaZ2sFMEI

🔍 What it can do:

• New Contributor Onboarding
• Architecture Memory
• Decision Intelligence
• Change Impact Analysis
• Architecture Drift Detection
• Repository Risk Alerts
• Executive Engineering Reports
• Knowledge Graph Visualization
• Repository Intelligence Scoring

One of the most interesting capabilities is the ability to answer questions such as:

"Why does this dependency exist?"

Instead of giving a generic AI answer, Navigator traces real repository history through GitLab Orbit and explains when a technology was introduced, why it was added, and which merge request introduced it.

🏗 Technical Highlights

• GitLab Orbit API
• Orbit Local Graph (DuckDB)
• Gemini 2.5 Flash
• Python
• Knowledge Graph Traversal
• Multi-Repository Analysis
• Interactive HTML Dashboards

The project was validated not only on its own codebase but also on a fork of GitLab Runner containing:

✅ 1,366 files
✅ 9,314 definitions
✅ 58,340 indexed relationships

One of the biggest lessons from this project was that repository intelligence requires more than an LLM. The real value comes from combining AI with structured repository knowledge and software development lifecycle context.

From Code → Context → Decisions.

GitLab #GitLabOrbit #GitLabAIHackathon #DeveloperTools #SoftwareEngineering #AI #KnowledgeGraph #Python #OpenSource #DevTools #GenerativeAI

🏗️ CasePilot — India's AI Legal Case Worker

Mon, 08 Jun 2026 12:16:33 +0000

Most Indians facing landlord fraud, consumer scams, or workplace violations have no idea where to start. Legal fees cost more than the dispute is worth. CasePilot changes that.

What it does:
Describe your legal situation in plain language → 7 AI agents investigate your case → get a ready-to-send legal notice in minutes, for free.

The stack:
→ Google ADK — 7-agent pipeline (Intake → Law Research → Evidence → Strategy → Citation → Drafting → Memory)
→ MongoDB Atlas Vector Search — 3,310 chunks across 13 Indian laws, semantic search at 3,072 dims
→ MongoDB MCP Server — agents query Atlas via MCP protocol
→ Gemini 3.1 Flash-Lite — reasoning across all agents
→ Google Cloud Run — live public API
→ gemini-embedding-2 — document + law corpus embeddings

What makes it different from legal chatbots:
❌ Not: "Here's what Section 108 says"
✅ Yes: "Your landlord violated TPA S.108. Here's a pre-filled legal notice. Send it today. File consumer complaint in 15 days if no response."

Evidence uploaded → Justice Score calculated → action timeline built → case persists across sessions.

Live demo:

https://casepilot-34309631370.us-central1.run.app

Built solo for the Google Cloud Rapid Agent Hackathon — MongoDB track.

GitHub: github.com/ssurekumar01111-hue/casepilot

Lessons from a Kaggle Playground Competition

Sun, 07 Jun 2026 08:44:50 +0000

Just participated in this month's Kaggle Tabular Playground challenge focused on Stellar Classification

The goal was to classify astronomical objects into:

STAR
GALAXY
QSO (Quasar)

A few interesting findings from the exploration:

Redshift turned out to be one of the strongest predictive signals.
Color indices such as u-g, g-r, and r-i were often more informative than raw photometric measurements.
A simple ensemble of LightGBM, XGBoost, and CatBoost performed surprisingly well.
Despite a moderately imbalanced dataset (~65% Galaxy, ~20% QSO, ~14% Star), explicit class weighting actually reduced validation performance in my experiments.
Hyperparameter tuning with Optuna did not outperform a carefully engineered baseline model, reinforcing the importance of feature engineering and domain understanding.

To document the entire process, I created a beginner-friendly guided notebook covering:

• Dataset understanding
• Exploratory analysis
• Feature engineering
• Categorical encoding
• Stratified K-Fold validation
• LightGBM, XGBoost, and CatBoost
• Model ensembling
• Experimentation with class imbalance and hyperparameter tuning

If you're learning machine learning, working on tabular data, or interested in astronomy-related datasets, feel free to take a look.

I'm also happy to discuss alternative approaches, feature engineering ideas, or leaderboard strategies. Constructive feedback and questions are always welcome.

Notebook Link: Click Here

I Built an AI-Powered Agricultural Logistics Platform for Farmers Worldwide — Here's How

Mon, 01 Jun 2026 06:04:51 +0000

16% of agricultural produce globally is lost every year before it reaches the buyer. Not because the crops are bad. Because the supply chain is broken.
Farmers have no digital way to list surplus crops. Buyers can't discover what's available nearby. Drivers get no coordination layer. Everyone loses.
I built Micro-Harvest to fix all three — at the same time — using a single AI conversation.

What Is Micro-Harvest?
Micro-Harvest is a three-sided agricultural logistics platform built for the Google Cloud Rapid Agent Hackathon 2026 (Elastic Track). It connects:

Farmers (Growers) — who list surplus crops via an AI chat agent
Buyers (Producers) — who discover listings through smart geo-search
Drivers (Transporters) — who get auto-assigned hauls and handle delivery

One conversation from the farmer triggers the entire chain — AI reasoning, buyer matching, driver dispatch, and Stripe payment settlement. All automated.
Watch the full demo: https://youtu.be/0ZdplkglDBo

The Core Idea: One Message Does Everything
Here's what happens when a farmer speaks or types:

"I have 20 macro bins of Merlot ready to go today, asking $4000 per ton"

Under the hood, in under 30 seconds:

Gemini 3.1 Flash extracts → crop type, quantity, price, urgency
AI Reasoning Engine scores → urgency level, weather risk, vehicle recommendation
Elastic MCP (24 tools) → geo-matches nearest available buyer + transporter
FCM push notification → driver gets haul assignment
Driver completes → Gate 1 pickup + Gate 2 delivery confirmation
Stripe → 80% to farmer, 15% to driver, 5% platform fee. Same day.
No phone calls. No middlemen. No 3-day delays.

The Tech Stack-
AI Agent - Google Agent Platform, LLM - Gemini 3.1 Flash Lite Preview, Search - Elastic MCP — 24 tools, Backend - Firebase (Firestore, Auth, Cloud Functions) Payments - Stripe, Mobile - Flutter (3 Android apps) Admin - Flutter Web

The Elastic MCP server is the heart of the matching layer. It exposes 24 tools covering semantic crop search, geo-distance queries, transporter availability matching, index health monitoring, and BigQuery analytics. Every search the buyer runs fires a real geo-distance query against the listings index in real time — you can watch it in the Elastic search profiler.

The Feature I'm Most Proud Of: Offline-First Listing
Farmers often operate in areas with poor connectivity. Someone out in a field with no signal shouldn't lose their listing.
So I built the Harvest Agent to be offline-first:

Farmer speaks or types their crop details — no internet detected
App shows an offline badge and queues the message locally
The moment connectivity returns — listing syncs and goes live automatically
Zero farmer action needed

This was the hardest part to get right. The local queue needed to survive app restarts, handle partial sync failures, and not create duplicate listings on reconnect. It took more debugging than the entire AI integration.

Three Apps, One Platform
All three apps are built in Flutter and share the same Firebase project:
Farmer App (Grower)

Voice + text AI listing creation
Offline message queue with auto-sync
Real-time listing status tracking
Earnings dashboard

Buyer App (Producer)

Natural language surplus search
Geo-filtered results with radius control
Claim and reserve listings
Live transport tracking

Driver App (Transporter)

FCM haul notifications
GPS route guidance to farm
Gate 1 + Gate 2 photo capture
Instant payment on delivery confirmation

You can download and install all three APKs from the GitHub release and walk through the complete end-to-end flow yourself. APK links are in the Links section at the bottom.
(Enable "Install from unknown sources" in Android settings first)

What I'd Build Next
A few things I want to add after the hackathon:

Price intelligence — Gemini currently recommends a price band but doesn't pull live commodity market rates; integrating real-time agri pricing APIs would make this genuinely powerful
iOS builds — currently Android only; the Flutter code is cross-platform but Apple provisioning didn't make the deadline
Multi-language AI agent — supporting regional languages so the Harvest Agent works natively for farmers regardless of where they are in the world

Links
Demo Video
https://youtu.be/0ZdplkglDBo
Landing Page
https://micro-harvest-landing.web.app
️ Admin Panel
https://micro-harvest.web.app
GitHub
https://github.com/ssurekumar01111-hue/micro-harvest
Farmer APK
https://github.com/ssurekumar01111-hue/micro-harvest/releases/download/v1.0.0/grower-release.apk
Buyer APK
https://github.com/ssurekumar01111-hue/micro-harvest/releases/download/v1.0.0/producer-release.apk
Driver APK
https://github.com/ssurekumar01111-hue/micro-harvest/releases/download/v1.0.0/transporter-release.apk

Building this solo in Flutter + Firebase was genuinely fun — the Google Agent Platform + Elastic MCP combination is seriously powerful for this kind of multi-party matching problem. Happy to answer questions about any part of the architecture in the comments.

I Stopped Fixing Bugs Myself and Built an AI to Do It Instead

Sun, 03 May 2026 10:48:06 +0000

Every developer knows this pain. A bug gets filed and suddenly someone has to drop everything, read the issue, search through the codebase, figure out what broke, write a fix, add tests, open a PR and report back. It’s all manual work that takes time away from things that actually need a human brain. I kept asking myself one simple question, how much of this work can an agent handle on its own? That’s how BugFixer came about.

BugFixer is an AI agent that works inside GitLab using Claude. You file a bug report, assign BugFixer to the issue and walk away. The agent reads the issue, looks through the codebase, finds the problem, writes a fix with tests, opens a merge request and comments back explaining what it did. Nothing gets merged automatically, you still review and approve. BugFixer does the work, you make the final call.

In my demo, I filed a bug about passwords being stored as plain text in an authentication file. After assigning BugFixer, it found three vulnerable functions, replaced the plaintext storage with bcrypt hashing, wrote security tests and opened a merge request. It also spotted a session token vulnerability that I never mentioned. It found that on its own just by reading the code.

Building this wasn’t easy. The first problem was the YAML tool configuration. The documentation wasn’t clear, and small syntax changes caused confusing errors like “tool_name is missing” or “tool_name not expected.” I had to ask in the GitLab Discord community to figure it out. The second issue was permissions. Even with a Developer role, the agent could read files but couldn’t create commits or merge requests. Early runs were triggering but producing nothing, no commits, no MRs, no comments. Fixing that took days and was the biggest challenge.

Learn about Medium’s values
What I’m most proud of is that BugFixer fixed real bugs on its own. It worked on a Python calculator, a geospatial script I was working on at work and an authentication module with multiple security issues. Every run produced real fixes, real tests and real merge requests. But the best part was the session token issue it found on its own. I never asked for that. It just read the code and noticed the problem.

This project taught me how to build an AI agent from scratch on a platform I had never used before, how to write prompts that give an LLM enough context to make decisions, and how to debug using only session logs. It also showed me that building on a beta platform means hitting walls with little or no documentation. You just have to keep testing until something works.

Right now, BugFixer handles one bug at a time, but real teams deal with many issues at once. The next step is to run multiple agents in parallel and prioritize bugs by severity. I also want it to leave inline comments directly in the merge request not just a summary on the issue. Long term, the goal is for BugFixer to run the pipeline after fixing a bug, check if tests pass and only then open a merge request. The tools for that already exist, so it’s close.

BugFixer isn’t about replacing developers. It’s about removing repetitive work so people can focus on what really matters. If an agent can read bugs, fix code, and write tests, then maybe our time is better spent reviewing, designing, and solving harder problems.

Try it out: GitLab
YouTube: BugFixer - AI Agent that fixes bugs automatically in GitLab

Building Anzen: What I Learned About Token Vault the Hard Way

Sun, 03 May 2026 10:47:33 +0000

When I started building Anzen for the Authorised to Act hackathon, I thought Token Vault would be the easy part. I was wrong.

The concept is simple and powerful: instead of your AI agent holding OAuth tokens for GitHub, Gmail, and Slack, Auth0 holds them in a secure vault. The agent requests a scoped token when it needs one, uses it, and the token is gone. No credentials stored in your app. No breach risk. No all-or-nothing access.

The implementation is where it gets interesting. The first thing I discovered is that nextjs-auth0 v4 is a completely different SDK from v3. The familiar handleAuth function is gone. The middleware file convention changed. Environment variable names changed. Even the callback URL path changed from /api/auth/callback to /auth/callback. None of this was obvious from the documentation.

The second discovery was about the token exchange flow itself. Calling getAccessToken() returns an Auth0 JWT — not the GitHub or Slack token you actually need. To get the provider token, you have to make a separate POST to the token endpoint using grant_type: urn:ietf:params:oauth:grant-type:token-exchange with specific subject and requested token type parameters. This is the Token Vault exchange, and getting those parameters exactly right took significant debugging.

The third discovery was Groq compatibility. Zod schemas include a $schema meta-field in their JSON output that Groq's API rejects, causing silent "Failed to call a function" errors. The fix was switching from Zod to jsonSchema() from the AI SDK.

Despite these challenges, the architecture we ended up with is exactly what AI agents should look like: zero credentials in the app, scoped access per action, and a user who stays in control at every step. That's the promise of Token Vault, and it's worth the difficulty of getting there.

How Backboard.io Transformed My Multi-Agent AI System

Tue, 14 Apr 2026 12:56:36 +0000

I built Londoolink AI to help users stay on top of their day by generating personalized briefings from emails, calendar events, Notion pages, and social media.

It worked well and pulled together useful insights, but it had one major flaw.

It forgot everything.

Every time a user came back, it was like starting over. Preferences were lost, conversations had no context, and the experience felt repetitive. The system was smart, but it didn’t feel intelligent.

That changed when I integrated Backboard.io.

You can view the project here: https://londoolink-ai.vercel.app/

1. The Problem: No Memory

Before the integration, users had to:

Repeat their preferences every day
Re-explain what mattered to them
Ask the same follow-up questions again

Even though the system could analyze data well, it didn’t learn from users over time.

2. The Shift to a Stateful System

I first came across Backboard.io through an email after submitting my project to an Auth0 Hackathon on Devpost. The team had reached out, sharing more about the platform and how it enables AI systems to become stateful through persistent memory, threads, and tool-calling.

That sparked my curiosity, so I explored it further during MLH Global Hack Week: API, where I got to understand more about how it actually works in practice.

What stood out was simple but powerful:

Instead of building memory from scratch, Backboard provides it out of the box.

3. What Changed

Persistent Memory

Now, users can store preferences like:

Preferring meetings in the morning
Prioritizing certain emails

And the system remembers them.

Here’s a simplified version of how I store preferences:

This function saves a new piece of memory (like a user preference) for a specific assistant using Backboard’s API.

class BackboardService:
    def add_memory(self, assistant_id, content):
        response = requests.post(
            f"{self.base_url}/assistants/{assistant_id}/memories",
            headers=self.headers,
            json={"content": content}
        )
        return response.json()

Retrieving preferences:

This function searches stored memories and returns anything related to user preferences so the assistant can personalize responses.

def get_preferences(self, assistant_id):
    response = requests.post(
        f"{self.base_url}/assistants/{assistant_id}/memories/search",
        headers=self.headers,
        json={"query": "user preferences"}
    )
    return response.json().get("memories", [])

Better Document Retrieval

I moved from a local setup to a cloud-based system.

This function uploads documents (like notes or data sources) to the cloud so they can be retrieved and used by the AI system later.

def add_document(self, content, metadata):
    return requests.post(
        f"{self.base_url}/documents",
        headers=self.headers,
        json={
            "content": content,
            "metadata": metadata
        }
    )

This improved both scalability and search quality.

Threaded Conversations

Now users can ask follow-up questions with full context.

This function creates a conversation thread tied to a specific user so all messages stay connected.

def create_thread(self, user_id):
    response = requests.post(
        f"{self.base_url}/threads",
        headers=self.headers,
        json={"metadata": {"user_id": user_id}}
    )
    return response.json()["thread_id"]

Adding messages to a thread:

This appends a new message (from a user or an assistant) to an existing conversation thread to maintain context.

def add_message(self, thread_id, role, content):
    requests.post(
        f"{self.base_url}/threads/{thread_id}/messages",
        headers=self.headers,
        json={"role": role, "content": content}
    )

4. How It All Comes Together

In my main agent:

This is the full flow:

Get or create an assistant
Fetch stored user preferences
Generate a personalized briefing
Create a conversation thread for follow-ups

def create_briefing(self, user_id):
    assistant_id = self.get_or_create_assistant(user_id)

    preferences = self.get_preferences(assistant_id)

    briefing = self.generate_briefing(
        data_sources,
        user_preferences=preferences
    )

    thread_id = self.create_thread(user_id)

    return {
        "briefing": briefing,
        "thread_id": thread_id
    }

5. Challenges Along the Way

One issue I ran into was handling API responses.

The API sometimes returned 201 instead of 200, so I updated my handler:

if response.status_code in (200, 201):
    return response.json()

I also had to handle endpoint inconsistencies like /memory vs /memories, and made response parsing more flexible.

6. The Impact

Before Backboard	After Backboard
No memory	Remembers user preferences
Generic outputs	Personalized results
No conversation continuity	Context-aware conversations

7. Key Takeaways

Memory makes AI feel like an assistant, not just a tool
A simple service layer keeps integrations clean
Small API details matter more than you think

8. Shoutout

I learned more about Backboard.io during the ongoing MLH Global Hack Week: API Week 2026, a week-long online hackathon by Major League Hacking (MLH) focused on APIs, building, and learning through live sessions and community challenges.

Big shoutout to the MLH community and organizers for creating an environment where developers can explore tools like this while building real-world projects and learning by doing.

9. Final Thoughts

This integration changed my system from something that generates results into something that understands users over time.

If you’re building AI applications, adding memory is one of the most impactful upgrades you can make.

Hackathon Highlights: Building and Livestreaming an AI Travel Agent

Mon, 12 Jan 2026 19:38:02 +0000

In this week's article, we dive into a sponsored hackathon where we build an AI-powered travel agent app—competing, collaborating, livestreaming, and more! Follow along to learn real-world dev skills!

Hackathon AI Agent Challenge

To kick off 2026 and continue my self-taught developer journey, I’m once again joining Shashi Lo’s Gridiron Survivor team—an apprenticeship program that gives devs hands-on, pro-level experience. This time, we're taking on a hackathon challenge to build an AI agent!

The hackathon features two rival teams competing to develop an AI-powered travel agent app, sponsored by GitKraken, Frontend Mentor, and Zephyr Cloud. Up for grabs: a $1000 cash prize, one-year free memberships, and plenty of swag! This hackathon is underway now and will continue into February (and may extend if additional time is needed).

While it’s a contest, the real win for everyone is the shared learning experience, the sense of team camaraderie, and—my favorite—the chance to keep building an online presence.

On a personal note, I’m especially excited for this hackathon because my nephew David Terzano—fresh out of college with a degree in computer science and a passion for game development—is joining my team! This event gives David and all participants real-world team experience to help close the gap that new devs face when seeking their first roles. I can’t wait to see him jump in, learn with us, and bring fresh ideas to the project!

AI Agent, Travel Agent

The challenge is to build a travel agent app powered by a specialized AI agent that serves as the core of our hackathon project. A successful AI travel agent should efficiently integrate with multiple APIs to provide accurate travel information, automatically suggest itineraries, and personalize travel plans based on user preferences. Our desired outcome includes robust handling of user queries and consistent performance under various use-case scenarios.

Speed: Each team chooses its own tech stack, which enables efficient development and performance optimization to meet specific project demands.
Flexibility: Micro front-end architecture enables modular development, making it easier to update sections of the app independently.
Integration: API integrations are key to the app pulling real-time travel data and resources, ensuring accurate, timely information.
Intelligence: Custom AI models are used to analyze user data and preferences, providing personalized travel suggestions and enhancing the user’s experience.

These features and more highlight the complexity and potential of our AI travel agent app!

Livestream Presentations

To truly level up like the pros, team members will be hosting live presentations. Taking the floor to present, demo, and field questions is a valuable skill in itself, especially when navigating inevitable technical difficulties.

As a first step to engage with our journey, subscribe to the Coding with Shashi YouTube channel and turn on notifications to stay updated on all events. This ensures you won't miss any opportunities to follow along, ask questions, and provide feedback live.

In upcoming articles, I’ll take you behind the scenes of this hackathon, sharing our process, challenges, and key takeaways. You’ll be able to follow our journey step by step—from the initial setup and development to our results and lessons learned. Beyond building an AI agent, there’s a lot happening under the hood, and I can’t wait to cover it all!

Gridiron Survivor Sponsors

A very special thanks to our sponsors!

GitKraken: A popular Git client that provides a graphical interface to manage Git repositories. It is known for its user-friendly design and features that simplify version control, making it easier for developers to collaborate and manage their code.
Frontend Mentor: An online platform that offers front-end coding challenges. It helps developers improve their skills by providing real-world projects to work on and a supportive community for feedback and learning.
Zephyr Cloud: A Module Federation platform that accelerates micro-frontend development by providing instant deployment, intelligent dependency resolution, and seamless version management—all while remaining cloud agnostic, framework agnostic, and bundler agnostic.

Be sure to listen to the HTML All The Things Podcast!

I also write articles for the HTML All The Things Podcast, which you can read on their website: https://www.htmlallthethings.com/.

Be sure to check out HTML All The Things on socials!

I’m excited to announce that I’m now a Torc Ambassador! As part of this global community, I’ll be sharing valuable insights from Torc’s virtual events, lessons from my own tech journey, and real-world perspectives on how teams are hiring and working today. I’ll be active in the Torc community through posts, events, Q&A sessions, and more—so stay tuned for updates and opportunities to connect. Whether you’re looking to advance your tech career or simply stay informed, I hope the insights I share will support and inspire you on your journey!

Torc is an AI-powered platform and vibrant global network that connects skilled professionals with top opportunities and forward-thinking companies. If you’re interested in joining, you can create a free profile using my referral link: https://platform.torc.dev/#/r/b5QZ7k5h/cp

Affiliate & Discount Links!

With CodeMonkey, learning can be all fun and games! CodeMonkey transforms education into an engaging experience, enabling children to evolve from tech consumers to creators. Use CodeMonkey's FREE trial to unlock the incredible potential of young tech creators!

With a structured learning path tailored for various age groups, kids progress from block coding to more advanced topics like data science and artificial intelligence, using languages such as CoffeeScript and Python. The platform includes features for parents and teachers to track progress, making integrating coding into home and classroom settings easy.

Through fun games, hands-on projects, and community interaction, CodeMonkey helps young learners build teamwork skills and receive recognition for their achievements. It fosters a love for coding and prepares children for future career opportunities in an ever-evolving tech landscape.

To learn more about CodeMonkey, you can read my detailed review article!

Affiliate Links:

Advance your career with a 20% discount on Scrimba Pro using this affiliate link!

Become a hireable developer with Scrimba Pro! Discover a world of coding knowledge with full access to all courses, hands-on projects, and a vibrant community. You can read my article to learn more about my exceptional experiences with Scrimba and how it helps many become confident, well-prepared web developers!

***Important:* *This discount is for new accounts only. If a higher discount is currently available, it will be applied automatically.***

How to Claim Your Discount:

Click the link to explore the new Scrimba 2.0.
Create a new account.
Upgrade to Pro; the 20% discount will automatically apply.

Disclosure: This article contains affiliate links. I will earn a commission from any purchases made through these links at no extra cost to you. Your support helps me continue creating valuable content. Thank you!

Conclusion

A hackathon is a fantastic way to learn web development and build real team experience. This challenge lets us work with cutting-edge technologies and showcase how an AI agent is built from the ground up. Whether you’re a participant or following along, you’ll see how competition, collaboration, and livestreaming all come together—plus pick up valuable, in-demand skills!

We’ll take you behind the scenes as we choose our tech stack, tackle real-world problems, and share the tools and approaches we use. Watch our livestreams to see the action unfold, and join the conversation to connect, ask questions, and get involved. You’ll find inspiration, insights, and practical tips for your own projects.

Curious how it all comes together in real time? Follow our journey for updates, lessons learned, and strategies you can put to use in your own projects—so you gain real value as we build and learn together!

Let’s connect! I’m active on LinkedIn and Twitter.