volcengine

What compute do you need for RL training of LLM agents? RL training for an LLM agent needs two kinds of compute. GPUs generate the agent's actions and update its weights, and a fleet of isolated CPU sandboxes runs those actions so they can be scored. On Nodus, the GPUs come from a TrainingJob or a Job, and the sandboxes are Nodus Sandboxes that start with no network access and stop at a dollar cap. In our worked example below, the sandboxes are about a tenth of the bill; the expensive part is GPUs waiting while tool calls finish. That last point decides most design choices, so this post walks through the parts of an agent RL setup, what each one costs, and when the managed path is enough. What are the moving parts of an agent RL run? An agent RL run is a loop of three jobs: generate, act, and learn. The policy model writes a reply or a tool call. An environment executes it, returns the result, and the episode continues for several turns. At the end, a grader turns the episode into a reward, and the trainer updates the model. GRPO is a common choice for agent RL. It samples a group of episodes per task and rewards the ones that beat their group's average. It needs no critic model, which keeps GPU memory down. The DeepSeekMath paper introduced it, and our post on what GRPO is and how to run it covers the method itself. The three jobs want different hardware: | Part | What it does | Hardware it needs | |---|---|---| | Policy and trainer | Samples actions, computes the loss, updates weights | GPUs sized to the model and method | | Environment | Runs code, shell commands or tool calls for each episode | Isolated CPU containers, one per live episode | | Grader | Scores the finished episode, holds the answers | A separate process the model cannot read | The environment is the part that is new compared with ordinary RL on text. A coding agent needs a real filesystem, a shell and a test runner for every episode in flight. That is why agent RL is as much a sandbox problem as a GPU problem. How much GPU does the trainer need? The trainer's GPU follows from the model and method, the same as any fine-tune. With a LoRA adapter on a small model, one GPU is enough. The nodus/grpo-lora runtime's presets put Qwen3-8B with QLoRA on one L40S, RTX A6000 or A100 80GB, and the L40S is listed at $0.793/hr on the Nodus pricing page. Full-parameter training is another matter. In our PPO vs DPO vs GRPO comparison we worked out that full GRPO on an 8B model needs about 131 GB at 16 bytes per parameter. That means several 80 GB GPUs before you count activations. The group size also multiplies generation work. The Nodus rl.train recipe samples 8 replies for each of 4 tasks per step, capped at 256 tokens each. That is up to 8,192 generated tokens per step for single-turn tasks. A multi-turn agent episode repeats that generation on every turn, so plan generation capacity per turn, not per task. How many sandboxes does agent RL need, and what do they cost? Plan on one sandbox per episode that is running at the same moment. With 16 tasks per step and a group size of 8, that is 128 episodes in flight, so 128 sandboxes. Fewer sandboxes means episodes queue, and the GPUs wait for them. On Nodus, a 1 vCPU, 2 GiB Sandbox is listed at $0.0179/hr on the pricing page. Keeping 128 of them running costs 128 x $0.0179 = $2.29 per hour. Sandboxes run on CPU machines Nodus operates, not on the GPU machines used for your jobs, so they never take GPU memory from the trainer. Each one is isolated in ways that matter for code a model wrote. The Sandbox isolation page lists the layers: a user-space kernel that filters system calls, a default-deny firewall with cloud metadata addresses always blocked, a 256-process limit and a non-root user. The Ephemeral continuity mode starts every run empty, which fits a fresh sandbox per task. Why does GPU wait time matter more than sandbox price? Because the GPUs bill for every minute a step takes, including the minutes they spend waiting on tool calls. The worked example below shows the size of the effect. Take an illustrative run on one 8 x H100 node with 128 sandboxes at 1 vCPU and 2 GiB. It trains for 300 steps at 3 minutes of wall-clock time per step, most of it spent waiting on tests and shell commands. These inputs are our assumptions for illustration, not a benchmark. The rates are from the Nodus pricing page, where the H100 SXM is listed at $2.600/hr. Prices checked November 4, 2026. The run lasts 300 x 3 minutes = 15 hours. The GPUs cost 8 x $2.60 x 15 = $312.00. The sandboxes cost 128 x $0.0179 x 15 = $34.37. The total is $346.37, and the sandboxes are 9.9% of it. !Cost breakdown of a 15-hour agent RL run: $312.00 for 8 x H100 GPUs and $34.37 for 128 sandboxes. In this example the sandboxes are under a tenth of the bill; the GPUs are the rest. Now cut the step time in half, to 1.5 minutes, by running tool calls in parallel or overlapping generation with execution. The run drops to 7.5 hours. GPUs cost $156.00 and sandboxes $17.18, for $173.18 in total. !Total cost of the same 300-step run at 3 minutes per step ($346.37) and at 1.5 minutes per step ($173.18). Halving the step time saves $156.00 of GPU time, more than four times the entire $34.37 sandbox bill. From this arithmetic we get a decision rule. Never starve rollouts of sandboxes to save money, because a sandbox costs cents per hour while every idle minute costs the whole GPU node. Spend your engineering effort on step time: parallel episodes, fast environment resets and generation that does not sit idle during tool calls. When is the managed Nodus runtime enough? The managed path fits when your environment's tools are plain Python that runs offline. Nodus Environments are versioned task sets with a grader, and the Environments guide shows nodus/grpo-lora training on multi-turn games and tool-calling environments. The tools run inside the grader, and the trainer never sees the expected answers. A tool-calling run is a short manifest, copied from that guide: spec: runtime: nodus/grpo-lora environment: {name: tool-test@0.1.1, trainTasks: 21, heldOutTasks: 43, seed: 42} parameters: maxTurns: 3 maxCompletionLength: 256 Each episode can call tools for up to maxTurns rounds, and the reward covers the whole episode. Program graders run in grading Sandboxes with no network access, billed to the TrainingJob and counted against its maxCostUSD. Before you launch, the recipe's preview() returns a cost estimate from the runtime's published per-step times. Grading results are also built to keep training honest. A grader that crashes returns InfrastructureFailure, which carries no reward and does not count toward the pass rate. An outage never trains the model to believe a correct action was wrong. When do you need your own trainer and sandboxes? You need your own trainer when tools need the network, a browser, an MCP server or another model as judge. The managed grader has no network, so the Environments guide says those environments fail the build. For them, run an open-source trainer such as verl or SkyRL on GPUs, and give each episode a Nodus Sandbox through the Python SDK. This sketch shows the sandbox side of one episode, using calls from the Python Sandboxes guide. The policy and score functions are placeholders for your own generation and reward code: import nodus def run_episode(task, policy, score, max_turns=6): sb = nodus.Sandbox.create(cpu=1, memory="2Gi", idle_timeout="5m", max_cost=1) try: with sb.open("/workspace/task.json", "w") as f: f.write(task.setup_json) history = [task.prompt] for _ in range(max_turns): command = policy(history) # your model proposes a shell command if command is None: break p = sb.exec("bash", "-c", command) history.append(p.stdout.read()) p.wait() return score(sb, task) # e.g. run the hidden tests finally: sb.terminate() The egress default is deny, so the agent cannot reach the internet unless you open it with network=nodus.Egress.open(). Keep it closed unless a tool needs it, because code in a sandbox can read every secret you put there. Where does this setup fall short? Be clear about the limits before you plan around them. Nodus has no managed PPO runtime, so a learned reward model with a value head means running your own trainer. Allow-list egress, where only named hosts are reachable, is available in Sandbox manifests but not yet in the Python SDK. Our worked example uses assumed step times; your environment's real reset and tool latency decide the numbers, so time a few episodes before you size a run. Training recipes, TrainingJobs and GPU Sandbox state snapshots are Beta; Environments are generally available. FAQ Can agent RL run on a single GPU? Yes, for a LoRA adapter on a model up to about 8B parameters. The smallest nodus/grpo-lora presets, Qwen3-0.6B and Qwen3-1.7B with LoRA, fit on one RTX 4090, listed at $0.290/hr on the pricing page. That is a cheap place to debug an environment before you scale up. Should rollouts run on GPU sandboxes? Only if the agent's tools need a GPU, such as an agent that writes and benchmarks CUDA kernels. Shell and test-running tools work fine on CPU sandboxes, which cost cents per hour. Nodus GPU Sandboxes run on dedicated on-demand machines and are never preempted; our GPU sandboxes post compares the options. How do you stop a reward hack from reading the answers? Keep the expected answers outside the model's reach. In Nodus grading, code from a completion runs as a separate user that cannot read the answers, and the trainer only sees prompts and metadata. With your own trainer, run hidden tests from a location the agent's sandbox never mounts. Can I train on environments built for verifiers, OpenEnv or verl? Many of them, yes. The Environments guide covers verifiers packages, OpenEnv environments and verl datasets with their reward functions unchanged, as long as grading needs no network. Originally published on the Nodus blog.

