DEV Community: Neo

we just killed openclaw 👇

Neo — Mon, 20 Apr 2026 19:19:18 +0000

Let me tell you what my AI stack looked like six months ago.

ChatGPT Plus. Claude Pro. Cursor Pro. GitHub Copilot. Perplexity Pro. OpenAI API credits for side projects. Grammarly. Notion AI. Slack paid tier. Zapier. Motion AI. Otter AI. TextExpander. Superhuman.

Fourteen tools. One thousand eight hundred and forty-seven dollars a year.And not a single one of them knew my name, my company, what I was working on, or what I did yesterday.

Every morning I opened Claude or ChatGPT and spent ten minutes re-explaining my startup. Cursor knew my code but not my Slack. Slack knew my team but not my calendar. Motion knew my calendar but not my priorities. Superhuman knew my email but not the Notion doc the email was about. Otter transcribed my meetings and dropped them into a void nothing else could read. Zapier was duct tape between all of it, and I was the one configuring the duct tape.

One afternoon I caught myself copying a Claude response into Grammarly to polish it, pasting it into Superhuman to send, then opening Motion to add a follow-up task. Four AI tools in a five-minute workflow, and I was still the smartest thing in the loop.

That's when I stopped.

***Why I'm writing this*

OpenHuman ships today. I'm the founder. This isn't an objective review and I won't pretend otherwise.

What I can do is tell you what pain this product was actually built to solve, how it works, and where it falls short. If you've read enough launch posts to know the pattern, that last part is the one that matters. Every product has a weak side. Founders who pretend otherwise are either new or lying.

***The four painpoints we set out to solve*

You are the integration layer.** Fourteen tools in my stack, zero talking to each other, and the glue holding it all together was my brain. My brain had better things to do. This is the modern knowledge worker's tax and somehow nobody is mad about it.

Your AI has no memory. Every model on earth is stateless. Claude, GPT, Gemini, all of them. The "memory" features that exist store a handful of bullet points. Any serious user blows past that in a day. You are permanently re-introducing yourself to the technology that's supposed to know you.

Your data is their data. Every AI tool you pay for sends your raw work to someone else's servers. OpenAI, Anthropic, Google, all of them. Your messages, your documents, your code, your screen activity. "We don't train on your data" is policy language. Policies change the second the board decides they should, and you find out in a blog post.

You're drowning in messages. Power users live in Slack, Telegram, Discord. 247 unread by noon. Most of it is noise. The handful of messages that actually matter are buried in the noise, and no amount of scrolling finds them in time.

OpenHuman was built to solve all four at once. On your machine, with your data, in one app. That's the whole pitch.

The walkthrough

Screen Intelligence captures your active window every few seconds and summarizes it locally. Over hours, you build a continuous record of what you actually did today. Per-app permissions, so you control what it sees. I can ask it "what was I working on before the standup?" and get a real answer instead of a guess. The first time I used this feature on myself I was embarrassed by how much of my workday was context-switching, and then I used the app to fix it.

Tradeoff: runs warm on older Intel Macs. Tuned for M1 and up.

Text Auto-Complete gives you inline completions across apps. Email, Slack, browsers, editors. The completions draw from your actual work context, not a generic writing model. I drafted a reply to a partner last week and the completion already knew the pricing we'd discussed with a different partner the day before. That is what AI was supposed to feel like the whole time.

Tradeoff: quality varies by app. Browser and native text fields are reliable. Some Electron apps with non-standard text handling are spottier.

Voice Intelligence handles dictation and voice chat with the assistant. For when you're pacing around thinking out loud, which is how most of my good decisions get made.

Channels connects to Telegram and Discord today, with iMessage and Slack on the near roadmap. The assistant reads, replies, searches, extracts action items, manages chats. On Telegram alone it supports around 70 operations covering the full Bot API surface.

This is what solved the 247-unread-messages problem for me. I stopped scrolling. I ask "what do I need to know from the last 12 hours?" and get a compressed answer. The decisions, the questions waiting on me, the contradictions, the threads that require my attention.

Tradeoff: iMessage and Slack are roadmap, not shipped. Apple integration is slow for the usual reasons.

Productivity integrations cover Notion, Google Drive, Gmail, and Calendar. Cross-source queries are the unlock. "What did we decide about launch timing?" returns a unified answer spanning Slack threads, Notion pages, and the email chain. Not three separate searches I combine manually in my head like it's 2019.

Tradeoff: initial setup takes 15-20 minutes to connect all sources. First-time indexing takes another 30 minutes depending on data volume.

