As AI-powered coding tools flood the market, a critical weakness has emerged: by default, as with most LLM chat sessions, they are temporary — as soon as you close a session and start a new one, the tool forgets everything you were just working on.

Developers have worked around this by having coding tools and agents save their state to markdown and text files, but this solution is hacky at best.

Qodo, the AI code review startup, believes it has a solution with the launch of what it calls the industry’s first intelligent Rules System for AI governance — a framework that gives AI code reviewers persistent, organizational memory.

The new system, announced today as part of Qodo 2.1, replaces static, manually maintained rule files with an intelligent governance layer. It automatically generates rules from actual code patterns and past review decisions, continuously maintains rule health, enforces standards in every code review, and measures real-world impact.

For Itamar Friedman, CEO and co-founder of Qodo, the release represents a pivotal moment not just for his company but for the entire AI development tools space.

“I strongly believe that this announcement of ours is most important we ever done,” Friedman said in an interview with VentureBeat.

The ‘Memento’ problem

To explain the limitation of current AI coding tools, Friedman invokes the 2000 Christopher Nolan film Memento, in which the protagonist suffers from short-term memory loss and must tattoo notes on his body to remember crucial information.

“Every time you call them, it’s a machine that wakes up from scratch,” Friedman said of today’s AI coding assistants. “So all it can do is, before it goes to sleep and restart, it could write whatever it did in a file.”

This approach—saving context to markdown files like agents.md or napkin.md—has become a common workaround among developers using tools like Claude Code and Cursor. But Friedman argues this method breaks down at enterprise scale.

“Think about heavy duty software where you now have, let’s say, 100,000 of those sticky notes,” he said. “Some of them are sticky notes. Some of them are huge explanations. Some of them are stories. You wake up and you get a task. The first thing that [the AI] is doing is statistically starting to look for the right memos… It’s much better than not having it. But it’s very random.”

From stateless to stateful

The evolution of AI development tools has followed a clear trajectory, according to Friedman: from autocomplete (GitHub Copilot) to question-and-answer (ChatGPT) to agentic coding within the IDE (Cursor) to agentic capabilities everywhere (Claude Code). But he contends all of these remain fundamentally stateless.

“In order for software development to really revolutionize how we do software development for real world software, it needs to be a stateful machine,” Friedman said.

The core challenge, he explained, is that code quality is inherently subjective. Different organizations have different standards, and even teams within the same enterprise may approach problems differently.

“In order to really reach high level of automation, you need to be able to customize for the specific requirements of the enterprise,” Friedman said. “You need to be able to provide code in high quality. But quality is subjective.”

Qodo’s answer is what Friedman describes as “memory that is built over a long time and is accessible to the coding agents, and then they can poke and check and verify that what they’re actually doing is according to the subjective needs of the enterprise.”

How Qodo’s Rules System works

Qodo’s Rules System establishes what the company calls a unified source of truth for organizational coding standards. The system includes several key components:

• Automatic Rule Discovery: A Rules Discovery Agent generates standards from codebases and pull request feedback, eliminating manual authoring of rule files.

• Intelligent Maintenance: A Rules Expert Agent continuously identifies conflicts, duplicates, and outdated standards to prevent what the company calls “rule decay.”

• Scalable Enforcement: Rules are automatically enforced during pull request code review, with recommended fixes provided to developers.

• Real-World Analytics: Organizations can track adoption rates, violation trends, and improvement metrics to prove standards are being followed.

Friedman emphasized that this represents a fundamental shift in how AI code review tools operate. “It’s the first time that AI code review tool is moving from reactive to proactive,” he said.

The system surfaces rules based on code patterns, best practices, and its own library, then presents them to technical leads for approval. Once accepted, organizations receive statistics on rule adoption and violations across their entire codebase.

A tighter connection between memory and agents

What distinguishes Qodo’s approach, according to Friedman, is how tightly the rules system integrates with the AI agents themselves—as opposed to treating memory as an external resource the AI must search through.

“At Qodo, this memory and agents are much more connected, like we have in our brain,” Friedman said. “There’s much more structure to it… where different parts are well connected and not separated.”

Friedman noted that Qodo applies fine-tuning and reinforcement learning techniques to this integrated system, which he credits for the company achieving an 11% improvement in precision and recall over other platforms, successfully identifying 580 defects across 100 real-world production PRs.

Friedman offered a prediction for the industry: “When you look one year ahead, it will be very clear that when we started 2026, we were in stateless machines that are trying to hack how they interact with memory. And we will have a very coupled way by the end of 2026, and Qodo 2.1 is the first blueprint of how to do that.”

Enterprise deployment and pricing

Qodo positions itself as an enterprise-first company, offering multiple deployment options. Organizations can deploy the system entirely within their own infrastructure via cloud premise or VPN, use a single-tenant SaaS option where Qodo hosts an isolated instance, or opt for traditional self-serve SaaS.

The rules and memory files can reside wherever the enterprise requires—on their own cloud infrastructure or hosted by Qodo—addressing data governance concerns that enterprise customers typically raise.

