Bullwark

Inspiration

A few of us have worked at finance startups and spent a lot of time researching companies and putting together stock pitches. In that world, who knows what matters a lot. At quant shops and funds there are information barriers for a reason: the people working on a deal can't share it with the people trading the stock. That used to be about who's in which meeting. Now everyone runs their work through AI tools, and a shared AI memory doesn't respect any of those lines.

We also had a more personal version of the problem: our own context is scattered across Claude, ChatGPT, docs and chats, and every tool either remembers nothing or remembers everything. Products like Mem0, Honcho got us thinking about what AI memory should look like, and we wanted to take it a step further: memory that's shared across a team but still knows who's allowed to see what, and that stays current on its own.

What it does

Bullwark is a memory system for a finance team's AI. Every person and every agent gets a memory that holds exactly what their role needs, and nothing else.

• Memory that writes itself. Chats in Claude Code, notes and documents turn into facts automatically, filed into the right group so only the right people see them.
• Memory that stays current. A paid invoice, an old stock price or a position that's since changed moves to the background on its own and only comes back if you ask about it directly.
• Agents with just enough. Anyone can spin up an agent, pick which parts of their memory it can use, give it a task and watch it work step by step. It can never see more than the person who made it.
• A control room for compliance. One moderator sees everything, decides who can see what, gets the cases the system isn't sure about, and has a full audit trail of who knew what and when.

How we built it

• Capture: Claude Code hooks add a person's memory before every prompt and save their sessions; an MCP server gives Claude four memory tools; documents can be uploaded directly.
• Writing facts: Claude reads each item and pulls out the facts worth keeping, along with who said them and where they came from.
• Filing: Jev, a fast yes/no judge, decides whether each fact is worth keeping, which group it belongs in, and whether it's hiding instructions aimed at an AI (those get quarantined).
• Building each person's memory: code removes everything behind a wall before any model sees it, then Moss finds candidates and Jev picks what fits that person's task. The result is a fixed list of facts.
• Answering: every question searches only inside that list. Jev judges what's relevant and whether it's still current, and every answer is logged.
• Agents: Factory Droid (or Claude as a fallback) runs each agent in its own sandbox folder that only contains that agent's memory.
• Built in TypeScript across a server, a worker for writing facts and running agents, and a web app.

Challenges we ran into

• Ideation. Building something actually new, not another chatbot wrapper, that solves a problem we've personally run into took a lot of back and forth.
• Not leaking, and not refusing either. "Sorry, I can't discuss that" already tells you something exists. Getting the AI to answer normally while knowing nothing took careful design.
• Keeping memory fresh. Deciding when a fact is out of date is harder than it sounds. A newer position should replace an older one, but an agent repeating a fact in different words should never overwrite the original. We found that exact bug while testing and fixed it.
• The usual hackathon stuff: three people building in parallel, merging work late at night.

Accomplishments that we're proud of

• A memory design we think is ahead of most of what's out there. It combines Jev's fast yes/no judgments with walls enforced in code, retrieval through Moss, and memory layers that keep things current. We think this approach could catch on more widely as AI memory matures.
• It works end to end: a chat in Claude Code becomes a filed memory in about 3 seconds, and an agent goes from Run to a finished report in about 30 seconds.
• 846 automated tests, plus an answer key with planted traps (like an email hiding instructions for the AI) to prove the walls hold.

What we learned

• The hard part of AI memory isn't remembering, it's forgetting the right things and knowing who should see what.
• Keep the AI's job small and checkable. Asking a model narrow yes/no questions and enforcing the rules in code is far more reliable than trusting it to "be careful."
• Test the real product with a real browser early. Our live click-through found bugs that unit tests didn't.

What's next for Bullwark

• Connect to a real ledger and accounting tools, so agents can take on more finance work like payables and reconciliations.
• More capture sources (ChatGPT, email, Slack) and single sign-on.
• Talk to compliance teams at small funds and get Bullwark in front of real users.

Built With

• claude
• droid
• javascript
• jev
• moss
• typescript