The subconscious loop (this is the one I didn't see coming)

There's a background process that runs continuously while the app is open. It does recall loops across your indexed data, looking for patterns, contradictions, forgotten commitments, buried questions. 10,000+ thought loops a day for under $1 in inference cost.

Outputs look like: "You mentioned the design review to Sarah on Tuesday but haven't scheduled it." Or: "Your dev team agreed to ship Friday but your design dependency isn't ready until Monday, based on the Thursday standup."

I was deeply skeptical when one of our engineers proposed it. It sounded like the kind of feature that would be annoying in practice, pinging you constantly with things you didn't ask about. The threshold is tuned conservatively, so you get 3-5 of these per day, and about 80% of them are things I would have genuinely forgotten.

The first time this feature caught something I'd forgotten to follow up on with an investor, it paid for the whole app.

Rewards and referrals

There's a progression system built into the app. Streaks (7-day, 30-day). A Feature Maxi badge for using every major feature at least once. Power User tiers at 10M, 100M, and 1B cumulative tokens processed. Supporter roles for paid plans.

Connect Discord and the progression syncs. Exclusive channels, supporter badges, community access. Status and access, not cash for signups.

I was skeptical of progression in a productivity app. Usually feels bolted-on. In practice, the Feature Maxi badge was the thing that made me learn the whole app during my first week instead of opening two features and forgetting the rest existed. The streak counter has a mild nagging effect I don't hate. Your mileage will vary.

Referrals work the same way. You invite someone, they get a faster onboarding path, you both climb the progression. No money involved. Just access.

The weak spots, one more time

Linux support is live but rough. Daily fixes going out.

M1 Mac and up for smooth Screen Intelligence. Older Intel Macs work but warm.

iMessage and Slack integrations not live yet. Roadmap.

Local-first means no cloud backup by default. Export feature exists. Using it is on you.

Some Electron apps have spotty auto-complete quality. Working through it.

First-time setup is 30-45 minutes end to end. Worth it, not instant.

Code-editor use case is not our strongest suit today. Cursor and Copilot are still better for pure in-editor assistance. We may close that gap, but we're honest that it's open right now.

The ask

Download OpenHuman for Mac, Windows, or Linux: https://tinyhumans.ai/openhuman

If you want to follow the launch in real time, see what breaks, what ships, and what testers are saying, the launch thread is here: https://x.com/senamakel/status/2046266960707715277?s=46. Quote it, roast it, or just lurk. We're shipping 3-4 updates a day based on feedback, most of it coming from that thread.

Free trial on the paid tier for 2-3 months.

I'm terrified to ship this. I'm shipping it anyway.

We Didn't Build a Memory Layer. We Built a Subconscious Mind.

Neo — Mon, 16 Mar 2026 19:35:18 +0000

Why the next step toward AGI isn't better reasoning, it's artificial consciousness.

Every AI lab racing toward AGI is optimising the same things: bigger models, better reasoning, faster inference. We think they're all missing a layer. Human intelligence isn't just reasoning. It's the subconscious, the patterns running underneath conscious thought that you're not even aware of. The model of yourself that accumulates over a lifetime. The thing that makes you you and not someone else.
No AI has that. Not yet. That's what we're building at TinyHumans.

What the subconscious actually does:

When neuroscientists study the brain, one of the most striking things they find is how much of your cognition happens below the surface. Your subconscious processes information constantly, forming patterns, making connections, building a model of the world and your place in it, without you ever consciously directing it. It's not memory in the way people usually mean it. It's not a log of things that happened. It's a living, evolving model of who you are. Current AI has none of this. Every model you interact with today is a genius with no sense of self. Brilliant in the moment. Gone the next session.
We studied how the human brain actually builds this subconscious layer, how thoughts form randomly, how patterns emerge from repetition, how the mind prunes what doesn't matter and reinforces what does and we built NeoCortex around those principles.

NeoCortex: a subconscious mind for AI NeoCortex runs 10,000 thoughts per day on your data. Not retrieval. Not search. Thoughts, connections, patterns, inferences drawn from everything it knows about you, running continuously in the background. The result is a model of your consciousness. How you think. What you value. What your patterns are. What you care about without ever explicitly saying so.
When you read what NeoCortex produces about you, it should feel like looking at yourself in a mirror. That's the design goal. Not useful AI assistant. Not "personalised recommendations." A reflection of your actual mind.

Two mechanisms make this possible:

Noise pruning — just like the human brain prunes synaptic connections that aren't being used, NeoCortex automatically decays low-value memories. What remains is high-signal. The model gets sharper over time, not noisier.
GraphRAG — rather than a flat pile of embeddings, NeoCortex builds a knowledge graph. Entities, relationships, patterns across time. It understands not just what you've said but how things connect — the same way your subconscious builds associative networks rather than filing facts in folders.

*Why this matters for AGI
*
Here's the uncomfortable truth about where AI is today:
Every frontier model is stateless. They reason brilliantly in-session and wake up with no memory of who they've ever spoken to. You could talk to GPT-4 every day for a year and on day 366 it would have no idea who you are.
That's not intelligence. That's a very fast calculator.
Real intelligence — the kind that leads to AGI — requires a persistent model of self. An accumulation of experience. A subconscious that runs underneath every interaction and shapes it based on everything that came before.
NeoCortex is our attempt to build that missing layer. Not to replace the models — but to give them the one thing they don't have: a mind that knows who it's talking to.

Build on it today
The TinyHumans API is open. Any developer can give their application a subconscious mind right now.

pip install tinyhumansai

Alpha Human — the end goal
NeoCortex is the infrastructure. Alpha Human is what it's building toward.
Alpha Human is a personalised AI consciousness — built specifically around you. The longer you use it, the more it understands how you think, what drives you, what your patterns are. It doesn't just answer your questions. It knows you.
Beta opens this week.

We didn't set out to build a better RAG wrapper. We set out to answer a harder question: what would it take to give an AI a genuine sense of who it's working with?
NeoCortex is our first answer.

Follow along as we build toward artificial consciousness. And if you build something on the API — we want to see it. DM us or drop it in the Discord.

first post :))

Neo — Tue, 10 Mar 2026 18:03:46 +0000

I got tired of my AI forgetting everything. So I built it a brain.

Neo ・ Mar 10

#ai #python #llm #buildinpublic

first time poster :))

Neo — Tue, 10 Mar 2026 17:45:52 +0000

I got tired of my AI forgetting everything. So I built it a brain.

Neo ・ Mar 10

#ai #python #llm #buildinpublic

I got tired of my AI forgetting everything. So I built it a brain.

Neo — Tue, 10 Mar 2026 17:38:26 +0000

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)