On pricing, Qodo is maintaining its existing seat-based model with usage quotas. At present, the company offers three pricing tiers: a free Developer plan for individuals with 30 PR reviews per month, a Teams plan at $38 per user per month (with 21% savings available for annual billing) that includes 20 PRs per user monthly and 2,500 IDE/CLI credits, and a custom-priced Enterprise plan with contact-us pricing that adds features like multi-repo context awareness, on-prem deployment options, SSO, and priority support.

Friedman acknowledged the ongoing industry debate about whether seat-based pricing makes sense in an age of AI agents but said the company plans to address this topic more comprehensively later this year.

“If you get more value, you pay more,” Friedman said. “If you don’t, then we’re all good.”

Early customer response

Ofer Morag Brin of HR technology company Hibob, an early user of the Rules System, reported positive results in a press statement Qodo shared with VentureBeat ahead of the launch.

“Qodo’s Rules System didn’t just surface the standards we had scattered across different places; it operationalized them,” Brin said. “The system continuously reinforces how our teams actually review and write code, and we are seeing stronger consistency, faster onboarding, and measurable improvements in review quality across teams.”

Founded in 2018, Qodo has raised $50 million from investors including TLV Partners, Vine Ventures, Susa Ventures, and Square Peg, with angel investors from OpenAI, Shopify, and Snyk.

Researchers at Nvidia have developed a technique that can reduce the memory costs of large language model reasoning by up to eight times. Their technique, called dynamic memory sparsification (DMS), compresses the key value (KV) cache, the temporary memory LLMs generate and store as they process prompts and reason through problems and documents.

While researchers have proposed various methods to compress this cache before, most struggle to do so without degrading the model’s intelligence. Nvidia’s approach manages to discard much of the cache while maintaining (and in some cases improving) the model’s reasoning capabilities.

Experiments show that DMS enables LLMs to “think” longer and explore more solutions without the usual penalty in speed or memory costs.

The bottleneck of reasoning

LLMs improve their performance on complex tasks by generating “chain-of-thought” tokens, essentially writing out their reasoning steps before arriving at a final answer. Inference-time scaling techniques leverage this by giving the model a larger budget to generate these thinking tokens or to explore multiple potential reasoning paths in parallel.

However, this improved reasoning comes with a significant computational cost. As the model generates more tokens, it builds up a KV cache.

For real-world applications, the KV cache is a major bottleneck. As the reasoning chain grows, the cache grows linearly, consuming vast amounts of memory on GPUs. This forces the hardware to spend more time reading data from memory than actually computing, which slows down generation and increases latency. It also caps the number of users a system can serve simultaneously, as running out of VRAM causes the system to crash or slow to a crawl.

Nvidia researchers frame this not just as a technical hurdle, but as a fundamental economic one for the enterprise.

“The question isn’t just about hardware quantity; it’s about whether your infrastructure is processing 100 reasoning threads or 800 threads for the same cost,” Piotr Nawrot, Senior Deep Learning Engineer at Nvidia, told VentureBeat.

Previous attempts to solve this focused on heuristics-based approaches. These methods use rigid rules, such as a “sliding window” that only caches the most recent tokens and deletes the rest. While this reduces memory usage, it often forces the model to discard critical information required for solving the problem, degrading the accuracy of the output.

“Standard eviction methods attempt to select old and unused tokens for eviction using heuristics,” the researchers said. “They simplify the problem, hoping that if they approximate the model’s internal mechanics, the answer will remain correct.”

Other solutions use paging to offload the unused parts of the KV cache to slower memory, but the constant swapping of data introduces latency overhead that makes real-time applications sluggish.

Dynamic memory sparsification

DMS takes a different approach by “retrofitting” existing LLMs to intelligently manage their own memory. Rather than applying a fixed rule for what to delete, DMS trains the model to identify which tokens are essential for future reasoning and which are disposable.

“It doesn’t just guess importance; it learns a policy that explicitly preserves the model’s final output distribution,” Nawrot said.

The process transforms a standard, pre-trained LLM such as Llama 3 or Qwen 3 into a self-compressing model. Crucially, this does not require training the model from scratch, which would be prohibitively expensive. Instead, DMS repurposes existing neurons within the model’s attention layers to output a “keep” or “evict” signal for each token.

For teams worried about the complexity of retrofitting, the researchers noted that the process is designed to be lightweight. “To improve the efficiency of this process, the model’s weights can be frozen, which makes the process similar to Low-Rank Adaptation (LoRA),” Nawrot said. This means a standard enterprise model like Qwen3-8B “can be retrofitted with DMS within hours on a single DGX H100.”

One of the important parts of DMS is a mechanism called “delayed eviction.” In standard sparsification, if a token is deemed unimportant, it is deleted immediately. This is risky because the model might need a split second to integrate that token’s context into its current state.

DMS mitigates this by flagging a token for eviction but keeping it accessible for a short window of time (e.g., a few hundred steps). This delay allows the model to “extract” any remaining necessary information from the token and merge it into the current context before the token is wiped from the KV cache.

