Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

Xiaomi just dropped a FREE CLAUDE CODE with memory that actually persists between sessions and nobody is talking about it MiMo Code dropped 4 days ago. 8k GitHub stars. Built-in free model called MiMo Auto - you just install it and it works, zero configuration, zero API keys What's...

64,582 Aufrufe • vor 3 Monaten •via X (Twitter)

33 Kommentare

Profilbild von Sajid AI
Sajid AIvor 3 Monaten

Open-source AI tools are evolving fast 🚀 MiMo Code looks seriously promising.

Profilbild von FckThaFeds
FckThaFedsvor 3 Monaten

I mean couldn’t you use use Hermes. It already does all this.

Profilbild von monokern
monokernvor 3 Monaten

Find more AI tools worth actually using in my TG channel:

Profilbild von Gipp 🦅
Gipp 🦅vor 3 Monaten

Xiaomi is now also starting to study AI

Profilbild von monokern
monokernvor 3 Monaten

competition is increasing and this is encouraging

Profilbild von Xatacrypt
Xatacryptvor 3 Monaten

thanks, I'll try it later

Profilbild von Deydara
Deydaravor 3 Monaten

Thanks for the guide—it’s been really helpful lately

Profilbild von Samian
Samianvor 3 Monaten

zero config local coding with persistent memory is the angle people are sleeping on. curious how the memory layer actually works tho, is it just file-based context or something smarter?

Profilbild von Dekos
Dekosvor 3 Monaten

This new product is definitely worth trying

Profilbild von Alex
Alexvor 3 Monaten

wow, i need to test it today. thanks

Profilbild von monokern
monokernvor 3 Monaten

waiting for ur feedback

Profilbild von Lummox
Lummoxvor 3 Monaten

So looks bullish things to make money nonstop

Profilbild von slash1s
slash1svor 3 Monaten

hmm will check it bto

Profilbild von monokern
monokernvor 3 Monaten

ok broski, waiting for your feedback

Profilbild von Hussain Hashim | Building SundayBack
Hussain Hashim | Building SundayBackvor 3 Monaten

@monokern wait what?? how did i miss this? sounds like a total game changer, gonna check it out asap

Profilbild von MrGreenie
MrGreenievor 3 Monaten

for anyone looking at memory tools AtomicMemory is worth checking out. open source, self-hosted, fully inspectable. you can actually see what your agent knows and correct the parts that are wrong.

Profilbild von Nicolò Boschi
Nicolò Boschivor 3 Monaten

session persistence is absolutely crucial for agents to be truly useful over time. that's exactly why we built hindsight, an open source memory system.

Profilbild von Charlie · 云马AI · 免🪜稳连 Claude/GPT/Gemini API
Charlie · 云马AI · 免🪜稳连 Claude/GPT/Gemini APIvor 3 Monaten

这个点确实容易被低估。我觉得代码工具最烦的不是模型不够聪明,是每次重开都要重新交代上下文。能把记忆做扎实,日常写项目会省很多碎碎念。

Profilbild von Murmur
Murmurvor 3 Monaten

All things from Xiaomi are built different

Profilbild von monokern
monokernvor 3 Monaten

what do u mean, friend?

Profilbild von Murmur
Murmurvor 3 Monaten

Cheap+great

Profilbild von Long 7
Long 7vor 3 Monaten

You exceeded your current quota, please check your plan and billing details. For more information on this error, read the docs:

Profilbild von 晚晚
晚晚vor 3 Monaten

不用配钥匙还保留记忆,门槛确实低

Profilbild von AI Pixels
AI Pixelsvor 3 Monaten

What are the daily limits?

Profilbild von beamnxw ./
beamnxw ./vor 3 Monaten

XIAOMI COOKING

Profilbild von kiosa
kiosavor 3 Monaten

We need more free tools

Profilbild von Nostaline
Nostalinevor 3 Monaten

