Scale past one agent and most teams hit the same three memory problems. → Context disappears when a session ends → Agents overwrite each other's state → No audit trail when something breaks Walrus Memory was built for all three. 🦭

🚨SlowMist TI Alert🚨 💸 @Aurellion_Labs Loss: 455,003 USDC (~$455,003) 🔍 Root Cause: Unprotected initialize(address varg0) in SafeOwnable Facet. Diamond set owner via non-initialize path without updating _initialized version slot (bytes 0-7 of 0xf0c57e...) from 0, allowing re-init by attacker to overwrite owner, call diamondCut to inject malicious facet with pullERC20, and drain approved USDC. 📌 Victim Contract: 0x0adc63e71b035d5c7fdb1b4593999fa1f296f1b2 📌 Vulnerable Facet: 0x3ca79c1cf29b8d19f7c643bb6e6bc9c49762e70f 📌 Attacker EOA: 0x9f49591a3bf95b49cd8d9477b4481ce9da68d5ca Attacker seized Diamond ownership and drained USDC from approved victims including 0x2e933518..., 0xa90714a1..., 0xeced2d37.... Powered by #SlowMist#.AI

# OpenCode Features and Practical Usage 🧰 Wish you could decide in one line what your AI agent is allowed to do and what it must never touch? OpenCode's built-in tools plus permissions give you exactly that. 🏷️ Title: Built-in Tools + Permissions 🔗 URL: 📘 Overview OpenCode agents act on your codebase through "tools" such as file editing and shell execution. A rich set ships by default, and each tool can be governed by an allow / ask / deny policy. You get the safety-versus-convenience balance tuned entirely from config. ⚙️ How It Works The main built-in tools are: ・`bash`: run shell commands (git, npm, etc.) ・`edit`: modify existing files via exact string replacement ・`write`: create or overwrite files ・`read`: read files, with optional line ranges ・`grep`: regex search across files ・`glob`: find files by patterns like `**/*.js` ・`webfetch` / `websearch`: fetch and search the web ・helpers like `lsp`, `apply_patch`, `skill`, `todowrite`, `question` Permissions are set in the `permission` field with three states: `allow` (run freely), `ask` (confirm each time), `deny` (forbidden). Note that the `edit` permission governs `edit`, `write`, and `apply_patch` together. 🛠️ Practical Usage In `opencode.json`, you can forbid edits, confirm every bash call, and allow web fetches freely — set `"edit": "deny"`, `"bash": "ask"`, and `"webfetch": "allow"` under the `permission` block. Tools coming from MCP servers can be controlled with wildcards. Writing `"mymcp_*": "ask"` requires confirmation for every tool from that server. 💡 Use Cases On a production-adjacent repo, set `edit` to `deny` and `bash` to `ask` so the agent can plan and investigate but cannot rewrite code or run destructive commands on its own. On a throwaway experiment branch, allow everything to move fast. Switching between the two is just a config change. ⚠️ Caveats By default all tools are allowed, so nothing is restricted until you explicitly narrow it. The `lsp` tool needs `OPENCODE_EXPERIMENTAL_LSP_TOOL=true`, and `websearch` (powered by Exa) needs `OPENCODE_ENABLE_EXA=1`. It is easy to forget that the `edit` permission also covers write and apply_patch. #OpenCode# #AIAgents#

