c0mpiled_
← back to articles
hack·may 22, 2026·54 min read

gstack x gbrain Hackathon #1

by james tan2.0k reads

Overview

Reflections

Good

  • Running judging in parallel with pitches continues to work well! Everyone who wanted to present had the opportunity to, though it ran slightly late as a result.
  • Longer hackathon results in better relationships amongst peers and seems to strike a good middle ground between performance and brevity
  • Having a strong speaker with a clear vision that connect participants with the broader movement taking place is incredibly important and dramatically changes the color of the event. People were very motivated as a result.
  • The judges were all very strong and they understood the intention immediately. One key thing with hackathons is to ensure that your judges are opinionated and are empowered to voice their opinions. If not, the judging style doesn't work. Our judging system inherently requires conviction of the strength of a submission.

Bad

  • We will, moving forward, add a column for judging where judges can optionally leave feedback for participants that we can then provide
  • Way too much food! It was good because the food was light and high quality, but lots of folks were really locked into building.
  • We will have a slide, moving forward, reminding people about submission requirements and rubric. Generally speaking, we tell participants to treat the submission like a YC application and similarly we ask judges to review the submissions like a YC application. This question repeatedly comes up across the board.
  • Capacity! We will, in the future, explore multi-site hackathons to see how we can scale the system without breaking the event.

Observations

  • The best participants continue to do the following: They pressure test their ideas with peers and judges alike. They move aggressively in a specific direction. They build closely along with the prompts. They use this as an opportunity to sell or pitch product. We will include this in the future.
  • Much more activity than normal from the post-hackathon chat. People really excited about what others had built and eager to coordinate and team up after the fact.

Sponsors & Judges

Prizes & Recognition

1st Place: Sina Matian (Build your Phone) — stack iOS — Claude Code Skills for Live iPhone QA, Design Review, and Autonomous Bug Fixing gstack is an open-source skill framework for Claude Code.

2nd Place: LearningGraph — An adaptive self learning tool that visualizes topics on a graph, using Gbrain to dynamically adapt lessons to the user performance and preference. Using it allows the user to make their own knowledge base using Gbrain and visualize it using our graph.

3rd Place: GBody - Agentic Physical Intelligence — Bringing agents into the physical realm using a robotic arm, an MCP server, Claude, and GStack for self-optimization.

4th Place ($500 bonus): Hindsight — Hindsight is the active self-reflection layer GBrain doesn't have yet.

GBrain AI Award:

Jo Award: Lore.ai — First GBrain Social media

ZeroEntropy Award: Red Brain — RedBrain is an AI-native security system that helps enterprises and AI agents find and fix security problems in both their internal system applications and AI-generated code. Security tools are still disconnected.

LightSprint Award:

Transpose Award: OrderUp — OrderUp: One operating system for an independent restaurant. Independent restaurants stitch together 6-10 SaaS tools (Toast, Rippling, Homebase, Slack, Jolt, Cut & Dry) that don't talk to each other; the owner is the integration.

The Hog Award: Arvya Sales Closer — Arvya Closer is a Mac app that turns Outlook-native PE/IB deal teams into closers, built on top of GBrain.

Honorable Mention: Own Your Data — Track your own data as big companies do, just for yourself

Submissions by Side Quest

  • GBrain.io — 52 (59.8%)
  • The Hog — 27 (31.0%)
  • (none) — 20 (23.0%)
  • ZeroEntropy — 19 (21.8%)
  • Jo — 12 (13.8%)
  • LightSprint — 12 (13.8%)

Total submissions: 87. Many teams tagged multiple side quests, so percentages don't sum to 100%.

All Submissions

AgentDevStory (GBrain.io · Jo)#

  • Description: Agents are getting good enough to carry out tasks by themselves, especially with the release of features like /goals and tools like Symphony. While Kanban boards are a useful organization tool, we wanted to create something more interactive over this layer. Which is why we built AgentDevStory. AgentDevStory is inspired by the popular game Game Dev Story, and allows you to see your agents work in an interactive way.
  • Team: Kris Diallo, Moritz Schneider, David Chu
  • GitHub: https://github.com/bazumo/AgentDevStory
  • Video: https://screen.studio/share/2JABmEkb

AI Product Manager (literally) (GBrain.io · ZeroEntropy · Jo)#

AI/GBrain Enabled IOS Integration Tests (GBrain.io)#

  • Description: I have built an integration test suite for react native and ios applications in general. I face this problem at the startup that I work at where we have to test so many things and so many things fall through the crack. Automating tests are really good, but they are also difficult to configure once you have so many features or aspects of the product that you want to test. By using GBrain as the memory layer and using AI agents in the app and cli tools from apple to control the IOS simulator, I was able to automate the process of integration testing. It finds the flows that it needs to test on it's own using GBrain and then using AI agents and a nice TUI tool, users are able to check network calls, success/failures of different flows in the app, and all they have to do is install it through a single .sh script.
  • Team: Reeyan Khimani
  • GitHub: https://github.com/reeyank/yc-hackathon-integration-tests
  • Video: https://drive.google.com/drive/folders/1syQcHmNuSBLHVo7tosaL4qKPOAuGOlgU?usp=sharing

Alpaca (GBrain.io)#

  • Description: Alpaca is a native macOS AI coding IDE built for teams. The problem it solves: when several people work on one codebase, each running their own AI coding agent, those agents have no idea the others exist. They overwrite each other, repeat work, and break each other's conventions. For a team, that's chaos. Coordination is the missing piece. Alpaca's answer is a shared brain built on GBrain. A team can run multiple agents at once, each on a different model (Claude Opus, Claude Sonnet, and GPT 5.5, fully cross provider), each working its own task in parallel. The agents never message each other directly. Instead, every time an agent finishes a task, it writes what it learned, a project convention, into GBrain as a structured page with full provenance: which agent, which model, when. That shared brain is what lets a team's agents work together without colliding. Before any agent starts, it reads from GBrain and automatically inherits everything the team's earlier agents learned. It's an instant handoff with no standup and no Slack message. And because every agent's knowledge lives in one place in GBrain, Alpaca can compare across all of it and catch the moment two teammates' agents learn contradictory conventions, then surface both sides so a human can decide. The resolution is written back to GBrain, so every future agent inherits the settled decision instead of the conflict. GBrain is the shared memory layer underneath everything Alpaca does. A team's agents coordinate through it the same way human teammates coordinate through shared project knowledge, not by talking constantly, but by writing things down where everyone can see them.
  • Team: Ali Musayev
  • GitHub: https://github.com/MusayevAli/Alpaca
  • Video: https://youtu.be/_YvzLCNpAlg