“The ‘delayed eviction’ mechanism is crucial because not all tokens are simply ‘important’ (keep forever) or ‘useless’ (delete immediately). Many fall in between — they carry some information, but not enough to justify occupying an entire slot in memory,” Nawrot said. “This is where the redundancy lies. By keeping these tokens in a local window for a short time before eviction, we allow the model to attend to them and redistribute their information into future tokens.”

The researchers found that this retrofitting process is highly efficient. They could equip a pre-trained LLM with DMS in just 1,000 training steps, a tiny fraction of the compute required for the original training. The resulting models use standard kernels and can drop directly into existing high-performance inference stacks without custom hardware or complex software rewriting.

DMS in action

To validate the technique, the researchers applied DMS to several reasoning models, including the Qwen-R1 series (distilled from DeepSeek R1) and Llama 3.2, and tested them on difficult benchmarks like AIME 24 (math), GPQA Diamond (science), and LiveCodeBench (coding).

The results show that DMS effectively moves the Pareto frontier, the optimal trade-off between cost and performance. On the AIME 24 math benchmark, a Qwen-R1 32B model equipped with DMS achieved a score 12.0 points higher than a standard model when constrained to the same memory bandwidth budget. By compressing the cache, the model could afford to “think” much deeper and wider than the standard model could for the same memory and compute budget.

Perhaps most surprisingly, DMS defied the common wisdom that compression hurts long-context understanding. In “needle-in-a-haystack” tests, which measure a model’s ability to find a specific piece of information buried in a large document, DMS variants actually outperformed the standard models. By actively managing its memory rather than passively accumulating noise, the model maintained a cleaner, more useful context.

For enterprise infrastructure, the efficiency gains translate directly to throughput and hardware savings. Because the memory cache is significantly smaller, the GPU spends less time fetching data, reducing the wait time for users. In tests with the Qwen3-8B model, DMS matched the accuracy of the vanilla model while delivering up to 5x higher throughput. This means a single server can handle five times as many customer queries per second without a drop in quality.

The future of memory

Nvidia has released DMS as part of its KVPress library. Regarding how enterprises can get started with DMS, Nawrot emphasized that the barrier to entry is low. “The ‘minimum viable infrastructure’ is standard Hugging Face pipelines — no custom CUDA kernels are required,” Nawrot said, noting that the code is fully compatible with standard FlashAttention. 

Looking ahead, the team views DMS as part of a larger shift where memory management becomes a distinct, intelligent layer of the AI stack. Nawrot also confirmed that DMS is “fully compatible” with newer architectures like the Multi-Head Latent Attention (MLA) used in DeepSeek’s models, suggesting that combining these approaches could yield even greater efficiency gains.

As enterprises move from simple chatbots to complex agentic systems that require extended reasoning, the cost of inference is becoming a primary concern. Techniques like DMS provide a path to scale these capabilities sustainably.

“We’ve barely scratched the surface of what is possible,” Nawrot said, “and we expect inference-time scaling to further evolve.”

When enterprises fine-tune LLMs for new tasks, they risk breaking everything the models already know. This forces companies to maintain separate models for every skill.

Researchers at MIT, the Improbable AI Lab and ETH Zurich have developed a new technique that enables large language models to learn new skills and knowledge without forgetting their past capabilities.

Their technique, called self-distillation fine-tuning (SDFT), allows models to learn directly from demonstrations and their own experiments by leveraging the inherent in-context learning abilities of modern LLMs. Experiments show that SDFT consistently outperforms traditional supervised fine-tuning (SFT) while addressing the limitations of reinforcement learning algorithms.

For enterprise applications, the method enables a single model to accumulate multiple skills over time without suffering from performance regression on earlier tasks. This offers a potential pathway for building AI agents that can adapt to dynamic business environments, gathering new proprietary knowledge and skills as needed without requiring expensive retraining cycles or losing their general reasoning abilities.

The challenge of continual learning

Once an LLM is trained and deployed, it remains static. It does not update its parameters to acquire new skills, internalize new knowledge, or improve from experience. To build truly adaptive AI, the industry needs to solve “continual learning,” allowing systems to accumulate knowledge much like humans do throughout their careers.

The most effective way for models to learn is through “on-policy learning.” In this approach, the model learns from data it generates itself allowing it to correct its own errors and reasoning processes. This stands in contrast to learning by simply mimicking static datasets. Without on-policy learning, models are prone to “catastrophic forgetting,” a phenomenon where learning a new task causes the model to lose its past knowledge and ability to perform previous tasks.

However, on-policy learning typically requires reinforcement learning (RL), which depends on an explicit reward function to score the model’s outputs. This works well for problems with clear outcomes, such as math and coding. But in many real-world enterprise scenarios (e.g., writing a legal brief or summarizing a meeting), defining a mathematical reward function is difficult or impossible.

RL methods also often fail when trying to teach a model entirely new information, such as a specific company protocol or a new product line. As Idan Shenfeld, a doctorate student at MIT and co-author of the paper, told VentureBeat, “No matter how many times the base model tries, it cannot generate correct answers for a topic it has zero knowledge about,” meaning it never gets a positive signal to learn from.