7 Viral AI Agent Repos: 4 Checks Before You Install One Seven popular AI agent repos, four checks before you install any of them (checked 20-21 Oct 2026; star counts change daily). 1. Who made it? Anthropic Cybersecurity Skills is an independent community project by @mukul975. Its README says "Not affiliated with Anthropic PBC". 2. Is it the right repo? Two separate curated lists are both called Awesome Harness Engineering (ai-boost and walkinglabs), and several repos use "Agent Memory"-style names. Match the GitHub owner, not just the name. 3. The licence. OpenViking is AGPL-3.0, which has conditions if you offer a modified version as a service. Browser Use, Scientific Agent Skills and Diagram Design are MIT; agentmemory and Anthropic Cybersecurity Skills are Apache-2.0. Read the licence before business use. 4. The real cost. Browser Use's code is MIT and free, but you pay for the AI model you connect to it. Its optional Browser Use Cloud starts from $0.02 per browser-hour (the project's own figure). Also: agentmemory's "95.2% retrieval" and Scientific Agent Skills' "250,000+ scientists" are the projects' own claims. Diagram Design has a Claude Code plugin and also works with other agents. Repos (all 7, public on GitHub): Browser Use: browser-use/browser-use agentmemory: rohitg00/agentmemory Scientific Agent Skills: K-Dense-AI/scientific-agent-skills Diagram Design: cathrynlavery/diagram-design Anthropic Cybersecurity Skills (community project, not made by Anthropic): mukul975/Anthropic-Cybersecurity-Skills Awesome Harness Engineering (two lists share the name): ai-boost/awesome-harness-engineering and walkinglabs/awesome-harness-engineering OpenViking (AGPL-3.0): volcengine/OpenViking Browser Use Cloud pricing: browser-use.com Which check would have caught you out? #AI #AIagents #GitHub #shorts Made with AI-generated visuals and voice.