Annotate (GBrain.io)#

  • Description: A single customer bug can take 10-15 manual steps and 6 engineering hours just to ship to production, because bug reports arrive without enough context to reproduce or fix them quickly. This costs engineer speed and time lost due to back and forth. We built an embedded widget way thats collect helpful report contexts like screenshots, browser logs, browser elements in one click, to provide an agent enough context to replicate the bug and have a production fix in minutes We used gbrain to get context about previous bugs and gstack for an automatic triage process
  • Team: bolaji agunbiade, Vishnu Karpuram
  • GitHub: https://github.com/ibrolord/lite-annotate
  • Video: https://youtu.be/l-wpli3qX8k

Arvya Sales Closer (GBrain.io · ZeroEntropy · The Hog) — The Hog Award#

  • Description: Arvya Closer is a Mac app that turns Outlook-native PE/IB deal teams into closers, built on top of GBrain. PE and investment banking deal teams live in DealCloud + Outlook, but buyer signals get lost across Excel trackers, stale CRM notes, old call transcripts, security docs, and prior decks. Arvya Closer gives every deal team one persistent sales brain and three execution lanes: 1. Ask Brain — multi-query hybrid search across our real Arvya corpus: call transcripts, product vision docs, security packets, and prior decks. It uses stopword-stripped search, named-entity fanout, and longest-token fallback so informal questions like “whats arvya vision” still hit the right documents. Answers stream ChatGPT-style and include grounded citations. 2. Live Coach Overlay — a translucent, draggable Electron overlay for live sales calls. The window uses NSWindowSharingNone, so it stays visible to the salesperson but is invisible to Zoom, Loom, Meet, and QuickTime screen capture. It captures mic audio with getUserMedia, transcribes through Groq Whisper, and fires deterministic coach cards in 50–90ms when known objections hit: DealCloud, SOC2, buyer tracker, stale CRM, or premature demo. For open-ended moments, it routes to Anthropic with retrieved GBrain context. Every card shows the GBrain slugs that backed it, and the demo cards use real prospect quotes mined from past transcripts. 3. Find People + Find Events — brain-first parallel fanout for instant context from past calls, plus The Hog /deep-research for fresh outside-world prospects, plus ZeroEntropy reranking against the brain’s real pain language. One sweep produces prospect lists with grounded outreach angles and conference targets with walk-the-floor pitches. Built in one day on top of GBrain, The Hog, ZeroEntropy, Groq, and Anthropic, using Electron, Vite, React 18, Bun, and strict TypeScript. The thesis: 13 of our last 15 demos stalled. The brain remembers why. Arvya turns that memory into the next move.
  • Team: Naveen Siva, Prashanth Babu
  • GitHub: https://github.com/Pbabu-Github/arvya-closer
  • Video: https://drive.google.com/drive/folders/1v9rZah-pJZZCS379A7UfAL5mc8e4CuLM?usp=sharing

b2b-aSaaSinator (GBrain.io)#

Babel (GBrain.io · LightSprint)#

  • Description: Babel: a deterministic pocket lawyer for mom-and-pop shops/small businesses. We deconstruct messy legal “babbling” into deterministic decision trees that GBrain can act on. Contracts are too dense for LLMs to reliably reason over as raw text, so we break them into Hohfeldian legal relationships, then convert those clauses into finite state machines, similar to smart contract generation. Each business ends up with deterministic contract FSMs, not LLM slop. When a user asks a question, we load their contract FSMs into GBrain as memory pages and fan out specialist agents across risk, operations, legal, IP, and finance. Each agent queries GBrain for context while validating every recommendation against the FSM’s actual states. A synthesizer agent then enforces what the FSMs actually allow, keeping the answer grounded in real, predictable truth. Finally, we write the new context back into GBrain, so the system learns from every question the business asks.
  • Team: Pranay Dogra, Vivan Doshi, Neel Kansara, Yuvraj Taneja
  • GitHub: https://github.com/neelsck/DDKT
  • Video: https://drive.google.com/drive/folders/1o4V8kIL8hsih9VO08cbcsckTWrqCbz--?usp=sharing

Brainiac#

  • Description: Brainiac is a learning partner you talk to while you work — to learn and document as you go. Pull up an article, a paper, or even a person (a LinkedIn or Twitter profile) and talk: what's on your mind, the questions you have, how it connects to what you already knew. Brainiac writes back the learnings — what the source covered and how you understood it — in your voice and vocabulary, so all of it lives in GBrain, ready when you open Claude Code to apply it.
  • Team: Keefe Ho
  • GitHub: https://github.com/kenken182/brainiac
  • Video: https://www.loom.com/share/0a4f695db81f4641a0a62c467c6e73f9

Burrow (GBrain.io · ZeroEntropy · The Hog · Jo)#

  • Description: Software has never been cheaper to build. A founder with Claude Code and a weekend can ship a real product. But distribution hasn't gotten cheaper, and now we have a strange new bottleneck: we can produce far more software than the public can evaluate. Good products die unheard while mediocre ones win on outreach. Existing "AI outreach" tools make this worse, shipping templated slop at industrial scale. Burrow is a fully AI-native growth team. Paste your URL. A researcher agent reads your site, confirms your product, customers, and voice, then ingests private docs (past wins, lost deals, brand guide) as your "brain." Burrow then hunts public signals where someone is openly complaining about a problem you solve, ranks them against your actual ICP, and drafts five personalized emails citing the specific past win that mirrors each prospect's situation. Under the hood, TheHog powers prospect discovery and deep research, surfacing buying signals and enriching candidates with real web intelligence. ZeroEntropy's zerank reranker sits on top of retrieval over your private corpus, so the customer story that actually mirrors each prospect surfaces first, in your voice, with one concrete ask.
  • Team: Kabir Grewal, Rishyendra Medamanuri
  • GitHub: https://github.com/grewalsk/burrow
  • Video: https://youtu.be/rRzlKOlxhso