The standard alternative is supervised fine-tuning (SFT), where the model is trained on a fixed dataset of expert demonstrations. While SFT provides clear ground truth, it is inherently “off-policy.” Because the model is just mimicking data rather than learning from its own attempts, it often fails to generalize to out-of-distribution examples and suffers heavily from catastrophic forgetting. 

SDFT seeks to bridge this gap: enabling the benefits of on-policy learning using only prerecorded demonstrations, without needing a reward function.

How SDFT works

SDFT solves this problem by using “distillation,” a process where a student model learns to mimic a teacher. The researchers’ insight was to use the model’s own “in-context learning” (ICL) capabilities to create a feedback loop within a single model.

In-context learning is the phenomenon where you provide the LLM with a difficult task and one or more demonstrations of how similar problems are solved. Most advanced LLMs are designed to solve new problems with ICL examples, without any parameter updates.

During the training cycle, SDFT employs the model in two roles.

The teacher: A frozen version of the model is fed the query along with expert demonstrations. Using ICL, the teacher deduces the correct answer and the reasoning logic required to reach it.

The student: This version sees only the query, simulating a real-world deployment scenario where no answer key is available.

When the student generates an answer, the teacher, which has access to the expert demonstrations, provides feedback. The student then updates its parameters to align closer to the teacher’s distribution.

This process effectively creates an on-policy learning loop by combining elements of SFT and RL. The supervision comes not from a static dataset, but from the model’s own interaction and outputs. It allows the model to correct its own reasoning trajectories without requiring an external reward signal. This process works even for new knowledge that RL would miss.

SDFT in action

To validate the approach, the researchers tested SDFT using the open-weight Qwen 2.5 model on three complex enterprise-grade skills: science Q&A, software tool use, and medical reasoning.

The results showed that SDFT learned new tasks more effectively than standard methods. On the Science Q&A benchmark, the SDFT model achieved 70.2% accuracy, compared to 66.2% for the standard SFT approach.

More important for enterprise adoption is the impact on catastrophic forgetting. When the standard SFT model learned the science task, its ability to answer general questions (such as logic or humanities) collapsed. In contrast, the SDFT model improved on the science task while holding its “Previous Tasks” score steady at 64.5%. This stability suggests companies could specialize models for specific departments (e.g., HR or Legal) without degrading the model’s basic common sense or reasoning capabilities.

The team also simulated a knowledge injection scenario, creating a dataset of fictional “2025 Natural Disasters” to teach the model new facts. They tested the model on indirect reasoning questions, such as “Given the floods in 2025, which countries likely needed humanitarian aid?”

Standard SFT resulted in a model that memorized facts but struggled to use them in reasoning scenarios. The SDFT model, having internalized the logic during training, scored 98% on the same questions.

Finally, the researchers conducted a sequential learning experiment, training the model on science, tool use, and medical tasks one after another. While the standard model’s performance oscillated, losing previous skills as it learned new ones, the SDFT model successfully accumulated all three skills without regression.

This capability addresses a major pain point for enterprises currently managing “model zoos” of separate adapters for different tasks.

“We offer the ability to maintain only a single model for all the company’s needs,” Shenfeld said. This consolidation “can lead to a substantial reduction in inference costs” because organizations don’t need to host multiple models simultaneously.

SDFT limitations and availability

The code for SDFT is available on GitHub and ready to be integrated into existing model training workflows.

“The SDFT pipeline is more similar to the RL pipeline in that it requires online response generation during training,” Shenfeld said. They are working with Hugging Face to integrate SDFT into the latter’s Transformer Reinforcement Learning (TRL) library, he added, noting that a pull request is already open for developers who want to test the integration.

For teams considering SDFT, the practical tradeoffs come down to model size and compute. The technique requires models with strong enough in-context learning to act as their own teachers — currently around 4 billion parameters with newer architectures like Qwen 3, though Shenfeld expects 1 billion-parameter models to work soon. It demands roughly 2.5 times the compute of standard fine-tuning, but is best suited for organizations that need a single model to accumulate multiple skills over time, particularly in domains where defining a reward function for reinforcement learning is difficult or impossible.

While effective, the method does come with computational tradeoffs. SDFT is approximately four times slower and requires 2.5 times more computational power (FLOPs) than standard fine-tuning because the model must actively generate its own answers (“rollouts”) during training to compare against the teacher. However, the researchers note that because the model retains knowledge better, organizations may avoid the costly multi-stage retraining processes often required to repair models that suffer from catastrophic forgetting.

The technique also relies on the underlying model being large enough to benefit from in-context learning. The paper notes that smaller models (e.g., 3 billion parameters) initially struggled because they lacked the “intelligence” to act as their own teachers.

However, Shenfeld said that the rapid improvement of small models is changing this dynamic. “The Qwen 2.5 3B models were too weak, but in some experiments we currently do, we found that the Qwen 3 4B model is strong enough,” he said. “I see a future where even 1B models have good enough ICL capabilities to support SDFT.”

Ultimately, the goal is to move beyond static snapshots toward systems that improve through use.

“Lifelong learning, together with the ability to extract learning signal from unstructured user interactions… will bring models that just keep and keep improving with time,” Shenfeld said.

