hi.

we're nikhil and advaiyt.

we're both CS students.

which means when we see a problem, we reach for data structures before we reach for more compute.

here's the problem we couldn't stop thinking about.

every time an agent needs to remember something, developers cram more text into the context window. summaries. retrieved chunks. md files injected every 60 seconds.

we've seen this in production. we've built this ourselves.

they call it memory. it's a patch.

and everyone kind of knows this — but they keep doing it because transformers are incredible and surely the model will sort it out if you just give it more tokens.

here's what we kept coming back to.

there are entire classes of memory structures that are deterministic. provable. efficient. that let you reason about exactly what an agent knows and why. that cost nothing to run at retrieval time.

classical computer science has had answers here for decades.

the industry got so deep into the magic of LLMs that it forgot those answers existed.

we didn't.

so we started building. hackathons first. then real companies. built things that completely broke. rebuilt them. won some things. got a lot wrong.

but the pattern kept showing up: relational memory — memory that understands how data actually connects — beat the bloated alternative. not sometimes. consistently.

so we kept going.

we call it AX. agent experience.

in ten years, humans won't be the ones navigating the web. agents will. booking flights. resolving your support tickets. handling the thousand small things that eat your day.

those agents need memory that's actually designed for them. memory you can reason about. memory that knows the difference between a signal worth keeping and noise worth forgetting. not a black box you throw tokens at and pray.

what does an agent-first web look like?

it's not bigger windows. it's provable architecture.

we're building that layer.