I built OptMem plugin for Hermes. It's one of the 24 in the official catalog. Zero dependencies. No database, no embeddings, no API key. An append-only log: summaries keep context small, the raw record is never deleted. OptMem from @VictorTaelin rarf/optmem-hermes-plugin

6 открытых репозиториев для ИИ-агентов 6 открытых репозиториев для ИИ-агентов, которые экономят месяцы работы. Один превращает Claude в учёного. 1. Браузер для агента: browser-use/browser-use 2. Память агента: rohitg00/agentmemory 3. Наука, 177 навыков: K-Dense-AI/scientific-agent-skills 4. Схемы: cathrynlavery/diagram-design 5. База памяти и знаний: volcengine/OpenViking 6. Обвязка агентов: ai-boost/awesome-harness-engineering Открой Claude Code, вставь нужную ссылку и напиши: «Поставь это и покажи на примере». Ставь по одному, а не все сразу. Нужна подписка Claude Pro или Max. В терминал ничего вводить не нужно. Бесплатная игра и материалы из всех роликов: ig.onai.academy #shorts #claude #ииагенты #github

An 8B Agent That Thinks Without Writing Tokens Beats GPT-5.6 Luna on GAIA. Not on HLE - Book: RAG Pocket Guide - Also by me: Thinking in Go (2-book series) — Complete Guide to Go Programming + Hexagonal Architecture in Go - My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools - Me: xgabriel.com | GitHub --- An 8-billion-parameter agent does part of its thinking without writing a single token, and on the GAIA agent benchmark it scores 43.7 to GPT-5.6 Luna's 37.9. Those numbers are the authors' own, reported in Table 1 of the Hybrid Reasoning Agents paper. The same table puts it at 14.4 on Humanity's Last Exam, where Luna scores 29.0. The paper went up on arXiv on October 13, 2026 and made the Hacker News front page on October 18, with 168 points and 101 comments by the time this was written. The weights, training data and code are public under MIT. Both halves of that scorecard matter if you are thinking about using it. What Stanford and Together AI released The authors list affiliations at Stanford, UIUC and Together AI. The GitHub repo holds the method, the generation engine, both post-training stages, batch inference and an inspector for the latent thoughts, all MIT-licensed. Two agents are on Hugging Face: HybridAgent-8B-Agentic and HybridAgent-14B-Agentic. Both start from Qwen3 base models, per the repo README. They call a Python interpreter and a web search tool across turns, and search needs a Tavily API key (model card). The SFT and RL datasets are published too. The abstract reports, across 3 model scales and 11 benchmarks, an average 10.4% improvement, 35.5% to 54.7% fewer tokens, 1.8x to 2.6x faster inference and 2.7x to 3.7x lower cost. How the agent goes quiet A normal agent reasons in text. Every thought is a token you pay for, and every token lands in your logs. HybridAgent can leave text. When the model emits a special <latent> token, the next steps skip decoding: the last-layer hidden state goes through a small residual adapter the authors call HybridLink and is fed straight back in as the next input embedding (paper, Eq. 4). The paper estimates HybridLink at roughly 10M parameters for a 4B model, and the count grows with hidden size. The latent span ends when HybridLink's output lands nearest to the </latent> token embedding. Nothing fixes the span length; the model decides as it goes. Then it acts in plain text: a tool call, a search query, an answer. Between turns, the agent keeps the KV cache of everything so far (prompt, text, latent steps, tool results) and resumes from it, instead of re-encoding the trajectory as tokens (paper). HybridRL is the stage that teaches it when to think quietly and when to write. Read the scorecard row by row The 10.4% is an average. The rows are uneven. From Table 1: | Benchmark | HybridAgent 8B | HybridAgent 14B | GPT-5.6 Luna | Kimi K3 | |---|---|---|---|---| | GAIA | 43.7 | 52.4 | 37.9 | 41.7 | | WebWalker | 42.5 | 49.5 | 11.0 | 10.0 | | HLE | 14.4 | 16.0 | 29.0 | 31.4 | | DeepSearchQA (acc) | 20.0 | 21.7 | 23.3 | 21.7 | The small agents win the web-navigation and multi-hop search rows by wide margins. On HLE, a hard knowledge-and-reasoning exam, the frontier models score roughly double. On DeepSearchQA, Luna still leads. If your workload looks like HLE, the averaged headline does not describe you. One more row from the same table matters for the headline. ARPO, a text-based 8B agent trained with multi-turn tool-use RL and no latent mode, already scores 38.8 on GAIA and 32.0 on WebWalker (Table 1). That is above Luna on both, narrowly on GAIA. So an 8B agent beating Luna on GAIA is not unique to the latent mode. What the latent mode adds is the margin: from 38.8 to 43.7 on GAIA and from 32.0 to 42.5 on WebWalker. The cost number needs the same care. Table 9 prices compute, not an API bill: "Monetary costs assume $2.50 per H100-hour and 10% utilization of peak BF16 throughput" (paper). Each latent step is charged as one full forward pass, so thinking without tokens is not free. The estimates also "exclude prompt prefill, context-dependent attention, and external tool execution." On those terms the 8B agent drops from $439 to $121 per million questions. Your search API bill and your prefill are on top of that. You can't log what was never written Most agent observability today reads text: the reasoning, the tool calls, the final answer. A latent span has no text to read. One commenter in the HN thread asked: "Monitorability and safety, no? This results in lower volume or less accurate text reasoning traces, right?" (HN). The authors do offer a window. Each latent step can be mapped to its nearest token embedding, which yields what the paper calls pseudo-text, and its readability score is the average best cosine match against the vocabulary (paper, Appendix F). The repo ships an inspector that writes those spans to an HTML report (README). Nearest-token decoding tells you which word the hidden state points closest to. It does not prove that the word is what the step computed. The paper's Appendix B.1 also describes small errors compounding over a long latent span, "gradually eroding the semantic coherence of the latent trace" (paper). If your review process depends on reading an agent's reasoning, a latent agent gives you less of it: the steps you can't read are the same steps that save the tokens. Trying it today The README's quick start, split to fit: git clone https://github.com/togethercomputer/HybridAgent.git cd HybridAgent conda create -n hybridagent python=3.11 -y conda activate hybridagent pip install torch==2.11.0 \ --index-url https://download.pytorch.org/whl/cu128 pip install -r requirements.txt pip install -e . cp .env.example .env # TAVILY_API_KEY for the search tool And the inspector, also from the README: python -m interpretable_latent_mode \ --model togethercomputer/HybridAgent-14B-Agentic \ --question "How many trailing zeros does 100! have?" \ --output report.html Before you plan around it: the model card says loading with transformers alone gives you a text-only model; latent mode and tools need the HybridAgent code. No inference provider hosts it yet. And the authors write that verl and vLLM "do not directly support multi-turn hybrid generation," so they extended their own stack (paper). Training is heavier still: the README recommends 32 GPUs for HybridRL. One early report in the HN thread came from a commenter who ran the 14B model and said "it looped on variations of the same paragraph for five minutes before running out its turn budget," suspecting a llama.cpp incompatibility. Given the model card's warning, my reading is that a run outside the HybridAgent engine is not testing the hybrid part at all. I haven't run it myself. Is a cheaper agent worth reasoning you can only read through a projection? For search-heavy jobs where you check the answer and not the path, maybe. For anything you have to audit, I'd want the text. Where do you land? --- If this was useful HybridAgent's biggest wins are on search and multi-hop retrieval tasks, and that's a reminder that what the agent fetches still decides most of the answer. The RAG Pocket Guide covers that layer: retrieval, chunking and reranking patterns you can apply whether the model on top thinks in text or in hidden states. If you run several coding agents side by side, I build Hermes IDE, a console, free to download, that gives each one its own terminal and worktree, on macOS, Windows and Linux (GitHub). 