BYOA#

  • Description: BYOA (Bring Your Own Agent) — a runtime + contract for agent-native apps. The pitch: today every "AI app" bolts a chatbot onto a SaaS sidebar. BYOA inverts that. Apps become small, capability-shaped, and expose their tools over MCP (Model Context Protocol). The user's agent — any agent — composes them on the user's behalf. Composition happens at the agent layer with zero app-to-app coupling. Built tonight: a runtime on a single-node k3s cluster plus two reference apps that prove the contract generalizes. • gustus — a recipe app. Postgres-backed, full web UI, agent-callable over MCP. Save a recipe by typing two words or uploading a screenshot; the agent extracts the rest. • pantry — a kitchen inventory app. ~300 LOC TypeScript, live two-column web UI (shopping / pantry), agent-callable over MCP. Items flow shopping → mark purchased → pantry. The killer demo composes them: "What can I cook with what's in my pantry?" → agent calls pantry.list_pantry, gustus.list_recipes, gustus.get_recipe(shakshuka), identifies gaps. "Add the missing ones to my shopping list." → agent populates shopping column live. "I bought everything." → items migrate to pantry column. "Can I make it now?" → same question, different answer, because the agent walked state across two apps that don't know about each other. Stack: Node + Fastify + MCP + Postgres (gustus) / JSON-on-disk (pantry) + k3s + cert-manager + Tailscale (perimeter) + Hermes (the agent runtime, by Nous Research) + Anthropic Claude. Five-thing contract every app implements: MCP endpoint at /mcp · bearer auth via MCP_BEARERS · a SKILL.md agent manifest · k8s Deployment + Service with pod label mcp-skill: "true" · default-deny NetworkPolicy + explicit ingress from the agent's namespace. No SDK, no framework, ~30 min to bootstrap a new app. What's next (all natural extensions of what's running, none require rearchitecting): sign-in-with-Claude / GitHub / Google for identity, per-channel app routing, app store + install primitive, scoped capability tokens, audit log, billing.
  • Team: Franklin Bagherzadeh
  • GitHub: https://github.com/franklad/byoa
  • Video: https://www.loom.com/share/d42a021aa0bf45c9a25d6877747e0751

C0llegeN00b (ZeroEntropy · The Hog)#

Cad-Coder (ZeroEntropy)#

CanaryBrain (GBrain.io)#

  • Description: CanaryBrain is an open-source pre-production safety net for backend code — the kind that touches money, ranking, fraud, billing, or allocation. Five layers (Diff Risk Score, Record-Replay-Compare, ServiceLab statistical regression, Bisect, Canary rollout) plug into your company's brain of past incidents and catch behavior changes that code review + tests miss. Built on the Meta DRS methodology (Abreu et al. 2024). V0 ships today, Apache-2.0.
  • Team: Dave Petrovikj
  • GitHub: https://github.com/agentordinary/canarybrain
  • Video: https://www.loom.com/share/bebda7f7cd114626a5593455e924ee86

**Collab Brain ** (GBrain.io)#

Compass (GBrain.io · The Hog)#

  • Description: Compass is an autonomous AI assistant for small-business owners who manage their key customers personally. Five specialized agents — Money, Pulse, Promise, Triage, World — continuously watch every customer relationship, ground their reasoning in a typed memory graph, and DM the owner on Telegram with what needs them today.
  • Team: Rajashekar V
  • GitHub: https://github.com/rajashekarcs2023/brainstack-G
  • Video: https://youtu.be/_sfE6GuMHAM

Conamur (GBrain.io) — GBrain AI Award (tied)#

  • Description: Independent retail loses billions a year to one thing: the second phone line. The owner's at the counter with a customer, the phone rings, It goes to voicemail. The order's gone with it. Six hours ago, the fix didn't exist. This morning we built it on gstack and gbrain -end-to-end, zero to live. Conamur the voice agent that answers in your voice, remembers every caller forever, and runs the follow-up on your phone. SMS, calendar event, prep alarm, Maps directions to the venue. No dashboard. No second screen. The shop we wired up today is Maria's Flowers in Brooklyn. Mid-build, a caller said 'no lilies - allergy: The agent threaded it into his existing order, drafted five follow-up tasks, and pushed them straight to the owner's Android, complete all the task in a flow like a teammate. A hired receptionist costs forty grand a year and still forgets customers. Ours never does and scales to a thousand shops without hiring one more. Built today. Live now.
  • Team: Alice Xu, Steven Gao, Zhen Dong
  • GitHub: https://github.com/agentconamur/conamur-os
  • Video: https://oncall-shop.vercel.app/

Cortex (GBrain.io · ZeroEntropy) — GBrain AI Award (tied)#

  • Description: We built Duolingo for junior radiologists, powered by GStack and Zero Entropy. Cortex tracks junior radiologists' mistakes under different circumstances and dynamically suggests new cases, identifying bad patterns and offering useful feedback along the way. We validated our idea by speaking to real doctors, including cardiologist Dr. Michał Nedoszytko who won Anthropic's global hackathon, and a neuroscientist at Stanford.
  • Team: Holly Tang, Troy Gunawardene
  • GitHub: https://github.com/tangxiya-star/cortex
  • Video: https://www.youtube.com/watch?v=Z2eQvUbEp3g

DefRM (GBrain.io)#

  • Description: PromiseLedger helps teams catch risky customer promises before they turn into engineering fire drills. It imports messy account from slack, emails, etc records into GBrain, extracts risky comments and turns them into GitHub issues for Engineering. It also closes the loop back to Sales: Promise Guard checks outbound drafts against account evidence and live GitHub issue state, blocks unsupported claims, and suggests safer wording Sales can send. It is a bridge between sales and engineering without the middleman saving weeks of time.
  • Team: Srikar Voleti
  • GitHub: https://github.com/vsrikar08/promise-ledger
  • Video: https://www.youtube.com/watch?v=0oUgnts7m24

Distro#

  • Description: In the investment banking industry, people onboard and leave banks, and a significant chunk of deal flow fails to survive that process, causing huge lag and wasted labor. We applied the concept of a G Brain and adopted 2 layers: a Project Brain and an Individual Brain for every employee. There are ethical walls around each Individual Brain that prevent them from accessing each other's information; there are also walls between the Individual Brain and the Project Brain that make sure only permissible information gets shared (i.e. emails with crucial clients) while crucial information never gets lost. GG Brain (Giga G Brain) fixes this problem. The employer onboards a Project Brain for every active deal, and a new Individual Brain is spawned for every employee that then starts ingesting their information. Every individual has access to the Project Brain so they don't have to repeat research someone from another team already performed, or send out 4 emails just to figure out who was responsible for an archived deal. We have created an open-sourced version of the Project Brain specifically, with ethical walls to choose private/public/summary and instructions for how to connect them together. We hope this can help multiple industries.
  • Team: Edward Chun, Yongchan Hong, Charlie Wagner
  • GitHub: https://github.com/yongchand/gbrain-company
  • Video: https://www.loom.com/share/b57a03163087455b895e1e773757dc01

