Hello 👋
First post here. Been building in public for a bit but never really sat down to write properly about what my team and I are working on. Figured it's time...and chose the right platform for it,
I'm one of the devs at TinyHumans and for a while now our whole team has been deep in AI tooling. The one thing that kept bugging us more than anything else was memory. Not the flashy stuff. Not the models, not the inference speed, not the prompting tricks. Just... memory. The boring, unglamorous, completely-broken part of almost every AI app we touched.
Here's the thing that was driving us crazy:
Every time we built something with persistent context; a support bot, a personal assistant, an agent workflow — we'd hit the same wall. Either the AI remembered nothing (new session, clean slate, start over), or it remembered everything so poorly that the context became noise. Stale facts. Outdated decisions. Irrelevant history injected into every prompt?
Vector similarity search retrieves what's similar. Not what's important. Not what's current. Just... similar.
That distinction kept bothering us. So we went down a rabbit hole.
Turns out the brain solved this millions of years ago...
Hermann Ebbinghaus figured it out in 1885. Memory retention drops roughly 50% within an hour unless it's reinforced. He called it the Forgetting Curve and it's not a flaw in human cognition. It's a feature. It's how the brain stays fast, lean, and actually useful.
The brain doesn't store raw data forever. It compresses experiences into patterns, strengthens what gets recalled and acted on, and quietly drops the rest. You remember the architecture decision that shaped 6 months of work. You don't remember the Slack message about lunch that day.
Forgetting is the feature. AI memory systems just... don't do this.
That's what we set out to fix with Neocortex.
What Neocortex actually does
At its core, Neocortex is a brain-inspired memory layer for AI apps. You store knowledge, the system figures out what's worth keeping, and everything else naturally fades.
Here's how:
Time-decay retention scores — every memory item has a score that decreases over time. Old, unaccessed memories fade on their own. No cron jobs, no manual cleanup.
Interaction-weighted importance — not all signals are equal. Something that gets referenced, updated, and built upon becomes more durable.
Noise pruning — instead of accumulating every token forever, low-value memories decay and get removed automatically. This is what lets Neocortex handle 10M+ tokens without quality degradation.
GraphRAG — instead of a flat list of embeddings, Neocortex builds a knowledge graph. Entities, relationships, context. Queries traverse the graph to get structured, rich answers — not just "here are 5 similar chunks.
Getting started is actually pretty simple
import tinyhumansai as api
client = api.TinyHumanMemoryClient("YOUR_APIKEY_HERE")
Store a single memory
client.ingest_memory({
"key": "user-preference-theme",
"content": "User prefers dark mode",
"namespace": "preferences",
"metadata": {"source": "onboarding"},
})
Ask a LLM something from the memory
response = client.recall_with_llm(
prompt="What is the user's preference for theme?",
api_key="OPENAI_API_KEY"
)
print(response.text) # The user prefers dark mode
The things I'm most excited to see people build
A few use cases that I think are genuinely underexplored:
Support bots that actually learn — ingest ticket history, let outdated workarounds decay naturally, give agents per-customer context without re-reading entire conversation logs every time.
Company knowledge agents — every org has knowledge scattered across Slack, Notion, wikis, and people's heads. A graph-based memory layer that understands who decided what and why is way more useful than semantic search over a pile of docs.
_Personal assistants that remember _— not just within a session. Across weeks and months. You told it you're vegetarian in January, it filters restaurants in March. No reminder needed.
If you want access or just want to follow along:
founders@tinyhumans.ai — reach out with your use case
And honestly — drop a comment if you've run into this problem before. I'm curious how other devs are handling memory in their AI apps right now, because I feel like most people are either ignoring it or duct-taping something together.
That's kind of why the team and I are building this.
— neocoder (dev @ tinyhumansai)
Top comments (10)
That's quite an interesting approach, crazy how "humanizing" the llms just simplifies the whole thing
Interesting approach with the time-decay scores. That's one of the hardest design decisions in agent memory — not what to remember, but what to let go.
One thing I've noticed running persistent agents: the gap between "recall the right fact" and "behave differently because of accumulated experience" is enormous. You can build perfect retrieval and still have an agent that treats its 500th session identically to its first. The knowledge is there but it hasn't shaped anything.
The graph structure helps because relationships carry more signal than isolated embeddings. But I think the real frontier is somewhere between your decay function and something nobody's quite built yet — a system where old memories don't just fade, they compress into behavioral patterns. Not "I remember the user prefers dark mode" but "I've learned to notice UI preferences early." One is data. The other is something closer to instinct.
Curious whether you've seen emergence effects in the graph topology — clusters forming that weren't explicitly designed.
That distinction recall the right fact vs behave differently because of accumulated experience is exactly the gap we're trying to close. You're right that perfect retrieval still leaves you with an agent that treats session 500 like session 1, lol can you imagine the pain of the user here?
Anyway the emergence question is one we're watching closely. Yes, clusters do form that weren't explicitly designed entities that get co-recalled frequently start developing stronger relational edges. Whether that crosses into something closer to instinct than data is the interesting open question. Would love to dig into this more with you!
Really fascinating idea... Most AI memory systems today just retrieve what’s similar, not what’s actually important. Using decay pluss reinforcement like the forgetting curve feels much closer to how real cognition works.
Curious to see how this behaves with long running agents. Cheers!
Exactly! similar ≠ important is the core problem nobody's really solved yet. The forgetting curve gives us a principled way to handle it: reinforce what gets used, let the rest fade. Long-running agents are the real test of whether this holds up. We'll be sharing results as we push it further stay tuned!
Really interesting approach. Mimicking the forgetting curve for AI memory makes a lot of sense. Systems should not just remember what is similar, they should remember what actually matters. The decay and reinforcement model feels much closer to real cognition. Curious to see how this performs with long running agents. 🚀
Long-running agents are exactly the use case we're most focused on. Short sessions you can get away with stuffing context into the prompt. At 6 months of history, that breaks completely and that's where decay + interaction weighting starts to matter. Happy to share early benchmark results when we have them!!
It's so educative 💪
The innovation in Web3 keeps blowing my mind — real utility, real value! 🚀
Some comments may only be visible to logged-in visitors. Sign in to view all comments.