bro. | Devpost

hero page

Inspiration

the ai that's supposed to know you is stuck in a chat box.

every assistant is the same window: you type, it answers, it forgets. you never see the mind. you can't watch what it remembers, you can't see it learn, you can't hand it something and watch it act. the memory, the part that would make it actually yours, is invisible or isn't there at all.

bro started from that frustration: what if a personal agent did not feel like a hidden black box? what if you could talk to it naturally, see what it remembered, watch its knowledge build, and trust that every action it claimed was actually real?

the design inspiration came from the same idea. we wanted bro to feel calm, obvious, and human from the first second. no confusing dashboards, no enterprise-looking maze, no overdesigned ai interface that makes users feel like they need instructions. people should open it and instantly understand: this is where i talk, this is where its memory grows, this is what it just did.

visually, we leaned into a clean, minimal, almost lifestyle-product aesthetic: soft motion, film grain, warm matcha tones, crisp iPhone framing, and a layout that feels more like a personal space than a technical console. humans naturally gravitate toward clean surfaces because they reduce friction. when something looks simple, people trust themselves to explore it. that was important for bro because the technology underneath is complex, but the experience should not feel complex.

bro is the opposite of the normal chat box. it is a personal agent you talk to, with a memory you can literally watch build itself out of the conversation. the rule from the first commit was simple: it has to be real. no faked integrations, no demo props. if a judge opens the dashboard or the database, it's all actually there.

What it does

bro is a calm web surface for a personal agent that remembers.

chat with it. the conversation runs on a configured bro assistant with real cross-message memory. tell it something now, ask about it ten messages later, it's got it.
watch its mind build. as you talk, entities and topics from the conversation get pulled into a knowledge graph that grows on screen, node by node, in real time. it only records things that genuinely came up. it will not invent a node to look smart.
an honest trace. every reply has a collapsed "what bro did" line. open it and it's the real steps that turn: the model call and how long it took, whether memory carried, whether it saved, whether the graph grew. only what actually happened.
it watches solana. a live mainnet read and real memecoin prices feed a paper trade desk. real chain, fake wallet, zero risk.

How we built it

bro is a next.js 16 app (react 19, tailwind v4, bun).

the brain is backboard. we create a real configured assistant through their api with a bro system prompt, so it answers as bro with its own persona, not a stock template. its id is persisted in mongodb so we reuse one clean assistant instead of spawning a new one every cold start (backboard has no list endpoint, so reuse-not-duplicate had to be deliberate). every message binds to it, memory carries by thread id. the backboard dashboard fills with real threads because the chat genuinely runs on it.

the memory is mongodb atlas. chat history, the assistant config, the waitlist, and the conversation-built knowledge graph all live in atlas. the graph is its own thing: a light extractor pulls entities and topics out of each turn, upserts nodes and co-occurrence edges, and the panel re-reads it after every message so you watch it grow. writes are idempotent, the same email or the same entity twice doesn't double anything.

elevenlabs. real conversational ai integration. like you're talking to your real homie.

solana is a live getEpochInfo read off mainnet for the pulse and dexscreener for the watchlist prices behind the paper desk. no key, real chain, paper wallet.

every integration is built to degrade honestly: pull a key and that piece says "not configured" instead of faking a success. and the stores report whether they actually wrote, so the trace can't claim a save or a graph-grow that didn't happen.

Challenges we ran into

the honesty constraint, on purpose. faking a couple integrations would've been a few hours. making each one genuinely load-bearing, a real configured assistant, a real atlas cluster, a real chain read, was more work and the right call. it's the reason the project survives a judge opening the backboard dashboard or the database. nothing is staged, so nothing falls apart under a click.

making the trace impossible to lie. the obvious way to build a "what it did" trace is to hardcode the steps. ours doesn't: the persistence layer and the graph extractor return whether they actually wrote, and the trace only renders steps that came back true. so a turn that didn't hit the database simply doesn't show that line. the graph does the same, it stays silent rather than claim entities it didn't record.

Accomplishments that we're proud of

a memory you can watch build itself. the graph isn't a decorative constellation, it's the actual entities from your conversation, persisted, growing live, with an honest trace under every reply that only claims what ran.

it looks like it costs money. a crisp iphone, a matcha and film-grain system designed from scratch, calm motion. the polish is the product as much as the plumbing.

almost AGI. a fully functional conversational ai that genuinely remember you. we are closer to AGI than we know.

What we learned

the orchestration is the product. backboard, mongo, solana are each great alone and none of them is the thing. the thing is the calm surface that turns a sentence into a remembered conversation, a growing graph, and an honest account of what just happened.

What's next for bro.

better extraction for the graph. today it records clear entities and stays silent otherwise, on purpose, it won't invent nodes. it could read casual lowercase talk and still be honest.

let bro act more. it remembers and it watches markets now. scheduled check-ins and real actions are the next surface.