Docket (GBrain.io)#

  • Description: Docket, chess engine for litigation. Lex Machina built a $200M business selling lawyers data about cases; lawyers don't want data, they want the move. Docket turns 20 years of public PACER filings plus a firm's own case history into prescriptive strategy — "file this motion, in front of this judge, at this stage, wins 68% of the time" — powered by a typed GBrain knowledge graph (Judge ↔ Motion ↔ Outcome ↔ OpposingCounsel) that answers the multi-hop questions RAG can't, and a team of specialist agents (Research Clerk → Associate → Senior Partner) whose handoffs happen through GBrain nodes so every claim in the final memo traces to a real court filing. GBrain is the brain; the agents are the org chart. Working demo runs on the actual FTC v. Meta docket in under 90 seconds.
  • Team: Siavash Shams, Arash Behravesh
  • GitHub: https://github.com/SiavashShams/docket
  • Video: https://github.com/SiavashShams/docket

Doppel (GBrain.io)#

DrCrop (GBrain.io · ZeroEntropy)#

  • Description: A month ago, I spoke with a strawberry grower in Sonoma County managing about 80 acres. He told me something simple and painful: when pests show up in one block, he often sprays far beyond the affected area because he does not have real-time confidence about how the outbreak is spreading. That means higher chemical costs, more pesticide residue risk for the people eating those crops, and a harder path toward regenerative, biological-first farming. Then I saw Garry Tan's request for startups in AI for low-pesticide agriculture, and the problem clicked: farmers do not just need another detector. They need memory. So I built Crop Doctor Memory. It is an AI agronomist powered by a knowledge graph. When Field Alpha reports aphids, DrCrop remembers the crop, pest, location, severity, timing, and field conditions. Later, when Field Beta reports leaf curling nearby, the agent connects the dots: this may be the same outbreak moving through the farm. Scout this zone first, try a biological intervention, and only escalate to chemical treatment if the threshold is crossed. Instead of blanket-spraying 80 acres, the farmer gets a targeted action plan. The goal is simple: help farmers grow more food while cutting unnecessary pesticide use by up to 90%. Crop Doctor Memory is the shared intelligence layer for low-pesticide agriculture.
  • Team: Evode MANIRAHARI
  • GitHub: https://github.com/Evode-Manirahari/DrCrop
  • Video: https://www.youtube.com/shorts/D0F43TnUIk8

Exodar AI (The Hog)#

**Fork SF (forksf.com) ** (GBrain.io · ZeroEntropy · The Hog)#

G-Eyes (GBrain.io)#

GBody - Agentic Physical Intelligence (ZeroEntropy · The Hog · Jo · LightSprint) — 3rd Place#

gbrain personal rss (GBrain.io)#

  • Description: gbrain-personal-rss is your personal content firehose, AI-filtered to what actually matters. How much life changing insights and knowledge are you missing, because of not keeping up with what you want? Today it's impossible to keep up with every podcast, channel, and blog you follow. The watch list never shrinks. The insight that would change a decision sits in the middle of an episode you didn't get to. An agent reads through your subscriptions every morning, scores each item against your stated interests, and lands a daily brief with the exact minute or paragraph worth your time. It lives in Claude Desktop, Claude Code, OpenClaw, or Obsidian through MCP — the same surface you already read. Built as a skillpack on gbrain, not a fork. Every hard part was already solved upstream.
  • Team: Alex Netto
  • GitHub: https://github.com/alextnetto/gbrain-personal-rss
  • Video: https://youtu.be/VrcMlu_sZWk

GbrainCommunication (LightSprint)#

Glitch#

  • Description: Glitch is an adaptive learning platform and synthetic semester skillpack powered by GBrain that builds a personalized curriculum from any PDF and teaches you in a way that matches how YOUR brain works. Upload a textbook, tell Byte your interests, and watch your content transform. Pokemon fan studying immunology? Your macrophages become Pokemon defenders. Same PDF, completely different experience for every student. GBrain also stores each student's checkpoint history and adapts future lessons around what they got wrong. Visual learners get AI-generated diagrams. Theory learners get dense academic content. The longer you use it, the smarter your personal tutor gets!!
  • Team: Kiruthika Marikumaran
  • GitHub: https://github.com/kirustar14/glitch
  • Video: https://www.youtube.com/watch?v=kenV6IziJq4

GPost (GBrain.io · The Hog · LightSprint)#

GSim - Chip Heat Lab#

GTeam (GBrain.io · ZeroEntropy · The Hog)#

GTM Flow World by MoltPod#

  • Description: Flow World is an agentic evidence to workflow system that takes messy and complex skills and distills them into elegant flowcharts with deterministic steps as well as semantic steps, eval batteries and durable waits. This turns any messy workflow into a strongly typed piece of TypeScript code that can then be heavily optimized in amazing ways by frontier coding agents at 100x speed. The result is 99% reliable, replayable, forkable skills.
  • Team: Aditya Advani, Dominic Damoah
  • GitHub: https://github.com/phantastic-ai/yc-gbrain-demo
  • Video: https://tinyurl.com/moltpod-yc-gbrain-hack

HealthSync (ZeroEntropy)#

  • Description: Getting data out of Apple Health means Shortcuts automations, third-party sync apps, and a fragile stack that breaks every iOS update. We eliminated all of it. We compiled a Pilot Protocol daemon into the iOS app and stream HealthKit samples directly to an AI agent. No message queues. No transport infrastructure. No data custodian between your wrist and your agent. The result: two OpenClaw agents, each with its own G-Brain memory, reasoning over your health data in real time. Every LLM turn draws from three knowledge sources at once — your raw biometric rows, your agent's accumulated memory, and 17 peer-reviewed papers with zerank-2 neural reranking. Ask a question on Telegram — get a cited, personalised answer in under 500 ms.
  • Team: Teodor Ioan Calin, Artemii Amelin, Philip Stayetski
  • GitHub: https://github.com/TeoSlayer/g-stack-hackathon
  • Video: https://youtu.be/M1lySJRF7h8

Hey, G! (GBrain.io · The Hog)#

  • Description: Seventy percent of shopping carts get abandoned. Two hundred sixty billion dollars walks out the door every year because companies and customers are speaking different languages. hey, G fixes the gap with a phone call. You call any business and you're talking to an agent that knows two things, the business inside out, and you. We call them the Company Brain (every product, ingredient, policy) and the Customer Brain (your preferences, history, how you like to be spoken to). Two graphs meet on every call. A new customer who's never ordered at Starbucks can ask for "something warm and sweet like chai back home" in their native language and get the right drink, no jargon required. A regular at Costco gets greeted by name with a suggestion based on what they bought last time. Every hey, G deployment runs fully local on the client's own machine, their menu, their customers, their memory, all on their hardware. For clients that want to scale or share memory across locations, we plug straight into gbrain.io for the hosted version. Same brain, same graph shape, same skills, local by default, cloud when you're ready. No migration, no rewrite. Voice bots answer calls. hey, G remembers customers.
  • Team: Krish Garg, Sean Esla, Aarya Patel, Aayushya Patel
  • GitHub: https://github.com/aayu22809/garrysupreme
  • Video: https://www.youtube.com/watch?v=W6wJzWQq00Y&feature=youtu.be