very interesting as memory infrastructure should respect developer autonomy. AtomicMemory does: open source, self-hosted, fully inspectable. You control what your agent believes and how it evolves.

Profilbild von Asteri
Asterivor 3 Monaten

Xiaomi really shot with MIMO CODE

Profilbild von Nick Venturi
Nick Venturivor 3 Monaten

downloading this before they start charging

Profilbild von Insomnia
Insomniavor 3 Monaten

absolute free to use this

Profilbild von monokern
monokernvor 3 Monaten

yep, and this is the main thing

Profilbild von MicrotronX
MicrotronXvor 3 Monaten

mimo code validates the premise exactly: session state doesn't belong in the context window. the real question is what happens when compaction hits mid-task - persistent sessions patch the symptom, not the architecture.

Profilbild von SLOT.WIN
SLOT.WINvor 3 Monaten

i just spun the wheel and got free ai magic xiao mi knows how to make luck real

Ähnliche Videos

Another insane Jev use case! Jev makes it incredibly cheap to evaluate and classify agent runs at scale. And finally, someone open-sourced a self-improving memory layer that can put that capability to work across agent harnesses. It turns your agent sessions into a compounding knowledge layer, where every successful run can make future agents smarter across: - Codex - Claude Code - Cursor - OpenCode and 20+ more Beacon by Asymptote Labs continuously builds a shared history across your agent harnesses and uses Jev to identify the runs worth learning from. It then turns the best workflows, corrections, and debugging patterns into reusable skills. GitHub repo: (don’t forget to star it ⭐) Most agent runs are messy. They contain exploration, failed commands, dead ends, and one-off fixes that should never become permanent memory. So Beacon preserves the full session history, while Jev helps decide what should be promoted, reviewed, or discarded. The recording below shows this in action. Beacon found 579 sessions across 5 coding-agent harnesses and normalized them into one consistent history. From there, Jev surfaces the lessons worth keeping and makes them available across your agent stack. - A pattern learned in Cursor can carry into OpenCode. - A lesson from Claude Code can improve the next Codex run. Every successful run adds to the shared knowledge layer, making future agents smarter. If you want to dive deeper into Jev, I also wrote a breakdown of how it works. The article is quoted below.

Akshay 🚀

119,118 Aufrufe • vor 9 Tagen