“Think about the fact that already the majority of compute around the world goes into inference instead of training. We have to find ways to harness this compute to improve our models.”

The rapid viral adoption of Austrian developer Peter Steinberger’s open source AI assistant OpenClaw in recent weeks has sent enterprises and indie developers into a tizzy.

It’s easy to easy why: OpenClaw is freely available now and offers a powerful means of autonomously completing work and performing tasks across a user’s entire computer, phone, or even business with natural language prompts that spin up swarms of agents. Since its release in November 2025, it’s captured the market with over 50 modules and broad integrations — but its “permissionless” architecture raised alarms among developers and security teams.

Enter NanoClaw, a lighter, more secure version which debuted under an open source MIT License on January 31, 2026, and achieved explosive growth—surpassing 7,000 stars on GitHub in just over a week.

Created by Gavriel Cohen—an experienced software engineer who spent seven years at website builder Wix.com—the project was built to address the “security nightmare” inherent in complex, non-sandboxed agent frameworks. Cohen and his brother Lazer are also co-founders of Qwibit, a new AI-first go-to-market agency, and vice president and CEO, respectively, of Concrete Media, a respected public relations firm that often works with tech businesses covered by VentureBeat.

NanoClaw’s immediate solution to this architectural anxiety is a hard pivot toward operating system-level isolation. The project places every agent inside isolated Linux containers—utilizing Apple Containers for high-performance execution on macOS or Docker for Linux environments.

This creates a strictly “sandboxed” environment where the AI only interacts with directories explicitly mounted by the user.

While other frameworks build internal “safeguards” or application-level allowlists to block certain commands, Gavriel maintains that such defenses are inherently fragile.

“I’m not running that on my machine and letting an agent run wild,” Cohen explained during a recent technical interview. “There’s always going to be a way out if you’re running directly on the host machine. In NanoClaw, the ‘blast radius’ of a potential prompt injection is strictly confined to the container and its specific communication channel.”

A more secure foundation for agentic autonomy

The technical critique at the heart of NanoClaw’s development is one of bloat and auditability. When Cohen first evaluated OpenClaw (formerly Clawbot), he discovered a codebase approaching 400,000 lines with hundreds of dependencies.

In the fast-moving AI landscape, such complexity is an engineering hurdle and a potential liability.

“As a developer, every open source dependency that we added to our codebase, you vet. You look at how many stars it has, who are the maintainers, and if it has a proper process in place,” Cohen notes. “When you have a codebase with half a million lines of code, nobody’s reviewing that. It breaks the concept of what people rely on with open source”.

NanoClaw counters this by reducing the core logic to roughly 500 lines of TypeScript. This minimalism ensures that the entire system—from the state management to the agent invocation—can be audited by a human or a secondary AI in roughly eight minutes.

The architecture employs a single-process Node.js orchestrator that manages a per-group message queue with concurrency control.

Instead of heavy distributed message brokers, it relies on SQLite for lightweight persistence and filesystem-based IPC. This design choice is intentional: by using simple primitives, the system remains transparent and reproducible.

Furthermore, the isolation extends beyond just the filesystem. NanoClaw natively supports Agent Swarms via the Anthropic Agent SDK, allowing specialized agents to collaborate in parallel. In this model, each sub-agent in a swarm can be isolated with its own specific memory context, preventing sensitive data from leaking between different chat groups or business functions.

The product vision: Skills over features

One of the most radical departures in NanoClaw is its rejection of the traditional “feature-rich” software model. Cohen describes NanoClaw as “AI-native” software—a system designed to be managed and extended primarily through AI interaction rather than manual configuration.

The project explicitly discourages contributors from submitting PRs that add broad features like Slack or Discord support to the main branch. Instead, they are encouraged to contribute “Skills”—modular instructions housed in .claude/skills/ that teach a developer’s local AI assistant how to transform the code.

“If you want Telegram, rip out the WhatsApp and put in Telegram,” Cohen says. “Every person should have exactly the code they need to run their agent. It’s not a Swiss Army knife; it’s a secure harness that you customize by talking to Claude Code”.

This “Skills over Features” model means that a user can run a command like /add-telegram or /add-gmail, and the AI will rewrite the local installation to integrate the new capability while keeping the codebase lean. This methodology ensures that if a user only needs a WhatsApp-based assistant, they aren’t forced to inherit the security vulnerabilities of fifty other unused modules.

Real-world utility in an AI-native agency

This isn’t merely a theoretical experiment for the Cohen brothers. Their new AI go-to-market agency Qwibit uses NanoClaw—specifically a personal instance named “Andy”—to run its internal operations.

“Andy manages our sales pipeline for us. I don’t interact with the sales pipeline directly,” Cohen explained.

The agent provides Sunday-through-Friday briefings at 9:00 AM, detailing lead statuses and assigning tasks to the team.

The utility lies in the friction-less capture of data. Throughout the day, Lazer and Gavriel forward messy WhatsApp notes or email threads into their admin group.

Andy parses these inputs, updates the relevant files in an Obsidian vault or SQLite database, and sets automated follow-up reminders.

