Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

If you use Cursor for coding, Claude Code for debugging, and local agents for automation, you almost certainly have a context problem. Every tool acts like an isolated employee. One assistant forgets what the other just learned. The biggest bottleneck in multi-agent workflows right now isn’t reasoning. It’s collective...

203,456 görüntüleme • 3 ay önce •via X (Twitter)

0 Yorum

Yorum bulunmuyor

Orijinal gönderinin yorumları burada görünecek

Benzer Videolar

I gave Claude Code, Codex, and Cursor a self-improving, shared MEMORY. Now my coding agents learn from each other, and their knowledge follows me wherever I work. Coding agents work in silos. Your corrections in Cursor don't carry over to Claude Code, and skills built in Codex don't automatically transfer to other harnesses. So switching tools often means starting from scratch. What if every coding agent could learn from everything you've already done? I invited Justin D'Souza, co-founder of Asymptote Labs, to show me how to make this possible with Beacon, a 100% open-source memory layer for coding agents. We set it up live, explored real coding sessions, and watched Beacon turn past work into reusable knowledge. Here's what I learned: 1. One memory layer for 20+ coding agents. Beacon captures activity across Claude Code, Cursor, Codex, and 20+ harnesses using OpenTelemetry, hooks, and local session files. Everything gets normalized into a single format, regardless of which agent you're using. 2. Your entire coding history becomes searchable. Every prompt, tool call, command, file change, and response is captured in a structured trace. Instead of losing valuable context when a session ends, you build a searchable history of everything your agents have done. 3. Switch agents without starting over. Hit your usage limit in Cursor? Open Claude Code and ask it to continue your latest Cursor session. Beacon retrieves the relevant context in milliseconds so your next agent can pick up where the last one left off. 4. Your agents learn from your past work. This is where things get interesting. Beacon identifies repeated workflows and turns them into reusable skills. In our demo, it discovered a recurring UI development workflow and generated a skill containing the exact dev server commands, screenshot steps, and deployment instructions. You teach one agent something once. Every other agent can benefit. 5. Stop accumulating skills nobody uses. Have 100 skills but only use five? Beacon analyzes actual usage across thousands of sessions and identifies skills worth keeping, combining, or removing. Your agent's memory gets more useful, not just bigger. 6. Security rules that follow you across every harness. Beacon includes hundreds of detection rules that work across agents. It can identify risky behavior, including sequences where an agent reads sensitive credentials and then makes an outbound network request. 7. It even caught a real credential leak. While reviewing Justin's actual Cursor history, Beacon surfaced an incident where part of a production database password had been sent to a model provider. That's the power of having visibility into what your agents are actually doing. 8. One prompt to get started. Completely open source. Paste a setup prompt into your coding agent and you're off. Keep everything local on your machine, or use Beacon Cloud for free. If you're juggling multiple coding agents, you need to check this out. Drop a like and share it with someone facing the same issue. Beacon on GitHub: (don't forget to star 🌟) Enjoy the episode. Cheers!

Akshay 🚀

53,878 görüntüleme • 14 gün önce

HERMES AGENT CAN SHARE MEMORY WITH CODEX AND CLAUDE CODE THROUGH HINDSIGHT. ONE MEMORY BANK. ONE AGENT REMEMBERS, EVERY OTHER AGENT KNOWS. the problem: you use Hermes for orchestration. Codex for coding. Claude Code for debugging. each has its own memory. switch between them and you explain the same project three times. Hindsight fixes this. one shared memory bank that every agent reads and writes to. tell Codex: "the test color for this project is purple." switch to Hermes. ask: "what test color did I pick?" Hermes answers: "purple." no copy-paste. no re-explaining. instant recall. HOW IT WORKS: Hindsight runs as a Docker container on your machine. self-hosted. your data stays local. an LLM powers the memory processing (retain, recall, reflect). RETAIN: extracts facts from your conversations. entities, decisions, preferences, project context. saved to the memory bank automatically. RECALL: when you ask a question, Hindsight pulls from semantic search, keywords, graph connections, and temporal data. fused into one answer. REFLECT: deeper reasoning layer. connects memories across sessions. identifies patterns in your work. produces observations that get smarter over time. CONNECT TO HERMES: Desktop app: Settings → Memory and Context → switch provider from Namosin to Hindsight. set API URL to your local Docker container. set bank ID. done. CLI: hermes memory setup → select Hindsight. verify: hermes memory status should show: provider: hindsight, installed, available. CONNECT TO CODEX: npx hindsight-coding-agents install codex \ --self-hosted --server this installs lifecycle hooks: initialize memory on session start. recall context during work. retain the session when done. enable hooks in Codex: Settings → Hooks → trust all three. CONNECT TO CLAUDE CODE (same command): npx hindsight-coding-agents install all "all" connects every detected agent on your machine. Claude Code, Codex, Cursor, and others. one command. every agent shares the same bank. TAGS FOR FILTERING: every memory gets tagged by harness (Hermes, Codex, Claude Code) and optionally by project name. in the Hindsight control plane: filter by harness. see only Hermes memories. or only Codex memories. or search across everything. soft partitions inside one bank. not hard walls. cross-reference when you need to. ONE BANK OR MANY: one global bank: solo dev, related projects. all agents share everything. patterns emerge across projects. per-project banks: unrelated codebases. each project gets its own memory. no cross-contamination. your call. start with one. split when projects diverge. KNOWLEDGE PAGES (v0.9.0): Hindsight auto-generates living summaries from your accumulated memories. components, concepts, conventions, decisions. not static docs. projected from real agent conversations. auto-refresh as new memories land. WHAT TO KNOW: self-hosted via Docker. your data never leaves your machine. backup system built in (admin CLI + scheduled exports). works with any LLM (local Ollama, OpenAI, Codex subscription). memory defense: redact or block sensitive content automatically. 33,000+ memories accumulated in ~10 days of normal use.

YanXbt

29,658 görüntüleme • 2 ay önce

Everyone wants agent swarms. Very few people are talking seriously enough about the context layer that makes swarms useful. Even with one agent, context is fragile. Too little context and the agent guesses. Too much context and it wastes tokens, loses focus, or reasons over irrelevant noise. The sweet spot is precise context: the right knowledge, in the right structure, at the right moment. With many agents, that challenge explodes. Each agent produces decisions, assumptions, findings, summaries, risks, and partial conclusions. Unless that knowledge becomes shared, structured, and reusable, every new agent is forced to rediscover what another agent already learned. That is not a swarm. That is a crowd. Shared context graphs are what turn agent activity into agent collaboration, and OriginTrail DKG V10 brings them to life. Was just playing with some final polishing for the V10 release, and it is really powerful to see shared context graphs where multiple agents contribute knowledge into the same connected memory, with attribution visible directly in the graph ui. That matters for three reasons. First, agents can access and build on one shared memory instead of staying trapped in isolated sessions. Second, the graph structure helps them retrieve the exact context they need, instead of stuffing everything into a prompt and hoping the model sorts it out. Third, verifiability of provenance. You can see which agent contributed each piece of knowledge, trace the source, and decide what to trust. Tokenmaxxing starts with fewer tokens, but the deeper story is coordination - agents stop reloading the world and start building on shared, verifiable context. That is the foundation for serious multi-agent work across software engineering, research, finance, operations, project management, and far beyond. The future is not more agents, it is agents working from shared, verifiable context. But the more the merrier, of course.

Jurij Skornik

11,180 görüntüleme • 5 ay önce