HERMES AGENT LEARNS FROM ITS OWN MISTAKES. UPDATES ITS MEMORY. CREATES ITS OWN SKILLS. NO CLOUD. EVERYTHING STORED LOCALLY. THIS IS HOW THE SELF-IMPROVING LOOP WORKS. most agents start from zero every session. Hermes carries forward what it learned. THREE MEMORY SYSTEMS: 1. PROCEDURAL MEMORY (how to act) stored in ~/.hermes/skills/ as SKILL.md files. when the agent repeats a complex workflow, it saves the procedure as a reusable skill. next time the same task comes up, it follows the skill instead of figuring it out again. you can also create skills explicitly: "create a skill called video-prep that captures how I format my video scripts. spoken english, define jargon inline, no em-dashes, close with a catchphrase." the agent writes the SKILL.md. available as a slash command from that moment. Hermes ships with 90+ skills. the number grows the longer you use it. 2. SEMANTIC MEMORY (durable facts about you) stored in ~/.hermes/memory/memory.md the agent scans conversations for facts worth remembering. preferences, habits, corrections, project details. real example from the video: agent tried to scrape a YouTube channel. URL was wrong. it failed. it updated memory.md with the correct URL pattern so it never makes the same mistake again. you can also save explicitly: "save to memory that my favorite testing framework is pytest" the agent updates memory.md immediately. this file loads into context on every session. the agent knows you better every week. 3. EPISODIC MEMORY (chat history) stored in ~/.hermes/state.db (local SQLite). every conversation. every tool call. every result. searchable with FTS5 full-text search. "search our past sessions. what was the first thing I ever said to you?" the agent queries state.db and finds it. over time, auxiliary models consolidate episodic memory into semantic memory. distilling recurring patterns into durable facts. THE SELF-IMPROVING LOOP: every agent run follows this cycle: → you send a prompt → working memory loads: SOUL.md + memory.md + relevant skills + chat history → agent calls tools (terminal, browser, delegate_task) → agent completes the task, replies to you → AFTER the reply: agent checks "did I learn something worth saving?" → if yes: updates memory.md or creates a new skill → next session starts smarter than the last this happens automatically. you don't ask the agent to learn. it decides what to remember on its own. WHAT MAKES THIS DIFFERENT FROM CLAUDE CODE: Claude Code has memory too. but Hermes stores everything locally. no cloud. your data never leaves your machine. Claude Code doesn't auto-create skills from experience. Hermes turns repeated workflows into reusable procedures. Claude Code memory is instruction-based. Hermes memory is conversational and self-updating. over months of usage, Hermes builds a knowledge base of your preferences, your projects, your mistakes, and the procedures that work for your specific workflow. the agent that remembers your birthday also remembers why your last deploy failed. NO EMBEDDINGS. PLAIN TEXT. Hermes does not use embeddings or RAG for memory. skill and memory search runs on plain text keyword matching. simpler. faster. no vector database to maintain. works entirely offline on your local machine. DELEGATE TO CLAUDE CODE: Hermes can spawn a sub-agent that runs Claude Code in headless mode: "spawn a sub-agent using Claude CLI to build a Python script that fetches the top 5 Hacker News stories to markdown." Hermes delegates. Claude Code writes the code. result returns to Hermes. Hermes runs the script and delivers the output. use Hermes for orchestration. use Claude Code for heavy coding. both tools. not competitors. WHAT HERMES DOES NOT HAVE: no built-in eval or LMOps system. no LangSmith, no LangFuse integration out of the box. trajectory export and logs exist but there is no automated quality tracking. if you need eval, build it yourself or connect external tools. the loop is self-improving. measuring how well it improves is on you. comment LOOP and I'll send you the configs that control how fast Hermes learns and what it remembers. memory limits, skill auto-creation triggers, and the auxiliary model that runs the learning. Replace your entire team with 8 hermes agents👇

YanXbt

22,720 Aufrufe • vor 2 Monaten

THIS MIGHT BE THE #1 OPEN-SOURCE REPO FOR CLAUDE CODE RIGHT NOW. IT GIVES CLAUDE A MEMORY AND SLASHES YOUR TOKEN COST ON EVERY QUESTION The repo is safishamsi/graphify, a free open-source skill that turns any codebase into a knowledge graph Claude Code can read instantly. Instead of grepping through your files every session, Claude gets a map of how everything connects The problem it fixes: Every time you ask Claude Code about a big repo, it does the same thing, greps through dozens of files like a brute-force Ctrl+F, blows through your context window, and sometimes still misses the answer hiding in a file nobody searched. Claude Code has no memory of how your project is structured. Every session starts from zero What it does: It maps your entire codebase into a knowledge graph, capturing not just which files exist, but which functions depend on which, which modules are central, and which files cluster around the same concern. Claude queries the map instead of scanning files How it works, three passes: 1. Code structure, free and local. Tree-sitter parses your files and pulls out classes, functions, imports and call graphs. No LLM, no tokens, just your actual code mapped deterministically 2. Audio and video, if you have them. Transcribed locally and folded into the graph 3. Docs, papers, images. Here an LLM does semantic analysis, figuring out what each document means and where it fits. Only the meaning gets sent up, never your raw source It saves you money: Normally a question about a big repo makes Claude spawn explore agents that scan file after file, eating your context window and your token budget before you get an answer. With the graph already built, Claude queries the map instead of re-reading the codebase every time. Same answer, a fraction of the tokens. The graph only gets built once, then a hook rebuilds it after each commit for free, so you never pay that scanning cost again. The bigger the repo, the bigger the gap The best parts: it's a skill, so once installed Claude knows when to use it without you memorizing commands. It works on non-code folders too, point it at docs or notes and it can spin up an Obsidian vault How to add it to your Claude: 1. Install Claude Code if you haven't: npm install -g Paul Jankura-ai/claude-code 2. Add the skill: claude skill add safishamsi/graphify 3. Open your project folder and run /graphify . to build the graph 4. Optional, make it automatic: graphify hook install so the graph rebuilds after every commit That's it. Ask Claude about your repo and it reads the map instead of burning tokens on a file hunt Bookmark this