Because the agent has access to the codebase, it can also be tasked with recurring technical jobs, such as reviewing git history for “documentation drift” or refactoring its own functions to improve ergonomics for future agents.

Strategic evaluation for the enterprise

As the pace of change accelerates in early 2026, technical decision-makers are faced with a fundamental choice between convenience and control. For AI engineers focused on rapid deployment, NanoClaw offers a blueprint for what Cohen calls the “best harness” for the “best model”.

By building on top of the Claude Agent SDK, NanoClaw provides a pathway to leverage state-of-the-art models (like Opus 4.6) within a framework that a lean engineering team can actually maintain and optimize.

From the perspective of orchestration engineers, NanoClaw’s simplicity is its greatest asset for building scalable, reliable pipelines.

Traditional, bloated frameworks often introduce budget-draining overhead through complex microservices and message queues.

NanoClaw’s container-first approach allows for the implementation of advanced AI technologies—including autonomous swarms—without the resource constraints and “technical debt” associated with 400,000-line legacy systems.

Perhaps most critically, for security leaders, NanoClaw addresses the “multiple responsibilities” of incident response and organizational protection.

In an environment where prompt injection and data exfiltration are evolving daily, a 500-line auditable core is far safer than a generic system trying to support every use case.

“I recommend you send the repository link to your security team and ask them to audit it,” Cohen advises. “They can review it in an afternoon—not just read the code, but whiteboard the entire system, map out the attack vectors, and verify it’s safe”.

Ultimately, NanoClaw represents a shift in the AI developer mindset. It is an argument that as AI becomes more powerful, the software that hosts it should become simpler. In the race to automate the enterprise, the winners may not be those who adopt the most features, but those who build upon the most transparent and secure foundations.

Presented by Cisco

AI agents are breaking traditional IT operations models, adding complexity, data silos, and fragmented workflows. DJ Sampath, Cisco’s SVP of AI Software and Platform, believes that AgenticOps is the solution: a new operational paradigm where humans and AI collaborate in real time to create efficiency, boost security, and allow for innovative technological applications.

In a recent conversation with VentureBeat, Sampath outlined why current enterprise IT management is fundamentally breaking and what makes AgenticOps not just useful, but necessary for IT operations going forward.

The breaking point of traditional IT operations

The core problem plaguing enterprise IT today is fragmentation, Sampath said.

“A lot of times inside of these enterprises, data is sitting across multiple different silos,” he explained. “For an operator to come in and start troubleshooting something, they have to go through many different dashboards, many different products, and that results in an increasing amount of time spent trying to figure out what is where before they can actually get to the root cause of an issue.”

This challenge is about to intensify dramatically. As AI agents become ubiquitous within enterprises, the complexity will multiply exponentially.

“Every single person is going to have at least 10 or more agents that are working on their behalf doing different types of things,” Sampath said. “This problem is only going to be tenfold, if not a hundredfold worse when you start to think about what’s really happening with the inclusion of agents.”

Three core principles of AgenticOps

To address these challenges, Cisco has developed its AgenticOps capabilities around three fundamental design principles that Sampath believes must be true for this new operational model to succeed.

First, unified data access across silos. The platform must bring together disparate data sources: network data, security data, application data, and infrastructure data.

“Bringing all of that stuff together is going to be incredibly important so that the agents that you are deploying to do work on your behalf can seamlessly connect the dots across the board,” Sampath said.

Second, multiplayer-first design. AgenticOps must be fundamentally collaborative from the ground up, enabling IT operations, security operations, network operations teams — and agents — to work together seamlessly.

“When you bring the IT ops person, the SecOps person, the NetOps person all together, you can troubleshoot and debug issues a whole lot faster than if you’re working in silos and copy pasting things back and forth,” he explained. “It’s humans and agents working together in a synchronous environment.”

Third, purpose-built AI models. While general-purpose AI models excel at broad tasks, specialized operations require models trained for specific domains.

“When you start to go into specializations, it becomes really important for these models to understand very specific things like network configuration or thread models that you care about and needs to be able to reason about that,” he said.

How Cisco operationalizes AgenticOps across the enterprise stack

Cisco’s approach unites telemetry, intelligence, and collaboration into a single coherent platform. Cisco AI Canvas is an operations workspace that replaces multiple dashboards with a generative UI and a unified collaborative experience. Within AI Canvas, operators can use natural language to delegate actions to agents — pulling telemetry, correlating signals, testing hypotheses, and executing changes — while maintaining human-in-the-loop control.

The reasoning capabilities come from Cisco’s Deep Network Model, trained on over 40 years of operational data including CCIE expertise, production telemetry, Cisco’s Technical Assistance Center (TAC), and Customer Experience (CX) insights. This purpose-built model delivers domain-specific intelligence that general-purpose models cannot match.

Cisco’s platform spans campus, branch, cloud, and edge environments, allowing agents to consume telemetry across the entire ecosystem at machine speed, including Meraki, ThousandEyes, and Splunk. With MCP servers implemented across Cisco products, agents gain standardized access to tools and data without custom integration work.

How fragmented reporting data undermines IT troubleshooting