# Learning Palantir Foundry 🚀 Are you recomputing billion-row tables in full every single day? Process only the delta, and your compute costs drop dramatically. 📌 Title and Feature URL Title: Incremental Transforms URL: 📝 Overview Incremental transforms enable efficient data processing by handling only the data added or changed since the last run, instead of reprocessing the entire dataset. They're enabled with the `@incremental()` decorator, which automatically chooses between incremental and snapshot execution based on how the inputs changed. 🔧 How It Works The `@incremental()` decorator wraps a transform function to give it delta-processing capability. - It converts the standard input/output objects into incremental variants: `IncrementalTransformInput`, `IncrementalTransformOutput`, and `IncrementalTransformContext` - Input read modes can be `added` (new rows since last run, the default), `previous` (state from the last run), or `current` (the full current dataset) - Output write modes are `modify` (append to existing output) or `replace` (overwrite entirely); the default is `modify` for incremental runs and `replace` for snapshot runs - Key parameters include `require_incremental` (fail if incremental isn't possible), `semantic_version` (bumping it triggers a snapshot rebuild), `snapshot_inputs` (exempt specific inputs from incremental constraints), and `strict_append` (enforce append-only safety) 🛠 Practical Usage - Add `@incremental()` to large append-heavy log or transaction tables to replace daily full recomputes with delta processing - When you change logic, bump `semantic_version` to safely trigger a snapshot rebuild - Use `require_incremental` to force delta execution when you don't want a silent full reprocess - Use `strict_append` when you need strict append-only guarantees 🎯 Use Cases - Slashing soaring compute costs from daily full recomputes of billion-row tables via delta processing - Serving as the core cost-optimization technique that determines the economics of large-scale projects - Daily ingestion of append-only transaction histories and event logs - Streamlining pipelines whose upstream grows only through additions (APPEND/UPDATE) ⚠️ Caveats - Preview features always run non-incrementally - Unless requirements are met (all non-snapshot inputs contain additions only via APPEND/UPDATE, the input list stays stable, `semantic_version` is unchanged, etc.), the transform automatically runs in snapshot mode and fully replaces the output - Updated or deleted input files must be marked as snapshot inputs - The `previous` mode requires schema validation matching the previous output structure - Transform logic must support both incremental and snapshot execution paths #PalantirFoundry# #DataEngineering#

Something we have been exploring: AI that co-writes the document with you, not just chats about it 🔥 We built it into WorkBuddy, our AI agent for work. It edits the same file you are working in, so it just sees your edits instead of being told, and it never overwrites them. Local Word, Excel, PPT, Markdown, and Tencent Docs online🙌

# Weaviate Features and Practical Usage 🚀 Ingesting data is just the start. From partial updates to conditional bulk deletes to existence checks, Weaviate's object management API covers the full CRUD you need to run a real sync pipeline. 📌 Title and Feature URL Title: Manage objects URL: 📝 Overview Weaviate provides fundamental CRUD operations on objects within a collection: create, read, update (partial or full replacement), and delete. These are organized under the Python client's accessor, and the ability to choose between partial update and full replacement is central to operational design. 🔧 How It Works The key methods are: - insert: add a single object; you can also pass uuid, vector, and references. - insert_many: add multiple objects at once. - update: a partial update that modifies only the specified properties while preserving the rest. - replace: overwrites the entire object with new data. - delete_by_id: deletes a single object by UUID. - delete_many: deletes multiple objects matching a filter. - exists: checks whether an object is present. When you modify properties configured for vectorization, Weaviate automatically regenerates the embeddings transparently during the update. 🛠 Practical Usage - Partial update: properties={"title": "Updated"}) - Full replacement: properties={"title": "New", "body": "Complete"}) - Conditional bulk delete: "brand").equal("OldBrand")) - For reproducible IDs, use generate_uuid5() from weaviate.util so the same input always yields the same UUID, preventing duplicate IDs on re-import. - delete_many supports dry_run (preview matches without deleting) and verbose for detailed output. 🎯 Use Cases - For product master sync, apply only changed fields (price, description) via update's partial update. - Purge a discontinued brand with delete_many(where=...) conditional bulk delete. - Assign stable IDs with generate_uuid5 to prevent duplicate inserts in a daily sync. - Confirm the target count with dry_run before running a production delete. ⚠️ Caveats - Updating a vectorized property triggers automatic re-vectorization and incurs embedding cost; factor "updating the description = embedding cost" into your sync design. - update is partial, replace is full; properties omitted from a replace are dropped, so don't confuse the two. - delete_many is bounded by a QUERY_MAXIMUM_RESULTS limit to prevent resource exhaustion; large deletes must be batched. - Deletes are generally irreversible; make dry_run previews a habit. #Weaviate# #VectorDatabase#