Yarchi

56,502 Aufrufe • vor 3 Monaten

Hermes agent just left the terminal. 𝗛𝗲𝗿𝗺𝗲𝘀 𝗗𝗲𝘀𝗸𝘁𝗼𝗽 dropped yesterday. native app for macOS, Windows, and Linux. for months Hermes was the agent that learned your projects, wrote its own skills, and built a model of who you are. all of it buried in terminal logs. now it has a window. the important part is that it's not a wrapper. it runs the same agent core, the same sessions, memory, and skills as the CLI. you can start a task in the terminal and finish it in the app without anything resetting. the state is shared across every interface, not copied between them. what the GUI actually adds: → streaming chat that shows live tool calls and inline reasoning instead of a spinner → a preview rail that renders pages, code, and images right beside the conversation → an artifacts panel that collects every file the agent has ever produced → remote gateway mode, so you can point the app at a VPS and run the heavy work elsewhere → skills, cron, profiles, and gateways managed point-and-click instead of through YAML → voice mode, drag-drop files, and inline image generation remote gateway mode is the one worth slowing down on. the agent runs 24/7 on a $5 server while you control it from your laptop like a local app. other agent UIs are chatboxes with a logo. this one shows the autonomy instead of hiding it, so you watch the skills load, the tools fire, and the artifacts pile up as it works. it was teased in Jensen's GTC keynote. MIT licensed, local-first, no telemetry. if you already run Hermes, download it and everything is already there. your chats, memory, and skills carry straight over. i wrote a full masterclass on Hermes Agent that walks through the SOUL. md identity layer, the three-tier memory system, the self-evolving skills loop, and how to run three specialized agents 24/7. desktop is the interface that finally does all of it justice. the article is quoted below.

Akshay 🚀

51,540 Aufrufe • vor 4 Monaten

Another insane Jev use case! Jev is making it dramatically cheaper to evaluate what actually happened inside an agent run. And finally, someone open-sourced a self-improving memory layer that can put that signal to work across agent harnesses: - Claude Code - Codex - Cursor - OpenCode, and 20+ more Beacon by Asymptote Labs continuously captures your agent history across harnesses and uses Jev to identify which runs are actually worth learning from. It then turns the highest-signal workflows, corrections, and debugging patterns into reusable skills. GitHub repo: (don’t forget to star it ⭐ ) Beacon preserves the complete session history. But preserving a run and learning from it are two different things. Most coding-agent sessions contain routine exploration, failed commands, and fixes that only apply to one task. The trace can remain available for inspection without turning every detail into guidance for future agents. Jev scores each run for evidence, reuse potential, and human correction signals. An application policy then decides whether to promote, review, or discard it. The recording shows this in action. Claude receives a coding task, modifies the implementation, and runs the tests. I then provide an edge-case correction, so Claude updates the code and adds regression coverage. Beacon automatically captures the complete session. Jev evaluates whether the correction contains a reusable engineering lesson. Once approved, that lesson becomes available to other coding agents working on the project. Since it works across harnesses: - Claude Code sessions can teach Codex. - Cursor debugging can improve OpenCode. So a problem solved by one agent should not need to be learned from scratch by another. If you want to dive deeper into Jev, I also wrote a hands-on guide to building this Jev-style decision path with open models, entirely locally. Read it below.

Avi Chawla

290,485 Aufrufe • vor 11 Tagen