The traditional approach to IT troubleshooting involves raising tickets and piecing together fragmenting information across multiple systems.

“People take screenshots. Sometimes it’s in Post-it notes,” Sampath said. “All of this information stays in completely different channels so it becomes really hard for somebody to start collecting them together.”

Cisco AI Canvas addresses this by giving teams one shared, real-time workspace for the work at hand — so context doesn’t get scattered across chats, tickets and screen shares. Teams can collaborate live, escalate instantly, and contribute context (such as screenshots and notes) alongside the agent’s generated charts and graphs. But the real power emerges when AI agents join these collaborative sessions.

“The machines are constantly learning from these human to machine interactions,” Sampath explained. “When you see that same problem happen again, you are that much faster in responding because the machines can assist you.”

This creates a virtuous cycle of continuous improvement, where the agent asks if you’d like to continue using the same approach as last time, for example, and you’re able to hand over more work to the agent. And the time spent debugging gets compressed as the system learns and accelerates future responses.

Security as an AI accelerator

Historically security has been considered a roadblock to adoption and even innovation. But with the right guardrails, organizations can confidently deploy AI at scale, and even accelerate it.

Employees have already experienced the productivity gains of tools like ChatGPT and want similar capabilities within their enterprise environments. When organizations can detect personally identifiable information, prevent prompt injection attacks, and maintain proper data governance, they can unlock and unleash the AI adoption inside of the enterprise in a fundamentally different fashion.

The identity layer required for cross-domain AgenticOps

Cross-domain data access presents one of the most complex challenges in AgenticOps implementation. Cisco’s strategic acquisitions, particularly Splunk, position the company to address this, unifying data across traditionally disconnected systems. But bringing data together is only half the battle, since who has access to what data becomes vitally important.

Cisco is evolving its Duo platform beyond multi-factor authentication to serve as a comprehensive identity provider, with robust identity and access management baked into the platform from the beginning, not bolted on as an afterthought.

“We’re investing in identity as a very core pillar of how these agents are going to be able to pull data from different data sources with the right authorization in mind,” explains Sampath. “Should this agent have access to this type of data? Should you be correlating these types of data together to be able to solve a problem?”

Humans in the loop, but at a higher level

As AI agents become more autonomous, the role of humans will evolve rather than disappear.

“We’re always going to have humans in the loop,” Sampath said. “What you’re going to see is the complexity of the tasks that are being performed are going to be a lot more involved.”

Take coding as an example, which today can be entirely agentic. The human role has shifted from manual coding, or even tab completion, to asking an agent to create code wholesale, and then verifying that it meets requirements before merging it into the codebase. This pattern will repeat across IT operations, with humans focusing on higher-level decision-making while agents handle execution. Importantly, rollback capabilities ensure that even autonomous actions can be reversed if needed.

Why waiting for AI to ‘settle down’ is the wrong move

For CIOs and CTOs, the message is clear: don’t wait.

“A lot of folks are in this holding pattern of waiting and watching,” Sampath said. “They’re waiting for AI to settle down before they make some of their decisions. And I think that is the wrong way to think about this. A partnership with the right groups of people, with the right sets of vendors, is going to help you go a whole lot faster, as opposed to trying to just stay on the fence, trying to figure out what’s right and what’s wrong.”

Sponsored articles are content produced by a company that is either paying for the post or has a business relationship with VentureBeat, and they’re always clearly marked. For more information, contact sales@venturebeat.com.

Until recently, the practice of building AI agents has been a bit like training a long-distance runner with a thirty-second memory.

Yes, you could give your AI models tools and instructions, but after a few dozen interactions — several laps around the track, to extend our running analogy — it would inevitably lose context and start hallucinating.

With OpenAI’s latest updates to its Responses API — the application programming interface that allows developers on OpenAI’s platform to access multiple agentic tools like web search and file search with a single call — the company is signaling that the era of the limited agent is waning.

The updates announced today include Server-side Compaction, Hosted Shell Containers, and a new “Skills” standard for agents.

With these three major updates, OpenAI is effectively handing agents a permanent desk, a terminal, and a memory that doesn’t fade and should help agents evolve furhter into reliable, long-term digital workers.

Technology: overcoming ‘context amnesia’

The most significant technical hurdle for autonomous agents has always been the “clutter” of long-running tasks. Every time an agent calls a tool or runs a script, the conversation history grows.

Eventually, the model hits its token limit, and the developer is forced to truncate the history—often deleting the very “reasoning” the agent needs to finish the job.

OpenAI’s answer is Server-side Compaction. Unlike simple truncation, compaction allows agents to run for hours or even days.

Early data from e-commerce platform Triple Whale suggests this is a breakthrough in stability: their agent, Moby, successfully navigated a session involving 5 million tokens and 150 tool calls without a drop in accuracy.

In practical terms, this means the model can “summarize” its own past actions into a compressed state, keeping the essential context alive while clearing the noise. It transforms the model from a forgetful assistant into a persistent system process.

Managed cloud sandboxes

The introduction of the Shell Tool moves OpenAI into the realm of managed compute. Developers can now opt for container_auto, which provisions an OpenAI-hosted Debian 12 environment.

