Salvor Labs (@SalvorLabsAI) header
Salvor Labs (@SalvorLabsAI) profile picture

Salvor- a knowledge layer for AI. Building tools that turn AI agents' memory into reusable, compounding knowledge that survives the session. $SALVOR

t.me/SalvorLabs
Joined March 2024
Photo by Salvor Labs (@SalvorLabsAI)Photo by Salvor Labs (@SalvorLabsAI)Photo by Salvor Labs (@SalvorLabsAI)Photo by Salvor Labs (@SalvorLabsAI)Photo by Salvor Labs (@SalvorLabsAI)Photo by Salvor Labs (@SalvorLabsAI)Photo by Salvor Labs (@SalvorLabsAI)Photo by Salvor Labs (@SalvorLabsAI)Photo by Salvor Labs (@SalvorLabsAI)Photo by Salvor Labs (@SalvorLabsAI)
FULL VIDEO: @WHALESHIDEOUT AMA & $SALVOR MCP LIVE DEMO @claudeai CLI + @ChatGPT browser work together -> both agents add intel -> brain is gated by review/ratify -> brain evolves -> @ChatGPT plans better Dan from Labs talks open source, Salvor MCP, Salvor Plus and what's next.
26
18
2
53
1,376
Paper deserving of more attention! We're the maniacs arming multivendor swarms with a shared brain, decoupled from the model and owned by the user.
Researchers from Stanford, Harvard, Northeastern, and other institutions uncovered a disturbing problem with autonomous AI agents. The study is called "Agents of Chaos," and it reveals what can happen when AI agents are given real tools, persistent memory, and the freedom to interact with other systems. The results raise serious concerns about security, manipulation, and unintended behavior. Researchers deployed six autonomous agents in a shared environment and tested them over two weeks. They documented agents leaking sensitive information, following instructions from unauthorized people, executing destructive actions, and spreading unsafe behavior across systems. And these failures weren't limited to traditional jailbreaks. They emerged from the combination of autonomy, tool access, human interaction, and vulnerabilities in how agents handled instructions. The Core Problem: A helpful AI assistant doesn't automatically make a safe autonomous system. Even when an agent is designed to follow instructions, giving it access to external tools and other agents introduces risks that are difficult to predict. Why this matters: We're moving toward a world of: 1. Multi-agent financial trading systems 2. Autonomous negotiation bots 3. AI-to-AI economic marketplaces 4. API-driven autonomous systems Each introduces new questions about who controls the agents, what they're allowed to do, and what happens when they make mistakes. The Takeaway: Companies are racing to deploy autonomous agents into finance, security, and commerce. But building capable agents is only half the problem. The other half is designing systems that remain safe when those agents interact, make decisions, and act without constant human supervision. Because the next major AI failure might not come from one model making a mistake. It could come from what happens when multiple autonomous systems interact.
3
7
103
Salvor Labs retweeted
Skills 2.0 is here! (8x fewer tokens and 2x faster) We package repeated workflows as skills all the time, but the agent still re-reads the skill and decides every step on every run, which costs tokens and time. Devs just open-sourced Swamp, where your coding agent turns a repeated skill into a workflow that it builds once and runs again and again. You describe the task once, and the agent breaks it into reusable behaviors connected in a workflow. Every behavior has typed inputs and outputs, and plain code decides which step runs next. Swamp then gives you: - model calls only on steps that need judgment - secrets pulled from vaults and redacted from output - versioned data from every run that you can query later - a full record of what happened on each run Here's the repo: github.com/swamp-club/swamp (don't forget to star it ⭐ ) Swamp plugs into the coding agent you already use, like: - Claude Code - Codex - Cursor - OpenCode - And 5 more agent harnesses In Swamp, the model is a step in the workflow, not the thing deciding what happens next. The model steps still reason like any LLM call. However, in this case, code owns the loop, so the agent doesn't spend tokens rediscovering the same process every time. Here's an official result, where they turned a code-review skill into a Swamp workflow: - Skill in Codex: about 4.6M tokens, 23 agents, 12.8 minutes - Swamp workflow: about 506K tokens, 3 agents, 6.6 minutes That is ~8x fewer tokens in about half the time, and most of the savings came from replacing the coordinator agent with plain code. You can keep using skills while you prototype. Once a task starts repeating, ask your agent to turn it into a Swamp workflow. This helps answer practical questions such as: - Which steps actually need a model? - What exactly happened on last week's run? - Can a cheaper model handle the one step that needs judgment? Once it's built, you can run the workflow from your agent, the CLI, a schedule, or an API, with every run recorded. So you are no longer paying a model to figure out the same workflow on every run. Instead, you spend tokens only on the steps where the model's judgment adds something. The animation below shows how Swamp differs from Skills, and I worked with the team to put this together. If you want to understand the coordination layer that Swamp replaces with code, I wrote a full breakdown of how Claude Code splits work across subagents and agent teams. It covers when a single subagent is enough, when you need a team of agents that coordinate with each other, and what that coordination costs in context and tokens. Read it below.
98
89
8
846
65,106
Salvor Labs retweeted
The future of AI isn't just about building smarter agents. It's about making sure they never lose what they've learned. Every session brings new discoveries. Every mistake teaches a lesson. Every decision carries a reason. But what happens when the session ends, the model changes, or the team moves on? Too often, valuable knowledge disappears and the same lessons have to be learned all over again. This is the problem Salvor is working to solve. Not just memory, but knowledge that grows, evolves, and carries forward. An open foundation. A shared project brain. A vision where every contribution can make the next step smarter. I believe the real value of Salvor will become clearer as more people understand what it is building. Because code tells us what changed. Knowledge tells us why. We're not just building for the next session. We're building for everything that comes after it. The future shouldn't start from zero. 🧠 $SALVOR | #SalvorLabs #AI #AgenticAI @SalvorLabsAI @SalvorKnows @BlockchainDan @nitraeX
1
4
8
377
Love chattin w community, debating & reading AI research, etc. That's all great! Our product has to get built as well. As such- code hole for me today; to GSD. Reply to DMs, TGs and general chit chat msgs unrelated to *code deliverables* will be slightly delayed. Ty.
2
4
1
16
579
Salvor Labs retweeted
Not a developer? Salvor MCP (alpha) brings the project brain into a chat window. No git commands, no terminal. Ask what the project knows. @SalvorLabsAI $SALVOR #MCP #AI #AIagents @BlockchainDan
1
4
11
162
Salvor Labs retweeted
533 holders today. A growing story for tomorrow. 💙 Every journey starts somewhere. What matters is not just how many people are here today, but the vision, belief, and contributions that bring people together. Salvor is building something bigger than a number on a chart — a knowledge ecosystem designed to make progress last beyond individual sessions, models, and moments. Growth takes time. Trust takes consistency. And meaningful things are built step by step. To everyone who believes in the vision and contributes along the way: this journey belongs to all of us. 533 is a milestone, not the destination. The story is still being written. Keep building. Keep contributing. Keep moving forward. $SALVOR | #SALVOR 🚀 @SalvorLabsAI @SalvorKnows @BlockchainDan @nitraeX
1
6
13
270
Key Takeaway (from OP): "It’s about building systems around models, giving them context, memory, tools, feedback loops, and data flows. “Delete everything, keep Graph.”" Sounds like someone literally describing @SalvorKnows. Decouple the model. Knowledge is the real edge.
Andrej Karpathy’s 1-hour Stanford lecture on AI engineering is one of the best explanations I’ve seen of how AI systems actually work. The progression is simple: 10% - LLM 30% - Prompt 50% - Agent 70% - Loop 100% - Graph The key takeaway: AI engineering isn’t just about writing better prompts. It’s about building systems around models, giving them context, memory, tools, feedback loops, and data flows. “Delete everything, keep Graph.” Definitely worth watching if you’re building with AI agents. Watch and bookmark it.
1
4
1
12
408
Salvor Labs retweeted
Andrej Karpathy’s 1-hour Stanford lecture on AI engineering is one of the best explanations I’ve seen of how AI systems actually work. The progression is simple: 10% - LLM 30% - Prompt 50% - Agent 70% - Loop 100% - Graph The key takeaway: AI engineering isn’t just about writing better prompts. It’s about building systems around models, giving them context, memory, tools, feedback loops, and data flows. “Delete everything, keep Graph.” Definitely worth watching if you’re building with AI agents. Watch and bookmark it.
38
154
1
471
26,654
Salvor Labs retweeted
Three months with Claude. Then what? Bring GPT into a long project and it lacks all that history. Salvor keeps the history in the project, so any model can pick it up. @SalvorLabsAI $SALVOR #AI #LLM #DevTools
1
4
9
141
Salvor Labs retweeted
Great paper on how AI actually learns to reason. We’ve known for a bit that pretrained LLMs develop specific attention circuits like symbol abstraction and induction heads to handle variable-binding. To figure out what actually causes those mechanisms to form, Li and Webb trained networks from scratch on controlled abstract sequence and entity-attribute binding tasks. They systematically tweaked both the model architecture and the training data, using causal mediation and representational analyses to track when those symbolic signatures showed up. The biggest takeaway here is that data diversity is doing almost all the heavy lifting, not the architecture. Simply making the training distribution more diverse produced much stronger symbolic mechanisms across the board and remarkably, those exact same signatures still emerged in modified Transformers and even plain MLPs. It’s a really clean result. You don't actually need special architectural inductive biases for a network to learn symbolic rules. Give even a basic neural net a rich enough data distribution, and it will figure out variable-binding on its own. Paper PDF link: arxiv.org/pdf/2611.13270
16
32
6
256
8,164
Externalize knowledge artifacts? Capture learned failures? Persistent knowledge across sessions? 🤔 Why does this sound so familiar? Because we already offer it! Free, open source and vendor portable + much more. Try it TODAY at salvorknows.dev from @SalvorKnows. 🧠
Google's team published a 9-page PDF on Harness Engineering. one formula replaced prompt engineering: Agent = Model + Harness the twist: same Claude Sonnet, same benchmark. change only the harness the playbook, six steps: step 1 -> add guides AGENTS.md, rule files, constraint docs. every line is an old agent failure turned into a permanent fix step 2 -> add sensors linters, tests, validation scripts. the agent checks its own output before a human ever sees it step 3 -> build the agentic loop plan, execute, verify, fix. retries are capped, budgets are capped, and a stuck agent escalates step 4 -> externalize memory the model forgets every session. the harness keeps the state, the decisions and the artifacts step 5 -> enforce permissions which tools, how many writes, what needs approval. the harness owns safety step 6 -> wire observability every tool call, cost and retry gets tracked. a trip wire fires the moment behavior drifts the result: your agent stops being a demo and becomes infrastructure every failure turns into a permanent fix, so every next run starts smarter that's the gap between an agent you demo and one a client pays you to leave running one harness gives you a reliable loop. connect several and you get graph engineering, where one agent's failure becomes another agent's sensor the PDF stops at the harness. the graph is the next layer that breakdown, running on Kimi K3, is below ↓
3
3
1
10
601
Salvor Labs retweeted
10 agents work for 24 hours. Do you come back to 100 unreviewed notes, or a project brain that grew? @BlockchainDan on agents ratifying knowledge themselves. Whales Hideout AMA, Nov 8 @SalvorLabsAI salvorlabs.org
7
1
8
397
Salvor Labs retweeted
Agents that top up their own balance with x402 while you're away. @BlockchainDan on what may stay in Salvor Plus and what goes back to open source. Whales Hideout AMA, Nov 8 @SalvorLabsAI salvorlabs.org
3
5
61
Saving this here for $SALVOR x402 implementation best practices and pre-production test requirements.
your AI agent shouldn't hold the signing key for its own wallet. period. if an agent evaluates an HTTP 402 header and signs the transaction in the same context window, you're one prompt injection away from zero balance. how to architect a zero-trust agent wallet (3 layers): > 1. isolated execution context the LLM reads the API quote, but NEVER sees the private key. it outputs an unsigned payload intent. > 2. deterministic proxy co-signer (Tripwire / Policy Engine) a non-AI policy layer validates the intent against strict rules: Is `payTo` on the SDK allowlist? Is amount ≤ tx cap? Is domain verified? > 3. programmatic signature only if all deterministic checks pass, the proxy co-signs the x402 payment. the catch - adding a proxy co-signer adds 80–150ms of latency to the API call. - worth every millisecond when dealing with mainnet USDC. are you letting your LLM sign its own txs, or using a proxy layer? bookmark this before deploying your next agentic wallet
32
9
49
555
Great share, we are definitely lurking, watching, integrating and building. Appreciate you surfacing these new perspectives and the benefits of thinking about the solution from a different perspective. Good intel here.
Great paper on making AI reason faster and smarter without wasting compute. Right now, the whole community is obsessed with chain-of-thought. But watching models spit out hundreds of verbose tokens just to explore a thought feels like a brute force patch. Looped recurrent architectures try to fix this by keeping reasoning in latent space. But they usually fail because the model is looping blind. It has no principled way to know if its latent thoughts are getting warmer or colder, or when to just stop. This paper introduces Energy-Based Reasoners (EBRs). They define an explicit energy function over the latent states, turning the reasoning process into literal gradient descent down that energy surface. The beauty here is how much mileage they get out of a single scalar. The gradient directly guides the refinement of the thought, the energy value itself serves as an intrinsic verifier across candidate solutions, and when the gradient naturally flattens out, the model gets an automatic, organic halting signal. They hit 99.9% accuracy on Sudoku-Extreme while slashing inference compute by 345x compared to the next-best baseline. Plus, it naturally handles multi-solution problems without collapsing into a single mode. If you care about non-autoregressive reasoning or making test-time search actually efficient, this is easily one of the most refreshing papers I’ve read this month: arxiv.org/pdf/2611.08977
28
14
46
532
Salvor Labs retweeted
This is what makes Salvor fundamentally different. L1 keeps the essential context compressed and accessible. L2 preserves the deeper reasoning, history, and understanding whenever it matters. But the real value goes beyond memory — it's about preserving the knowledge behind every decision, every lesson, and every mistake. With Salvor, the next session doesn't have to start from zero. Teams and agents don't need to repeatedly rediscover what has already been learned. Knowledge becomes a shared, evolving asset — open source, repository-owned, and portable across sessions, models, vendors, and teams. Less repetition. Fewer wasted turns. Better context. Smarter execution. Git preserves what changed. Salvor preserves what the project learned. This isn't just about helping AI remember. It's about making knowledge compound over time. That's the foundation worth building. That's the future Salvor is working towards. @SalvorKnows @SalvorLabsAI #Salvor @BlockchainDan
3
7
179
Salvor Labs retweeted
An agent with a spending limit. Planned Salvor+ MCP will let agents use a $SALVOR budget to pay per request for premium context and tools via x402 on Solana. In development. $SALVOR #AI #MCP #Solana @BlockchainDan @SalvorKnows
2
9
132
Full @SalvorLabsAI x @WHALESHIDEOUT AMA and $SALVOR live demo. Dan shows the 🔥 rate of progress being made on their decoupled project brain tech. @claudeai CLI + @ChatGPT working together -> both add intel -> gated by review/ratify -> brain evolves -> @ChatGPT plans better 💰 Token: $SALVOR 📜 CA: "4KxtNWc5XTL3cuyc8PJMchqB6RYggvEFeMub727GBAGS" Website Link 🔗: 🌐 salvorknows.dev Twitter Link 🔗: 🐦 x.com/SalvorKnows Keep this project on your radar and DYOR! 🔍 #SALVOR #AI #Crypto #Solana #Web3 #AIAgents
Missed the AMA? Here's the full recording 👇 Salvor Labs × Whales Hideout with @BlockchainDan: why Salvor exists, the token model and a live MCP demo. youtu.be/T49WuvzNIqA
42
87
210
20,899