Hindsight (GBrain.io · ZeroEntropy · The Hog · Jo) — 4th Place ($500 bonus)#

  • Description: Hindsight is the active self-reflection layer GBrain doesn't have yet. Five composable skills that extract a thinker's past predictions from a brain, grade them against sourced outcomes, surface contradictions across time, and produce calibrated advice that knows where the thinker has historically been wrong. The motivation is simple. Garry has talked about how operators like him hold so much in their heads that memory itself becomes the bottleneck. Past calls, past mistakes, past changes of mind all blur. GBrain stores the record. Hindsight makes that record active: it remembers what you predicted, knows how it turned out, and steps in exactly when you are stuck on a decision you have made a version of before. We built it on Paul Graham's mind. Extract-takes pulled 181 gradeable predictions from his 228 essays. Hindsight-profile aggregated those into a calibration view, surfacing patterns. Find-contradictions caught belief changes across decades. Calibrated-advise chains all of this with ZeroEntropy retrieval and The Hog's fresh signal to produce answers that hedge exactly where the thinker's history says they should. The system is designed to grow. The more pages a GBrain contains, the more predictions extract-takes can pull. The more outcomes resolved, the sharper the calibration profile. The more time passes, the more contradictions surface. Hindsight is not a snapshot, it is a feedback loop that gets more useful as the brain it sits on top of keeps learning. Five new skills shipped to the GBrain ecosystem: extract-takes - Reads a brain page and pulls out the falsifiable claims as structured takes with conviction and domain. resolve-outcomes - Grades a take against curated outcomes, returning the verdict and evidence. hindsight-profile - Aggregates resolved takes into a calibration profile: hit rate, patterns, and standout highlights. calibrated-advise - Takes a question, retrieves relevant brain pages, applies the user's calibration patterns, pulls fresh signal, and synthesizes a calibrated take. find-contradictions - Scans takes across years to surface pairs where the author contradicted themselves on the same topic. find-abandoned-threads - Surfaces high-conviction predictions the author made and then never revisited, even as the topic stayed live. Three repos with shared types so contract drift is a compile-time error rather than a runtime surprise. The browser extension is one visualization layer. The skills are the durable artifact, composable into any GBrain.
  • Team: Rushil Jaiswal, Rayan Arya, Keshav Kotamraju
  • GitHub: https://github.com/rayan-arya/hindsight-skills
  • Video: https://drive.google.com/drive/folders/1nJK6GJQc2p6uk3lw2dle8X7kRCIzH2yn?usp=sharing

Hummingbird (GBrain.io)#

Interf (The Hog)#

JitSw - Just in Time Software UI#

Kayba#

Kord Brain (GBrain.io)#

LearningGraph (GBrain.io · The Hog · Jo) — 2nd Place#

Link at the party (GBrain.io · The Hog)#

Lore.ai (ZeroEntropy) — Jo Award#

markit (The Hog)#

Marshall (GBrain.io · The Hog · LightSprint)#

  • Description: Marshall is an AI-powered campaign operating system for downballot political races, combining eight specialized agents under a centralized “Chief of Staff” AI. The platform integrates with existing campaign tools like ActBlue, NGP, Hustle, and Mailchimp to automate fundraising, volunteer management, voter outreach, compliance, communications, and election strategy. Built for campaigns that lack large consultant teams, Marshall helps prevent operational gaps by continuously monitoring campaign performance, orchestrating workflows, and generating actionable daily briefs, all with human approval safeguards and full auditability.
  • Team: Idan Kestenbom, Dan Shalev, Ayush Garg
  • GitHub: https://github.com/marshalldotai-dotcom/marshall.ai
  • Video: https://canva.link/w5mqwsx8yrz8d32

MCP UI (GBrain.io)#

me.txt (The Hog · LightSprint) — LightSprint Award — 1st#

MVP List (GBrain.io · The Hog)#

MVP List (resubmission in case video link broken) (GBrain.io · The Hog)#

Nava (GBrain.io · ZeroEntropy · The Hog)#

  • Description: Nava is the professional network where everyone gets their own public home and a personal agent. AI builds a website that represents your complete identity; your agent runs your feed and matches you to content, people, and opportunities based on what you actually want.
  • Team: Krishna Dusad
  • GitHub: https://github.com/krishnadusad/nava
  • Video: nava.work/demo

Nevastop (GBrain.io · LightSprint)#

  • Description: StoreGym is an autonomous robot training-control demo for small businesses. It takes store images and a task description, builds a simulator-ready robot training mission, runs test gates, generates new robot controller/reward/safety software versions, rejects bad patches, and exports the final robot software package plus simulated training/evaluation data. The demo uses a deterministic local backend for reliability, with a ManiSkill/Linux-GPU handoff path for real simulator validation.
  • Team: Mihir Modi
  • GitHub: https://github.com/wdwd720/ROBOT-AUTOPILOT
  • Video: https://www.youtube.com/watch?v=ioL6eYB_N4s

NeverZero (GBrain.io · ZeroEntropy · The Hog · Jo · LightSprint)#

  • Description: NeverZero is the future of software engineering which is the shared context layer for AI native teams, a mission control system where Claude, Codex, Cursor, GStack runners, and their subagents register into one workspace instead of working through isolated chats. Today, every new agent session starts cold, rediscovers the project, repeats old mistakes, and can accidentally overwrite another agent’s work. NeverZero fixes that by giving every agent shared memory, live context, file level claims, conflict detection, and resume packets across sessions, devices, and machines. The shared org document becomes the command surface: users can type commands like @iris @forge /research onboarding flow problems, triggering sponsor powered skills while heavy outputs are saved into clean linked subfiles. The Hog powers research and verification, ZeroEntropy compresses context and creates resume packets, GBrain stores durable memory, GStack coordinates build and runtime work, and Lightsprint supports deploy workflows. The demo proves that agents can register, collaborate, share context live, resolve conflicts before GitHub sees them, and let a new agent continue from the exact same project state without starting over.
  • Team: Ayush Ojha, Kush Ise, Elizabeth Bours
  • GitHub: https://github.com/ayushozha/neverzero-workspace
  • Video: https://drive.google.com/file/d/1mcZM-3F67n-lhkwhVPNN-UfZVKT7l-xb/view?usp=sharing

