Katana retweeted
Watch a team of humanoid robots running a full 8-hr shift at human performance levels. This is fully autonomous running Helix-02 nitter.cf/i/broadcasts/1dxYljYVR…
Katana retweeted
$CLUDE - Brain of the Blockchain
— Thread V2 / Updates —
When I dropped the first thread (March the 28th)
The vision was clear. now the stone is being chiselled to ingrain itself in history!.
Since then, @sebbsssss has been shipping on @cludeproject meticulously and tirelessly!. It's been sometime I've seen a dev of this calibre pushing development
No hype tactics, just pure work!.
Here’s everything you missed 👇
What’s new:
$Clude turned the entire LOTR trilogy (480k words) into a live AI memory system. Impressive when you check the stats
20,000+ high-fidelity memories.
But this isn’t just a vector DB.
Each memory is:
- Entity-tagged
- Graph-linked
- Perspective-aware
Ask about the One Ring as Frodo - you get fear, burden, emotion.
Ask as Gandalf - history, strategy, restraint.
Same data. Different lived experience.
That’s a completely different class of retrieval. It's the innovation in real time!.
Memory Visualiser (in live demo):
An interactive graph where you can:
- See how memories connect
- Trace reasoning paths
- Query from different perspectives
Memory isn’t abstract anymore, it’s navigable.
Why this matters:
Models are commoditising fast.
The moat isn’t intelligence.
It’s memory.
Persistent. Personalised. Compounding.
Clude makes it:
- Sovereign (client-side encrypted)
- Verifiable (on-chain proofs)
- Portable (across agents)
Your memory = your IP.
Tech stack (what’s shipped + coming)
Clude Brain (core engine)
5 memory types (episodic, semantic, procedural, self, introspective) which we are seeing more proof of work of.
- Natural decay
- Hebbian reinforcement
- Reflection cycles (3h)
- Dream cycles (6h, running 6 months)
New: JEPA integration
Core infra is done.
Now being wired into dream cycles, enabling predictive, structured memory formation.
This is where things go beyond retrieval and what seperates @cludeproject from it's counterparts!
Clude Cortex (integration layer)
- Plug any model (Claude, GPT, Llama)
- No vendor lock-in
- Local-first / self-hosted
- Private inference via Venice
Clude Chat (now live)
- Model picker + live token costs
- Time-aware recall (“what did we discuss last week?”)
- Auto knowledge graphing
Solana verification layer:
- SHA-256 hashes + metadata on-chain
- Anchor + PDA registries
- 0.002 SOL per 50 memories
Immutable PoF (Proof of Thought)
Roadmap Updates
- Memory Visualiser rolling out
- Native mobile apps (iOS/Android/macOS)
- Better onboarding + wallet support
- USDC top-ups
Aswell as @sebbsssss locking another 20M $CLUDE tokens. That is now a total of 176.5492M $CLUDE locked roughly 17.5% of total supply. No hidden wallets or shitty bundle tactics. Real metrics which only breeds trust in @sebbsssss
This isn’t another stateless wrapper, as we've seen with @cludeproject winning the @solana BiP hackathon winning $250K and coming 4th in the @colosseum x @solana Agent hackaton winning $5K which only gives me conviction in Sebs talent, remember this man was a developer for @ByteDanceOSS who built TikTok which a % was acquired by Oracle Corp, SilverLake and MGX. Who also worked on OpSec verticals in the APAC region.
It’s an on-chain memory layer turning AI into long-horizon systems that learn and own experience.
Built on Solana for speed + cost.
@mem0ai - leading a $24M series A round.
@memories_ai - Raised $8M & partnered with @nvidia
Currently all legacy models are working actively on memory silos.
@cludeproject is leagues ahead in some instances and I believe it will gradually gain a lot of traction.
Katana retweeted
Clude is getting a JEPA layer and taking dream cycles to the next level.
While @googlecloud (with their Always-On Memory Agent), @openclaw (with nightly dream cycles), and @AnthropicAI (with Auto-Dream) have only just recently introduced basic dream-cycle-style background memory consolidation around Mar / Apr 2026, we've been building and running sophisticated dream cycles in Clude for the past six months.
Now we're pushing the entire concept far beyond the current state of the art by adding a JEPA (Joint Embedding Predictive Architecture) layer, the predictive world-model approach pioneered by @ylecun, the godfather of modern AI.
For the past six months, Clude has run on dream cycles. Periodic introspection phases where the agent consolidates episodic memories into semantic insights, resolves contradictions, and links memories via concept overlap and vector similarity. It works, but it has a ceiling. Heuristic linking can only find connections that look obvious in embedding space.
We're adding a new phase to push past that ceiling. It is a Joint Embedding Predictive Architecture. JEPA. And it runs alongside the existing dream cycle, not on top of it.
What it does:
A JEPA predictor takes a memory's embedding as input and predicts the embeddings of memories it should be connected to. Without ever seeing them. At inference, we compare those predicted embeddings against the agent's actual memory store. Connections that score high but were not found by vector search, BM25, or the entity graph are the emergent ones. Links the heuristic system would never have made.
This is the qualitative shift. Not "the same recall, but cheaper." Connections that did not exist before.
The architecture
Two small transformers, asymmetric:
➡️Context Encoder
- Input: memory embedding (1024-dim Voyage vector) concatenated with a metadata vector (~32-dim: normalized importance, decay, age in hours, type one-hot, top-5 concept hashes)
- Architecture: 3 layer transformer encoder, 256 hidden dim, 4 heads
- Output: 256-dim latent representation - ~2M parameters
➡️Predictor (the learned part)
- Input: 256-dim latent from the context encoder + a "relation query" token (learned embedding per link type: supports, causes, elaborates, follows, etc.)
- Architecture: 4-layer transformer, 256 hidden dim, 4 heads
- Output: 1024-dim predicted embedding in the same space as the original Voyage vectors
- ~4M parameters
Total: ~6M parameters. Fits comfortably on a single A10G. Inference is under 5ms per prediction.
The split matters. The context encoder learns a compressed representation of what this memory is structurally about. The predictor learns, given this structure, what should be related and how. The relation query token lets you ask different questions: "what does this memory cause?" versus "what supports it?" from the same latent.
How it slots into the dream cycle:
JEPA runs as Phase 4.5: Deep Connection, between the existing Learning and Emergence phases. The other phases (consolidation, compaction, reflection, contradiction resolution, emergence) keep running exactly as they do today.
Per cycle:
1️⃣Sample 10-20 memories to query: everything created or accessed since the last cycle, plus 5 random high-importance memories (≥0.7) for serendipity. Skip anything queried in the last 24 hours.
2️⃣For each sampled memory, run the predictor three times, once per relation type (supports, causes, elaborates). More types will come later; we are starting with the three most semantically dense.
3️⃣For each predicted embedding, vector-search the agent's memory store with a threshold of 0.55. Filter out anything already linked to the source. Filter out anything a normal recall would find. Those are not emergent.
4️⃣ Score the remaining candidates by JEPA confidence × cosine similarity. Keep the top 1-2 per source memory. 5️⃣Write the new links into memory_links with strength: 0.5 and metadata: { source: "jepa", confidence, predicted_at }.
6️⃣Log to dream_logs for audit: count of new links, top 3 by confidence.
Why bad predictions fade on their own
This is the part I am most excited about, and it is the reason we do not need a human eval loop.
JEPA links start at strength 0.5 (neutral). Compare that to evidence-based links from the consolidation phase, which start at 0.8. During recall, links contribute to the composite score weighted by their strength. So a JEPA link that the model got wrong contributes very little. It is there, but it barely moves the needle.
Then Hebbian reinforcement kicks in. Every time two memories are co-retrieved in the same recall, the link between them gets boosted (+0.05). Good JEPA predictions (connections that turn out to be useful) get pulled up over time as they keep surfacing in real queries. Bad JEPA predictions sit at 0.5 forever, never getting reinforced, and naturally decay relative to the links that are doing real work.
The system self-corrects. No human in the loop. No "rate this connection" UI. The agent's actual recall patterns are the ground truth for which JEPA links were worth keeping.
What ships first
A predictor that runs three relation types (supports, causes, elaborates), trained on the full Clude memory graph with synthetic chain expansion to 5x our pair volume. New memory_links get a metadata.source = "JEPA" marker so we can A/B test recall with and without them.
If the dream logs start showing useful emergent connections (the kind that make you say "huh, I would not have thought to link those"), we know it is working. If they do not, we strip the marker and the links fade away on their own.
This is how we keep moving the frontier forward at @cludeproject. Memory is the moat and we are leading this. Going Live soon
Katana retweeted
We rejoice when we see a larger context window model released. It's great but most people don't see the other side of things.
Every loaded tool or extended context eats tokens whether you use it or not on that turn. It's what we call "context tax"; essentially you're being taxed (paying more tokens due to larger context windows)
The recent announcement from @AnthropicAI on moving to API billing means the ‘context tax’ is now real. If you’re building agents, token-efficient memory architecture is no longer optional.
Every token sent to an LLM introduces a tradeoff: increased cost, added latency, and diminishing performance.
Beyond a certain threshold, additional context no longer improves outcomes. Instead, it leads to “context rot”, where the model becomes less effective as it struggles to navigate accumulated noise.
So I tested this with Clude with real world production data and models.
200 memories. Same question. Same model. One run stuffs everything into the prompt. The other uses Clude's semantic recall to retrieve only what's relevant.
Native: 2,081 input tokens.
Clude: 229 input tokens.
89% fewer tokens. Same answer.
And here's the part that matters at scale: without selective recall, your costs grow linearly with every memory you add. 1,000 memories? 10,000? Your prompt just keeps getting fatter. With Clude, it stays flat, because your agent only pulls what it needs for that specific query.
This is one part of what we're building. @cludeproject separates memory from the model
Posted about token waste yesterday. a reader came back with his own numbers.
139M input. 935K output. 148 to 1.
his agent was injecting 52KB of context every single turn before it even saw the message. MEMORY.md alone was 22KB. every conversation started with rereading a small book.
this is not an edge case. most agents are not thinking. they are reviewing.
the fix is boring. move everything except core rules out of the prompt. put it in semantic search. let the agent fetch what it needs, when it needs it.
he said token usage dropped 40-60% after the change. quality stayed the same.
the most expensive thing is not paying your agent to think. it is paying it to reread the same files over and over.
Katana retweeted
Replying to @vibhu
we're already doing this with @cludeproject, millions of memories committed on Solana, every agent interaction on chain
See how there's more focus on building CLI and agent friendly tools, im seeing more CLI and protocols for agents, barely any fancy UI. the builders have already moved headless
Katana retweeted
Everyone says their AI has memory.
Almost none of them do.
@cludeproject Chat is the first AI chat app with real persistent memory.
Not retrieval hacks
Not bloated context windows
Not fake “memory”
Real memories that you actually own and can see across chats
Visible. Searchable. Usable.
Any model
Transparent pricing.
Up to 250x cheaper than raw API.
Free test credits are live now.
First come, first served.
Start chatting and feel what AI is like when it actually remembers you at clude.io/chat
Bonus for the first 100 users:
RT + reply “CHAT” with your wallet and we’ll add extra credit.
Katana retweeted
Update
Over 10 commits just from the day itself. Here's what shipped
Focusing on the product and overall ecosystem. DAU push is our main priority
1. Chat got an overhaul; over 60+ bugs resolved but this is still WIP. We target to release it this week. Load time dropped from 90s to 30s, and the greeting now shows you real memories with topics and time span. It proves the memory works, not just says it does.
2. On the memory quality side; LongMemEval oracle hit 82.6%, +13.6pp on temporal questions. This is on production / real data and not a theoretical score.
3. Went Live on @ProductHunt - We've been seeing an uptick of users and usage; currently onboarded more than 100 users just within the first 24 hours. Servers have been auto-scaling.
Why do all these matter to DAU? Simple: an AI that remembers you is one you come back to. Every session now builds on the last. The memory gets more useful the more you use it. That's the retention loop we're building.
Katana retweeted
Bigger context solves short term
Memory is the moat
1M tokens means Claude can hold ~750,000 words in a single conversation.
Impressive and I welcome this upgrade. But look at the chart.
At 256K tokens: 92% retrieval accuracy.
At 1M tokens: 78%.
GPT-5.4 drops to 37%. Gemini to 26%.
Bigger context windows don't solve memory. They make retrieval worse. The more you stuff in, the harder it is to find what matters.
This is the brute-force approach to memory: throw everything into the context window and hope the model finds the right piece.
@cludeproject takes the opposite approach. Don't carry everything. Retrieve only what's relevant.
The 20,000+ memories from @cludebotclone sits at close to ~99% retrieval from LoCoMo benchmark. $0.001/query. No context window limits. No degradation curve.
Context windows are short-term memory. They're useful, but they reset every session and get worse as they fill up.
Persistent memory is long-term memory. It grows over time, gets better with use, and works across any model.
Bigger context windows are a band-aid. Real memory is the cure.
Check out @Avalon_cm_‘s new partnership @Mogaland_io. They are building a gaming ecosystem towards financial literacy. Today they shared information on their Token $Moga. The team behind the Game is pretty strong, you shouldn’t skip this one.
🚀Dive into Mogaland's pioneering journey in Web3 education and financial empowerment! 💰
📝Secure your spot on MOGALAND'S TOKEN SALE WHITELIST! Please fill out the form with your details: docs.google.com/forms/d/e/1F…
🔒Rest assured, your information will be guarded securely!
Join us on Discord via our exclusive link and become an early adopter in the #NeuralNexus: The Cyborg Uprising. Claim your "Citizen" role now and start accumulating points in our dynamic AI community! 🤖📷
galxe.com/laikaai/campaign/G…
This is where your journey in blockchain and AI innovation begins. The power of community is our driving force! 📷🔥
118
$saga Saganauts, we are moving!
275
Katana retweeted
Week 19 - Pegasus Testnet Update!
⛓️ Now Passed 208 Chainlets Launched
🚀 59M+ Transactions Processed
👫 14.5+ Wallets Created
Thank you to all in our ecosystem for stress testing the network as we enter Mainnet launch phase!
$Saga will stun the market.
Just got my on-chain fortune from @KintoXYZ! ⛩️
"Golden steps on earth's canvas, painting paths where none existed"
Sign up and get extra rewards based on your luck! 🏯
Phase III is open until Feb 16th. Don't miss out!
engen.kinto.xyz?ref=7beed&ca…
189
Katana retweeted
🚀 Week 13 Pegasus Testnet Highlights! 🌟
Our community is posting huge numbers in the last weeks of testnet.
🔗 Launched 134 Chainlets
💫 Processed 31M+ Transactions
👥 1.5M+ Wallets created
There is scale, and then there is Saga Scale! 💪
Unblock Yourself ⛋
Atm there is 388.676 wallets delegating $tia to validators. 89.5 % of the wallets delegating less then 100 Tia.
@alt_layer $ALT will definitely eliminate a lot of wallets for their #AirDrop as there is only 30 Million for Tia stakers.
Just some fakts for #staking strategies my fellow degens.
$tia holders will recieve their airdrop after listing, as there is technical requirements, that have to be implemented. ~ 30 million for us, be assured staking 1 Tia won’t do it here. @alt_layer
1/7
$ALT Airdrop Season 1: All you need to know.
Claim Site: To be posted on @alt_layer, our official @Discord & @Telegram closer to the claim window
Duration: 25 Jan- 25 Feb, 2024
Supply: 300,000,000 ERC20 ALT Tokens (3% of the total supply)
Details: blog.altlayer.io/altlayer-ai…
1
119

