Fixed a data-loss bug in OpenViking's agent memory: a failed upsert was still deleting the original memory file. My PR skips the delete when the write fails, verified with the issue's repro. OpenViking#6218 #OpenSource #AIMemory #RAG

OpenViking: The Context Database for AI Agents (40k stars) What it does All text below is quoted directly from the project README. >Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills. Why OpenViking: - One filesystem for knowledge, memory, and skills. Resources hold documents and code; memories retain user preferences and experience; skills define how to perform tasks, not just extracted facts, but the full context, each with a viking:// URI for browsing and retrieval. - Search a directory, not the whole index. Scope semantic search to a project or memory subtree instead of scanning a flat vector pool. find runs a query directly; search plans retrieval from session context. - Read the summary before the source. Generated directory abstracts (L0) and overviews (L1) let agents judge relevance before opening full content (L2). - Sessions become files you can read. Committing a session archives the conversation and extracts memories as Markdown you can inspect, edit, and merge. With VikingBot enabled, ov compile organizes source material into a wiki, knowledge graph, or report. - L0 (Abstract): a one-sentence summary for quick relevance checks. - L1 (Overview): core information and usage scenarios for planning. - L2 (Details): the full original data, read only when needed. >Install OpenViking and run the setup wizard, which configures the models: uv tool install openviking --upgrade && openviking-server init Repository volcengine/OpenViking Repository stats |Metric|Value| |:-|:-| |Stars|40,055| |Forks|3,187| |Last release|v0.5.0 (2026-10-09)| |Languages|Python 72.9%, TypeScript 11.9%, Rust 11.6%| |Contributors|324| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|cursoragent: 4, codex: 7, claude: 208| |AI co-authored commits|Claude: 222, Codex: 3, Cursor: 4| Main contributor |Field|Value| |:-|:-| |Name|Qin Haojie| |GitHub|@qin-ctx| |Commits to this repo|434 (top contributor)| |Bio|Be the CEO of Agents !| |Company / Location|Bytedance / beijing| |Website|x.com| |Followers|145| |Public repos|15| |On GitHub since|2025-09-26| ------------------------------------------------------------------------------------------------- Discover the best GitHub repos without the endless scrolling. Get top repos organized by category (AI, DevOps, Databases & more), plus key takeaways from developers' most useful comments - all in one free, twice-weekly newsletter. 👉 Get the best repos & community insights - Free