This isn’t just a code interpreter: it gives each agent its own full terminal environment pre-loaded with:

• Native execution environments including Python 3.11, Node.js 22, Java 17, Go 1.23, and Ruby 3.1.

• Persistent storage via /mnt/data, allowing agents to generate, save, and download artifacts.

• Networking capabilities that allow agents to reach out to the internet to install libraries or interact with third-party APIs.

The Hosted Shell and its persistent /mnt/data storage provide a managed environment where agents can perform complex data transformations using Python or Java without requiring the team to build and maintain custom ETL (Extract, Transform, Load) middleware for every AI project.

By leveraging these hosted containers, data engineers can implement high-performance data processing tasks while minimizing the “multiple responsibilities” that come with managing bespoke infrastructure, removing the overhead of building and securing their own sandboxes. OpenAI is essentially saying: “Give us the instructions; we’ll provide the computer.”

OpenAI’s Skills vs. Anthropic’s Skills

While OpenAI is racing toward a unified agent orchestration stack, it faces a significant philosophical challenge from Anthropic’s Agent Skills.

Both companies have converged on a remarkably similar file structure — using a SKILL.md (markdown) manifest with YAML frontmatter — but their underlying strategies reveal divergent visions for the future of work.

OpenAI’s approach prioritizes a “programmable substrate” optimized for developer velocity. By bundling the shell, the memory, and the skills into the Responses API, they offer a “turnkey” experience for building complex agents rapidly.

Already, enterprise AI search startup Glean reported a jump in tool accuracy from 73% to 85% by using OpenAI’s Skills framework.

In contrast, Anthropic has launched Agent Skills as an independent open standard (agentskills.io).

While OpenAI’s system is tightly integrated into its own cloud infrastructure, Anthropic’s skills are designed for portability. A skill built for Claude can theoretically be moved to VS Code, Cursor, or any other platform that adopts the specification.

Indeed, the hit new open source AI agent OpenClaw adopted this exact SKILL.md manifest and folder-based packaging, allowing it to inherit a wealth of specialized procedural knowledge originally designed for Claude.

This architectural compatibility has fueled a community-driven “skills boom” on platforms like ClawHub, which now hosts over 3,000 community-built extensions ranging from smart home integrations to complex enterprise workflow automations.

This cross-pollination demonstrates that the “Skill” has become a portable, versioned asset rather than a vendor-locked feature. Because OpenClaw supports multiple models — including OpenAI’s GPT-5 series and local Llama instances — developers can now write a skill once and deploy it across a heterogeneous landscape of agents.

For technical decision-makers, this open standard is turning into the industry’s preferred way to externalize and share “agentic knowledge,” moving past proprietary prompts toward a shared, inspectable, and interoperable infrastructure.

But there is another important distinction between OpenAI’s and Anthropic’s “Skills.”

OpenAI uses Server-side Compaction to manage the active state of a long-running session. Anthropic utilizes Progressive Disclosure, a three-level system where the model is initially only aware of skill names and descriptions.

Full details and auxiliary scripts are only loaded when the task specifically requires them. This allows for massive skill libraries—brand guidelines, legal checklists, and code templates—to exist without overwhelming the model’s working memory.

Implications for enterprise technical decision-makers

For engineers focused on “rapid deployment and fine-tuning,” the combination of Server-side Compaction and Skills provides a massive productivity boost

Instead of building custom state management for every agent run, engineers can leverage built-in compaction to handle multi-hour tasks.

Skills allow for “packaged IP,” where specific fine-tuning or specialized procedural knowledge can be modularized and reused across different internal projects.

For those tasked with moving AI from a “chat box” into a production-grade workflow—OpenAI’s announcement marks the end of the “bespoke infrastructure” era.

Historically, orchestrating an agent required significant manual scaffolding: developers had to build custom state-management logic to handle long conversations and secure, ephemeral sandboxes to execute code.

The challenge is no longer “How do I give this agent a terminal?” but “Which skills are authorized for which users?” and “How do we audit the artifacts produced in the hosted filesystem?” OpenAI has provided the engine and the chassis; the orchestrator’s job is now to define the rules of the road.

For security operations (SecOps) managers, giving an AI model a shell and network access is a high-stakes evolution. OpenAI’s use of Domain Secrets and Org Allowlists provides a defense-in-depth strategy, ensuring that agents can call APIs without exposing raw credentials to the model’s context.

But as agents become easier to deploy via “Skills,” SecOps must be vigilant about “malicious skills” that could introduce prompt injection vulnerabilities or unauthorized data exfiltration paths.

How should enterprises decide?

OpenAI is no longer just selling a “brain” (the model); it is selling the “office” (the container), the “memory” (compaction), and the “training manual” (skills). For enterprise leaders, the choice is becoming clear:

• Choose OpenAI if you need an integrated, high-velocity environment for long-running autonomous work.

• Choose Anthropic if your organization requires model-agnostic portability and an open ecosystem standard.

Ultimately, the announcements signal that AI is moving out of the chat box and into the system architecture, turning “prompt spaghetti” into maintainable, versioned, and scalable business workflows.