Nocta (GBrain.io)#

  • Description: Nocta — Show me once, I'll finish the job. You start a task in your browser. Nocta watches through screen recordings, keystrokes, and clicks. When you stop, it understands what you were trying to accomplish, figures out what's left, and finishes it. Not a macro recorder. You don't configure anything. You just do the first one, and the agent does the rest. How it works: 1. Click Start, do something in your browser, click Stop 2. Nocta cross-references screen captures, UI events, and accessibility trees to understand your intent — not just what you clicked, but what you were trying to accomplish 3. It produces an editable plan — what you did, what remains 4. Click Execute — Claude drives a real browser to complete the work What makes it smart: - No templates, no workflow editor — the recording is the instruction - Understands intent, not actions — if you started an email, it finishes and sends it - Works across any website — Gmail, LinkedIn, Notion, whatever - Learns from every session — each completed action is saved to gbrain (persistent knowledge layer). Before executing, the agent searches gbrain for similar past actions. Over time, it gets better — it remembers how you send emails, how you navigate LinkedIn, what patterns you repeat. Knowledge compounds across sessions, not just within them. Built with: Claude Code, Claude API, local screen capture + inference pipeline, browser automation, gbrain for persistent memory.
  • Team: Nossa Iyamu
  • GitHub: https://github.com/nossa-y/gstack-yc-hackathon
  • Video: https://screen.studio/share/MgFj17Yn

nunu#

Oncura#

  • Description: Key problem we’re solving: Clinical Recruitment Coordinators (CRCs). who are responsible for recruiting patients to clinical trials, are overwhelmed by manual data analysis, patient/physician outreach, and tracking patient status, which slows patient recruitment so much that 80% of clinical trials fail to meet their recruitment goals. Our solution: Oncura is an agentic clinical trial patient recruitment workspace for CRCs. It has an agent team (Oncurabot) that autonomously finds potential patients by pulling patient data from the Electronic Health Record (EHR), analyzing patients' eligibility, contacting physicians, sending informed consent forms to patients, and logging all of the data in Oncurabase. As Oncurabot autonomously handles the recruitment workflow, it also edits OncuraBrain, which serves as Oncurabot's memory for trial criteria, data analysis methods, and the CRC's preferences.
  • Team: Caleb Han, Paxton Warin, Alex Gan
  • GitHub: https://github.com/paxton-warin/Oncura/tree/main
  • Video: https://drive.google.com/drive/folders/1Dh0NsB6hDvOGtpr7Bhl4TQBRYGyqrPYj?usp=sharing

OrderUp (GBrain.io · The Hog) — Transpose Award#

  • Description: OrderUp: One operating system for an independent restaurant. Independent restaurants stitch together 6-10 SaaS tools (Toast, Rippling, Homebase, Slack, Jolt, Cut & Dry) that don't talk to each other; the owner is the integration. OrderUp collapses them into a single agent-driven app. Staff message a Slack bot in plain English ("walk-in is 38°F", "I'm clocking out", "need oat milk by Friday") and the OpenClaw agent handles it: reading and writing a shared memory layer (gbrain on pgvector), calling the right module, and replying in-thread. Managers get a password-gated admin dashboard for schedule, PTO approvals, hiring, vendor inbox, and announcements. Built on AWS (App Runner + RDS + Bedrock) with Claude Sonnet 4.6 as the LLM backend — no external API keys needed.
  • Team: Milit Patel, Bennett Bishop, William Mannel, Anish Paleja
  • GitHub: https://github.com/MilitPatel/hackathon/settings
  • Video: https://youtu.be/XaeGHGFjA3Y

OrgMind (GBrain.io)#

  • Description: OrgMind is a shared company brain for teams and agents. Users log in, see their prior chat sessions on the left, chat with the org’s shared context in the center, and review connected thoughts from gbrain on the right. Each conversation can pull relevant context from the centralized org memory, propose scoped work through gbrain/gstack, and write useful outcomes back so future users and sessions build on the same knowledge instead of rediscovering it.
  • Team: Marquise Rosier
  • GitHub: https://github.com/MarquiseRosier/gemployee-4-orgs
  • Video: https://www.loom.com/share/0dfb9251e96f4eefb9d4a525f13fb5d1

Own Your Data (The Hog) — Honorable Mention#

Pegasus (LightSprint) — LightSprint Award — 2nd Runner Up#

**Pitstop **#

  • Description: Operational Memory Classifier — an evidence-backed execution classifier that wires Pitstop's WAIT/CAP/STOP taxonomy to GBrain precedent retrieval. Input: an AI/API execution failure finding Output: classification grounded in confirmed operational receipts from production systems that already hit the same wall Built during the hackathon: - execution failure classifier backed by GBrain memory - operational precedent retrieval by shared failure structure - live scan of YC open source repos — found execution gaps in GBrain, GStack, Jo, AnythingLLM, and Twenty today Prior research: 63 operational receipts, 14 confirmed and merged into production systems including GStack (Garry Tan), GSD (agent-implemented fix), and earendil/pi (Armin Ronacher). GBrain extension: PR open against garrytan/gbrain adding receipts/ as a native inferred document type in the frontmatter inference system. This is not just classification. It is classification grounded in confirmed operational precedent from systems that already hit the same wall. GitHub: https://github.com/SirBrenton/operational-memory-classifier
  • Team: Brent Williams
  • GitHub: https://github.com/SirBrenton/operational-memory-classifier
  • Video: https://www.loom.com/share/a7fdb68257174972a2364c0d90ff7bc1

Pocket-Console#

Pop (GBrain.io · LightSprint)#

QuickBrain (GBrain.io)#

RackX (GBrain.io)#

Red Brain (GBrain.io · ZeroEntropy · The Hog · Jo · LightSprint) — ZeroEntropy Award#

  • Description: RedBrain is an AI-native security system that helps enterprises and AI agents find and fix security problems in both their internal system applications and AI-generated code. Security tools are still disconnected. One tool reads & check code, another tests live apps, and security engineers still have to manage and connect everything manually. RedBrain brings all of this together in one system. It reads the code, checks the live application, understands how they connect, detects the risks, finds and fix vulnerabilities automatically in real-time. With GBrain and GStack, it stores and learns from past mistakes and self-evolve itself over time. Companies can connect RedBrain to their internal systems so it continuously checks for security issues and sends daily, weekly, or monthly reports. Developers can also connect it to coding agents like Claude Code or Cursor, where RedBrain checks AI-generated code in real time and makes it more secure while it’s being written.
  • Team: Azizjon Rakhimov
  • GitHub: https://github.com/Behruz1306/redbrain
  • Video: https://www.loom.com/share/e3abc3e6298847019f5c641f0e48e2c4