Options flow on Derive this month has been telling three very different stories. ETH is the conviction long: +$2.4M net bullish premium, mostly put underwriting between $1.8k and $2k and synthetic longs. Positive flows every single week. BTC came in hot with an early month bull put spread, went quiet, then started chasing ATM calls once spot pushed toward $66k. +$2.0M overall. HYPE is the interesting one: -$0.9M. Overwriters sold the $71 top almost perfectly, and dip buyers have been fighting the tape ever since.

# Decision Points in AI Agent Development 🎯 **The Hook** Should your AI agent remember everything it hears? Memory write eagerness is one of the most delicate dials in agent design. Write too aggressively and you get memory pollution. Write too conservatively and your agent never learns. Getting this balance right is critical, and the stakes are higher than most teams realize. 📋 **Overview** Memory write eagerness controls how aggressively an agent persists information gathered during interactions into long-term memory. Think of it like a database INSERT: it is a quasi-irreversible operation. When an LLM's speculations or a user's ambiguous statements get written as facts, every future session references them as established truths. Errors become self-reinforcing. This is memory pollution, and it is one of the hardest problems to debug in production agent systems. 🔍 **Decision Points** This dial is primarily driven by two variables: 🔹 **Input Trust** — When end-user free-text is the primary source, the risk of injection and misinformation is high, so raise the write gate threshold. In admin-controlled input environments, you can afford to be more aggressive. 🔹 **Failure Cost** — In healthcare, legal, and financial domains, persisting incorrect facts leads to severe consequences. For an internal chatbot, a minor memory error can be corrected without much harm. Higher failure cost means stricter write suppression. 🔹 **Accountability** — When you need to explain "why was this stored in memory" after the fact, tracking provenance and confidence scores becomes essential. 💡 **Key Details** A practical three-tier framework for write decisions: ✅ **Auto-write** — Facts explicitly stated by the user ("My name is Tanaka," "I use Python") ⚠️ **Write after confirmation** — Information inferred from user behavior ("You seem to prefer Python" — confirm with the user before persisting) 🚫 **Never write** — LLM-generated speculation, unverified external sources, ephemeral context Attach confidence tags to memory entries and downrank low-confidence entries during retrieval. This limits pollution damage without completely blocking writes. Build deduplication into your write pipeline as well. Check new candidates against existing entries using cosine similarity (0.90-0.95 threshold), and overwrite same-entity same-attribute entries with the latest value. ⚖️ **Trade-offs** 📉 Too conservative — The agent never learns. Users repeat their preferences session after session, always getting default behavior. "I already told you this" becomes a recurring frustration. For use cases requiring long-term relationship building, this is a dealbreaker. 📈 Too aggressive — The biggest risk is hallucination persistence. "A-san probably lives in Tokyo" gets stored as "A-san lives in Tokyo" and treated as confirmed fact in all future sessions. Even more dangerous: prompt injection persistence. A single-session attack becomes a persistent injection when written to memory, affecting all future interactions. 🛠️ **Use Cases** 🏥 **Healthcare / Legal / Finance** — Extremely high failure cost. Minimize writes, record only explicitly confirmed facts, and always track provenance and confidence. 💬 **Customer Support** — Need to accumulate user preferences and history, but free-text input carries injection risk. Auto-persist only information confirmed through repeated interactions (2+ matches). Use a quarantine period for implicit preferences before promoting them. 🏢 **Internal Knowledge Bots** — Want to capture organizational tacit knowledge ("this API breaks if you pass this parameter"). Admin-controlled input allows more aggressive writing, but periodic "memory audits" where users review stored information maintain long-term quality. Never forget audit trails. Tracking when, what, and from which source each write occurred makes it possible to identify and fix the root cause when memory pollution is detected. #AIAgents# #SoftwareArchitecture#