OpenViking's Self-Evolving Context Database: How Agent Memory, RAG, and Skills Unify Under One Storage Layer Most agent frameworks bolt memory onto RAG, then bolt skills onto both. OpenViking flips the problem: it treats agent context (memory, knowledge, and skills) as a unified database that evolves its own schema based on agent query patterns. Instead of three separate systems, you get one storage layer with self-evolution primitives. The project, backed by Volcengine (ByteDance's cloud arm), has 40K+ stars and positions itself as a "Context Database for AI Agents." The DSH-plugin architecture and self-evolving indexing suggest production-scale deployment patterns, not a wrapper around existing vector stores. What OpenViking Actually Does OpenViking provides a single storage abstraction for three agent context types: - Agent Memory: Episodic and semantic memory of past interactions, decisions, and outcomes. - Knowledge RAG: Document embeddings, retrieval strategies, and reranking logic. - Skills: Callable tools, plugins, and their execution history. The "self-evolving" mechanism monitors query patterns, retrieval latency, and agent feedback to adjust indexing strategies, schema fields, and embedding models without manual intervention. When an agent repeatedly queries a specific knowledge domain, OpenViking can promote those embeddings to a hot tier or refine chunking boundaries. DSH-Plugin Architecture The DSH-plugin model separates three concerns: - Data layer (D): Stores raw context, embeddings, and metadata in a versioned schema. - Schema layer (S): Defines how context is indexed, chunked, and retrieved. This layer can mutate based on usage patterns. - Handler layer (H): Exposes retrieval, insertion, and evolution APIs to agent runtimes. Plugins extend the handler layer with domain-specific logic (e.g., code search, customer support memory, financial document RAG). Each plugin can register its own schema evolution rules. Why This Matters Traditional agent stacks treat memory and RAG as separate databases. You end up with: - Duplicate embeddings (one for memory, one for RAG). - Inconsistent versioning when an agent's behavior changes. - No shared indexing strategy across context types. OpenViking's unified layer means a single embedding model, one versioning strategy, and shared evolution logic. When an agent's retrieval patterns shift, the entire context database adapts. Self-Evolution Primitives The self-evolution mechanism tracks four signals: 1. Query latency: Slow retrievals trigger index restructuring or hot-tier promotion. 2. Retrieval accuracy: Low precision/recall scores prompt embedding model swaps or chunking adjustments. 3. Agent feedback: Explicit thumbs-up/down or implicit task success rates. 4. Schema drift: New context types (e.g., a new skill plugin) trigger schema expansion. Evolution decisions are logged as versioned migrations. You can roll back to a previous schema if agent performance degrades. Example Evolution Flow # Agent repeatedly queries customer support tickets from Q4 2025 # OpenViking detects high query frequency for date range [2025-10-01, 2025-12-31] evolution_event = { "trigger": "query_frequency", "context_type": "knowledge_rag", "pattern": "date_range_filter", "action": "create_temporal_index", "params": { "field": "ticket_date", "range": ["2025-10-01", "2025-12-31"], "index_type": "btree" }, "version": "schema_v47" } # OpenViking applies migration, logs rollback path # Next queries hit the new index, latency drops 60% Storage Layer Trade-Offs | Aspect | OpenViking Approach | Traditional Vector Store | |--------|---------------------|--------------------------| | Schema flexibility | Self-evolving, versioned migrations | Static schema, manual updates | | Context unification | Memory, RAG, skills in one layer | Separate databases per type | | Indexing strategy | Adaptive based on query patterns | Pre-configured, rarely changed | | Rollback support | Built-in version history | Manual backups, risky restores | | Embedding duplication | Single model across context types | Often duplicated per use case | | Observability | Evolution events logged as first-class | Metrics bolted on after the fact | The downside: complexity. Self-evolution adds a control plane that must be monitored. If evolution logic misfires, you can degrade retrieval quality across all agents. Rollback paths are critical. Deployment Shape OpenViking runs as a standalone service with three components: 1. Context API: REST/gRPC endpoints for agent reads/writes. 2. Evolution Engine: Background process that analyzes query logs and applies schema migrations. 3. Plugin Registry: Manages DSH-plugin lifecycle (install, update, rollback). Agents connect via a thin client library. The context database handles all storage, indexing, and evolution logic. Failure Modes - Evolution thrashing: Rapid schema changes if query patterns are noisy. Mitigation: rate-limit migrations, require minimum sample size. - Rollback cascades: Rolling back one schema version may invalidate dependent plugins. Mitigation: dependency graph for migrations. - Hot-tier exhaustion: Promoting too many embeddings to fast storage. Mitigation: LRU eviction with agent priority hints. - Plugin conflicts: Two plugins evolve the same schema field in incompatible ways. Mitigation: schema namespacing per plugin. Observability Hooks OpenViking exposes evolution events as structured logs: { "event_type": "schema_migration", "version": "schema_v48", "trigger": "retrieval_accuracy_drop", "context_type": "agent_memory", "action": "reembed_with_new_model", "model": "text-embedding-3-large", "affected_records": 142000, "rollback_path": "schema_v47", "timestamp": "2026-10-16T14:22:00Z" } You can pipe these to your existing observability stack (Prometheus, Grafana, Datadog). Key metrics: - Evolution frequency per context type. - Rollback rate (high rollback rate signals unstable evolution logic). - Query latency before/after migration. - Embedding model swap frequency. Security Boundaries Because OpenViking unifies memory, RAG, and skills, access control becomes critical. A compromised agent could leak memory from other agents or inject malicious skills. Recommended boundaries: - Namespace isolation: Each agent gets a dedicated context namespace. Cross-namespace reads require explicit grants. - Plugin sandboxing: Skills run in isolated containers with limited syscall access. - Audit logs: All context writes and evolution events are immutable, signed logs. - Encryption at rest: Embeddings and raw context are encrypted. Evolution engine operates on encrypted data where possible. When to Use OpenViking Good fit: - Multi-agent systems where memory, RAG, and skills overlap (e.g., customer support bots that learn from ticket history and call external APIs). - Long-running agents that need adaptive indexing without manual tuning. - Teams that want a single source of truth for agent context instead of stitching together vector stores, SQL databases, and plugin registries. Avoid if: - You have a single-purpose agent with static retrieval patterns. The evolution overhead is wasted. - Your compliance regime forbids automated schema changes. OpenViking's self-evolution is its core value. - You need sub-millisecond retrieval latency. The evolution engine adds a control plane layer that introduces some overhead. Technical Verdict OpenViking solves a real problem: agent context fragmentation. By treating memory, RAG, and skills as a unified database with self-evolution primitives, it reduces duplication and manual tuning. The DSH-plugin architecture provides clean separation between storage, schema, and handlers. The trade-off is operational complexity. Self-evolution requires monitoring, rollback strategies, and careful plugin management. If your agents have stable retrieval patterns, a simpler vector store may suffice. But for multi-agent systems with shifting context needs, OpenViking's unified layer is worth the overhead. The Volcengine backing suggests production-scale deployment patterns are already in play. If you're building agent infrastructure that will evolve over months or years, OpenViking's self-adapting storage layer is a strong foundation. Source Links - OpenViking GitHub Repository - OpenViking Documentation - OpenViking Live Demo

40,000 stars. new logo. same direction ⛵ Explore what's next with viking:// volcengine/OpenViking t.co

40K stars on OpenViking! 🌟 To everyone who starred the repo, filed an issue, sent a PR, answered a question in the group, or just tried it and told us what broke: this sail is yours. Let's keep building ⛵ volcengine/OpenViking t.co