**ScarTissue **#

  • Description: ScarTissue — Every codebase remembers its bugs. ScarTissue is a PR review agent that warns when a pull request is about to reintroduce a bug pattern the repository already fixed. Static analyzers and LLM reviewers have no memory — they'll let a PR recreate the exact race condition that took down production six months ago because the fix is invisible to anyone who wasn't there. ScarTissue fixes that. It mines a repo's git history for fix:, bugfix, and revert commits, embeds each incident (commit message + files changed + unified diff) into a local vector store using MiniLM-L6, and at PR time runs an agentic Claude loop that retrieves the most analogous prior incidents and emits inline GitHub review comments — or a styled HTML email — when the new diff "rhymes" with an old fix. How it works: 1. Index once — clone a repo, walk its history, embed historical bug-fix incidents into ChromaDB 2. Review per PR — Claude (Sonnet 4.6) runs a tool-use loop: search scar tissue, inspect incident details, verify current code state, emit warnings 3. Deliver results — inline PR review comments anchored to the offending line, with issue-comment fallback and email via AgentMail Tech stack: FastAPI · Claude Sonnet 4.6 (tool use) · ChromaDB · sentence-transformers · PyGithub · AgentMail · Next.js 15 · MCP server (works natively in Claude Code and Claude Desktop) Built as a fully integrated MCP server so it works directly inside Claude Code — index a repo and review any PR without leaving your editor.
  • Team: Emanuele Fenocchi, Shivam Singh
  • GitHub: https://github.com/ShivamSinghNow/ScarTissue-GBRAINxGSTACK
  • Video: https://drive.google.com/file/d/1bBSACs-E1il8WEomi1lP5dXg0BfsWo71/view?usp=drive_link

ShellTab (GBrain.io)#

  • Description: GTab gives your team a shared brain. ShellTab (shelltab.dev) is where your team collaborates with Claude Code and Codex in the cloud multiplayer style — multiple engineers, working alongside the same agents, in the same place. GTab streams every session into a shared GBrain: every prompt, every command, every file touched. Continuously. What the org gets: Onboarding in an afternoon — new hire Asks the brain, learns everything the team and its agents have ever done Agents that learn from each other — your Claude reads what a teammate's Codex did yesterday before it starts No more "who did what?" — every action attributed, searchable forever Incident archaeology — "what changed auth between Monday and Wednesday?" → real answers The work is the documentation — no Notion sprawl, no stale wikis Open protocol. Local-first. Owned by the team, not by us. docker compose up to try it or login to ShellTab at shelltab.dev/login with these credentials Email: maya.chen@shelltab.dev Password: M4ya-Spr1g!7HkBxZ Then click GTab on the sidebar to see how it works.
  • Team: Michael Ogundare
  • GitHub: https://github.com/ShellTabHQ/gtab
  • Video: https://screen.studio/share/MgFj17Yn

ShivamSinghNow#

  • Description: ScarTissue is a PR review agent that warns when a pull request is about to reintroduce a bug pattern that the repo already fixed in its history. It mines a project's git log for fix/bugfix/revert commits, embeds those incidents into a vector store, and at PR time runs an agentic Claude loop that retrieves the most analogous prior incidents and emits inline GitHub comments (or an email) when the new diff "rhymes" with an old fix. We also used Activeloop Hivemind: Hivemind captures every coding-agent interaction in your org as a structured trace, codifies repeated patterns into reusable skills, and propagates those skills to every agent on your team. https://github.com/activeloopai/hivemind
  • Team: Emanuele Fenocchi, Shivam Singh
  • GitHub: https://github.com/ShivamSinghNow/ScarTissueOpenClawHackathon
  • Video: Uploaded by my colleague

SignalAI#

  • Description: SignalAI is an AI-native platform where anyone can build a trading signal in minutes without touching the underlying engineering. Today, trading signals exist everywhere — in news headlines, social media posts, government filings — but they're trapped, unstructured, and un-tradeable. Building a real one requires finding the data source, scraping it, cleaning it, scoring it, deploying it, and keeping it running — most people with a genuine edge never build it because the engineering is too painful. SignalAI fixes that. Users describe the signal they want — like tracking CEO sentiment across financial news or monitoring government defense contracts — and the platform's general skill handles the plumbing: data discovery, scraping, validation, and deployment. The part that matters most — turning raw, unstructured data like headlines or filings into a meaningful score — is where the builder brings their own expertise through a transformation skill. They describe how they think about the data, and the platform generates the scoring code from that description. The result is a live, deployed signal streaming date-and-score data. But building signals is only half the story. The real goal is a two-sided marketplace — signal builders publish their signals, and traders on the other side can browse, purchase, and plug those signals directly into their own strategies. One platform, producers on one side, consumers on the other, and you can be on both.
  • Team: Yash Kothari, Rahul Gupta
  • GitHub: https://github.com/rahuliitg/SignalAI
  • Video: https://drive.google.com/file/d/1tvR1thdmnL37ZRsxPGtW7HguipE9cTo8/view?usp=sharing

Sina Matian (Build your Phone) — 1st Place#

  • Description: stack iOS — Claude Code Skills for Live iPhone QA, Design Review, and Autonomous Bug Fixing gstack is an open-source skill framework for Claude Code. This project extends it to iOS — giving Claude the ability to physically control a real iPhone, understand what's running on it, and fix bugs without any human in the loop. The core trick: Claude reads your entire Swift source tree, maps every @Observable ViewModel, every screen, every mutating function — then generates a custom debug bridge tailored to your exact app. A StateServer compiled directly into your debug build exposes HTTP endpoints for reading live state, injecting taps, typing text, and dismissing sheets. Claude connects over the CoreDevice USB tunnel (IPv6, no proxy, no simulator) and essentially becomes a developer who already knows the codebase. /ios-qa — Claude studies your source, writes accessor code for every ViewModel it finds, builds it into the app, deploys to device, then navigates like a human tester — tapping real UI, catching real bugs, reading internal state that screenshots can never show. /ios-design-review — Screenshots every screen and evaluates against Apple's Human Interface Guidelines. /ios-fix — Takes a bug, writes a fix, rebuilds, redeploys, re-runs the failing test. Find → fix → verify, end to end. /ios-clean — Strips all generated instrumentation when QA is done. A PassthroughWindow floats the debug overlay above every sheet and modal, invisible to the accessibility tree so Claude sees the real app underneath. The whole thing is generated fresh for each codebase — no generic agent, no Appium, no boilerplate you maintain. take the capabilities of claude with a browser agent that tests your web app, but on iPhone!
  • Team: Sina Matian
  • GitHub: https://github.com/time-attack/gstack
  • Video: https://streamable.com/6g129s

Sohoist (GBrain.io)#

Spoticker (GBrain.io · Jo)#

  • Description: https://www.spoticker.com/ Spoticker is an intelligence platform for GPU spot pricing across major cloud providers. It assembles live pricing and eviction-risk data for A100s, H100s, L4s, and other training-grade GPUs across AWS and Azure, with GCP integration in progress. The data is visualized as a matrix at spoticker.com, where each cell shows the cheapest spot price per GPU type per region, color-coded by eviction probability. The problem Spoticker solves: GPU spot instances save 60-80% over on-demand pricing, but the data needed to use them safely - current prices, regional availability, and eviction rates - is fragmented across each cloud's APIs and dashboards. Most teams default to manual or outdated checks, which leads to either overspending on on-demand or losing training runs to unexpected evictions. Users can sign in with AWS credentials to unlock account-specific intelligence: their current spot quota limits, instance availability scoped to their account, and recommendations tailored to what they can actually launch. The public matrix becomes a personalized decision surface. I also integrated GBrain as the contextual agent for which spot to use. The full pricing catalog was ingested into GBrain as structured pages containing price, eviction rate, and workload-fit metadata for every instance-and-region combination. Claude queries this substrate when given a workload description (ex "4x A100s for 8 hours of fine-tuning, batch-tolerant") and returns a risk-adjusted recommendation with a clear tradeoff analysis between alternatives. Target users are AI infrastructure engineers running training and batch inference workloads. The roadmap extends from intelligence into action: launch-config generation for Terraform, SkyPilot, and Kubernetes, and continuous monitoring with mid-flight migration recommendations for long-running jobs. Built with Next.js, GBrain, Claude, and ingestion pipelines against AWS and Azure spot APIs.
  • Team: Anna Kislenkova
  • GitHub: https://github.com/akislenkova/spoticker
  • Video: https://www.loom.com/share/85f3a658b8a643a28a3646b48372e927

Superbloom#

  • Description: Superbloom is a stack of engineering simulation tools (MStack) and frameworks that AI Agents can use in order to propel and power an Auto-Auto-Omni-Researcher (vs. Karpathy's Auto-research which is human led and covers only so many fields), all locally, to encourage open-source AI and research capabilities for all. This is a set of simulation tools that run locally that an agent pilots seeking its own goals, always discovering new things and solving engineering problems on auto-pilot.
  • Team: Max Reynolds
  • GitHub: https://github.com/Bubbalubagus/Gbrain_Hackathon
  • Video: https://www.loom.com/share/e5be0617739b41abab985ddcaa109735

SuperBoomer (Jo)#

  • Description: Noodle is a phone number an elder can call. They talk naturally. Noodle already knows them — their family, their medications, their language, what the pharmacist said last week. It can take action through tools (remember a fact, text family, log an appointment), always confirming before irreversible things. After every call, family members see a live dashboard with the conversation, tool activity, and a post-call summary. No app for the elder. No friction.
  • Team: Ajibayo Adeyeye, Victoria Olaogun
  • GitHub: https://github.com/270v/Noodle
  • Video: GBRAIN CRASHED WHEN WE TRIED TO RECORD THE DEMO

Syed Husain (GBrain.io · ZeroEntropy)#

Tarry Gan (GBrain.io · ZeroEntropy)#

**team daniel **#

Team GFlow (The Hog · Jo)#

Team Robel#

Team Vaultic#

  • Description: Vaultic is an API that lets AI agents send, receive, and manage stablecoins. Today, any team building an AI agent that handles stablecoins has to build wallet management, transaction signing, compliance checks, and audit trails themselves. That's months of work before they ship anything. Vaultic does it in one API call. Policy enforcement, multi-chain routing across Ethereum, Solana, and Base, and audit trails are built in.
  • Team: Aashil Patel
  • GitHub: https://github.com/aashil/vaultic-v1
  • Video: https://www.loom.com/share/5bb7e2e61e964683bd035f49b55efd91

Tell. (Jo)#

ValutBrain (GBrain.io · The Hog)#

  • Description: VaultBrain — The Shared Brain for VC Teams VaultBrain is a shared intelligence layer for venture capital firms, built natively on GBrain, GStack, and The Hog. It solves a problem every VC team has but no tool addresses: knowledge that lives in scattered emails, siloed notes, and individual heads — never compounding, never queryable, never shared. What we built: VaultBrain gives VC teams a persistent, shared GBrain knowledge graph where every founder and company becomes a living entity page — enriched in real time by The Hog's web intelligence. Search any founder or company through The Hog's people and company endpoints; structured signals (traction, team, market, PMF, funding, moat) flow directly into GBrain entity pages with full provenance tracking. Every signal persists to a timeline, queryable by any future session. On top of the knowledge layer, we built a research-backed token optimization pipeline that runs before every LLM call. Rather than re-fetching context on every query, VaultBrain queries GBrain first — only calling The Hog on a cache miss. The optimizer then compresses remaining context using five published techniques: LLMLingua (EMNLP 2023), Selective Context (ACL 2023), LongLLMLingua (ACL 2024), RECOMP (ICLR 2024), and AutoCompressor (NeurIPS 2023) — delivering 15–65% token savings depending on mode, exposed through a live Token Lab with side-by-side comparison. The collaboration layer includes a Team Session workspace where partners can activate pre-built skills around any entity, a Collab Pad markdown editor with @agent mentions that write intelligence back into GBrain, and an Agent Chat interface wired to GStack skill endpoints. Tech stack: Bun/Express backend, SQLite, React 18 + Vite frontend, ForceGraph2D knowledge graph visualization, JWT auth, GBrain MCP, GStack skills layer, Hog API (company search, people enrichment, website scan). Side quests targeted: The Hog — The Hog is not a session tool in VaultBrain. It is a persistent enrichment pipeline: every search writes structured signals into GBrain entity pages that any future query can read for free. gbrain.io — VaultBrain is the team layer gbrain.io doesn't have. Two-person emerging manager funds get a shared brain, live web intelligence, and token-optimized LLM calls — without running their own infrastructure. Why it matters: VC firms spend 20% of every work week re-finding information colleagues already have. Deal intelligence compounds in no one's system. VaultBrain makes it compound in everyone's.
  • Team: Luxin Zhang
  • GitHub: https://github.com/luxinlabs/VaultBrain
  • Video: https://youtu.be/U4U3HtcOFBQ

VeraView (GBrain.io)#

Watchdog (GBrain.io)#

Winhint (GBrain.io · ZeroEntropy · The Hog · LightSprint)#

* * *