ironclaw

IronClaw 1.0 just gave $NEAR staking an actual use case beyond yield. Here's the full breakdown of what changed, why the architecture holds up, and what it means if you're holding.
The problem with most #AI agents
Every agent framework built so far shares the same structural weakness. The model deciding what to do is wired directly into the credentials it holds, the tools it can call, and the memory it keeps, all bundled into one system with no separation between them. That means one bad decision, one compromised tool, or one dropped connection can wipe out progress or expose access it should never have had in the first place.
@NEAR Protocol built IronClaw 1.0 specifically to remove that risk. Instead of one tangled system, the architecture separates what an agent decides from what it's actually allowed to execute, routing every action through a single coordination layer NEAR calls the guard. Nothing reaches the outside world until it clears that checkpoint, and sensitive actions require explicit approval before they execute rather than after. Credentials are never handed directly to tools either, they're issued once, scoped narrowly, and scrubbed from logs the moment they've served their purpose.
The benchmark numbers, and why they matter
Running on the same base model across every test, deepseek-v4-flash, #IronClaw currently leads three separate benchmarks that each stress a different kind of task:
PinchBench: 93.5%, across 147 real-world tasks spanning scheduling, coding, and researchClawBench: 88.6%, tested across more than 140 live production websites rather than sandboxed environmentsOfficeQA: 76.4%, built independently by Databricks to test reasoning across roughly 89,000 pages of dense financial documents
The detail worth sitting with is that the base model itself is nothing special. IronClaw isn't winning because NEAR trained a sharper model underneath it, it's winning because the architecture around an ordinary model is doing the heavy lifting. That's a much harder result to fake, and a far more durable edge to build on, than a benchmark score padded by a custom fine-tune.
Where staking actually fits into this
This is the part most coverage glosses over entirely, treating staking as some vague gesture toward network security without ever explaining what that security buys anyone. #NEARAI made the connection concrete instead. Staked $NEAR doesn't just sit there accumulating yield, it converts directly into monthly compute credits, at a ratio where roughly every 100 NEAR staked unlocks around five dollars in usable credits. Those credits fund IronClaw hosting and confidential inference with no credit card and no third-party billing account anywhere in the process. Unstake at any point and your original NEAR comes back fully intact, since the mechanism converts yield and allowance rather than touching the principal.
That reframes staking from a passive position into the literal metering layer for decentralized AI compute. Every agent this ecosystem adds, IronClaw today, OpenClaw as the space matures, pulls genuine demand onto the same staked capital that secures the chain underneath all of it. The more agents that get built on this infrastructure, the more that staking mechanism becomes load-bearing rather than optional.
What this means going forward
An agent that checkpoints through interruptions instead of losing progress, requires explicit approval before anything sensitive happens, and carries the same memory across CLI, Slack, Telegram, and web is a functioning product, not a demo reel. Pairing that with a staking model that ties real usage to network security gives this ecosystem a growth loop that doesn't need hype cycles to keep working, adoption itself generates the demand.
Does tying staking directly to compute demand change how you think about $NEAR 's long-term thesis, or does it need more live agents in production before that case is fully proven?

The evolution of artificial intelligence assistants has historically hit a very clear architectural bottleneck: a monolithic model wired directly to each of its capabilities. When reasoning, executing actions, handling sensitive credentials, and accessing the network all happen within the exact same environment, critical vulnerabilities and single points of failure emerge where any workflow can completely collapse in seconds.
@NEAR Protocol tackles this structural challenge head-on with the rollout of #IronClaw 1.0, an advanced architecture that cleanly separates high-level decision-making from execution through a secure coordination layer known as the guard.
The Architecture of IronClaw 1.0 and Its Benchmark Dominance
IronClaw 1.0 introduces predictable routes for every single action combined with a persistent state capable of surviving any unexpected interruption. By leveraging the deepseek-v4-flash base model to strictly isolate harness performance, the platform leads three essential industry benchmark classifications:
PinchBench (93.5%): Evaluates 147 real-world tasks—ranging from code development to email and file management—outperforming the next competitor by four points.
ClawBench (88.6%): Tests complex web workflows across actual production sites. Thanks to an interception layer that blocks irreversible submissions, it outperforms the wider industry average by 4.7 points.
OfficeQA (76.4%): Analyzes dense enterprise documents (such as an entire century of United States Treasury bulletins) while reducing errors by 12% compared to alternatives like Hermes.
Key Features for Autonomous Agent Workflows
One of its most valuable features lies in its robust operational design.
Security by Design
Every action passes through a centralized checkpoint that requires explicit user approvals for sensitive tasks, keeping tokens and credentials configured as single-use by default.
Persistent State and Checkpoints
If an agent halts due to missing permissions or restarts mid-task, it does not lose accumulated progress; it simply pauses and resumes right at the exact same point.
Omnichannel Memory
Functions identically and synchronously across the command line interface (CLI), the web, Slack, and Telegram, enforcing the same security rules across all channels.
Corporate Isolation
Allows teams to share validated skills across workforces while fiercely protecting individual privacy through fully auditable compliance mechanisms.
NEAR AI and Staking: The Foundation of Decentralized Infrastructure
The native crypto ecosystem desperately needed a billing model aligned with financial sovereignty. Relying on traditional cloud credit cards and centralized gateways represents value extraction entirely contrary to decentralization.
This is precisely where #NEARAI Staking steps in. Instead of spending fiat capital on recurring subscriptions, users lock NEAR tokens directly inside their own wallets to sustainably fund computing services: $NEAR
Agent Hosting: A fixed ratio where staked NEAR divided by 100 generates a predictable monthly credit budget to deploy agents like IronClaw in under thirty seconds.
Confidential Inference: Converts the yield generated by staking into per-second compute credits. Requests execute safely inside Trusted Execution Environments (TEEs), hardware-isolated enclaves backed by cryptographic chip-signed attestations, cryptographically guaranteeing that not even the network operator can read the data.
Staking in NEAR is not merely a passive yield mechanism; it is the technical and economic pillar securing the decentralized infrastructure upon which advanced future agents, such as the upcoming *OpenClaw*, will operate. By unifying capital, sovereign privacy, and computational power within a single wallet, NEAR consolidates a truly user-owned artificial intelligence ecosystem.

AI agents are becoming increasingly good at reasoning. The difference here isn't just that reasoning isn't enough.
The real challenge begins when an agent needs to take action. Accessing a tool, browsing the web, managing credentials, resuming a task after an interruption, or switching between different communication channels without losing context.
That's the problem IronClaw 1.0 is designed to address.
✅ A Different Architecture for AI Agents
#ironclaw separates the decision making part from the action taking part. Between them lies a coordination layer called guarding. This separation is important because an AI agent shouldn't have unlimited access simply because it can reason about an action. Every action goes through the guarding layer, creating a single checkpoint for permissions and security.
The result is an architecture where security isn't an extra feature added around the model; it's part of how the agent works. And the performance figures show that this additional structure doesn't have to come at the expense of capability.
✅ Performance tests tell an interesting story
Using the same deepseek-v4-flash base model, IronClaw currently leads in three different agent performance tests.
• PinchBench: 93.5%
• ClawBench: 88.6%
• OfficeQA: 76.4%
These performance tests assess very different capabilities. PinchBench covers real-world tasks such as scheduling, email, coding, research, and file management. ClawBench pushes agents across more than 140 real websites and evaluates complex multi step web tasks. OfficeQA focuses on reasoning through a very large collection of enterprise documents.
What I find interesting is not just that IronClaw scores highly. It's that the same architectural approach performs well on very different failure surfaces.
✅ What makes IronClaw practical?
The first advantage is the explicit approval for precise actions. The agent can reason about what should happen, but crucial actions still pass through a controlled checkpoint.
Secondly, there's persistence. IronClaw continuously creates checkpoints; this means that an interruption doesn't necessarily erase already completed work. The task can continue instead of restarting.
Thirdly, there's unified memory across the CLI, Web, Slack, and Telegram. The assistant isn't treated as four separate tools with four separate contexts.
There's also a strong team centric design. Organizations can choose multi tenant deployments where useful tools and skills can be shared, or singletenant deployments where complete isolation is prioritized.
To me, these details point to a significant shift. An AI agent is transforming from a chatbot into a constantly working digital worker. When this happens, reliability, permissions, memory, and persistence become as important as model intelligence.
✅The Place of #NEARAI and Staking
Here, the broader @NEAR Protocol vision becomes particularly interesting. NEAR AI is building the infrastructure for private, verifiable AI, including confidential inference and secure agent deployment. Its architecture utilizes hardware secure environments and real time verification to protect sensitive workloads.
Staking is also becoming part of this infrastructure. NEAR AI now allows users to stake NEAR to access confidential inferences and host IronClaw agents. While the stake remains the user's property, the staking mechanism provides usage credits for AI services. This is changing my thinking about staking.
It's not just about seeking returns. It can become an infrastructure mechanism that ties what users hold onchain with the AI ​​services they actually use. Therefore, the bigger picture isn't just "better AI agents." It's a new stack where intelligence, privacy, security, persistent execution, and decentralized infrastructure work together.
IronClaw 1.0 is an interesting step in this direction, demonstrating that adding stronger controls doesn't necessarily mean sacrificing performance. The next question is how far this architecture can go as AI agents become increasingly responsible for more important tasks.
NEAR AI and IronClaw make this question much more practical.
Thank you

AI is entering a fascinating new chapter. We are moving beyond systems that simply answer questions toward agents that can reason, use tools, remember context, and complete real-world tasks. But as AI gains more ability to act, one question becomes impossible to ignore: how do we give AI more capability without giving it unlimited authority?
That is where @NEAR Protocol IronClaw 1.0 presents an interesting approach.
At the heart of IronClaw is the separation between thinking and acting. Instead of allowing an AI agent to make a decision and immediately execute a sensitive action, the architecture introduces a guard layer between the agent's reasoning and execution.
Think of the guard as a security checkpoint. The AI can plan what should happen, while sensitive actions can require explicit approval before they are executed. This creates a clearer boundary between intelligence and authority.
Performance is also important. Using the same deepseek-v4-flash base model, #ironclaw reports impressive results across three agent benchmarks:
📌 93.5% — PinchBench
📌 88.6% — ClawBench
📌 76.4% — OfficeQA
Beyond benchmarks, IronClaw is designed around practical requirements for real-world AI agents.
Safer by design: explicit approvals help control sensitive actions.
Persistent state: continuous checkpoints allow work to resume instead of forcing an agent to start from scratch after an interruption.
Omni-channel memory: the experience extends across CLI, Web, Slack, and Telegram.
Team isolation: organizations can structure agent environments around their collaboration and security requirements.
But the bigger story goes beyond one AI agent.
#NEARAI represents a broader vision for secure, confidential, and decentralized AI infrastructure. And this is where staking becomes especially interesting.
Staking should not be viewed only through the lens of potential yield. Within the NEAR AI model, staking NEAR can activate IronClaw agents and provide credits for AI services, while the staked amount influences how much capacity can be used.
That creates a meaningful connection between AI agents, decentralized infrastructure, and network participation.
The future of AI will not be defined only by who builds the smartest model. It will also depend on who can build systems that are secure, persistent, controllable, and genuinely useful in the real world.
IronClaw 1.0 is an interesting step in that direction and the combination of NEAR AI + staking + agent infrastructure is a space worth watching closely.

I’ve been looking at what happens when AI moves beyond giving answers and starts taking actions.
That is where the real challenge begins. An agent can be capable, but can it act within clear boundaries, preserve its work, and handle sensitive tasks safely?
That is what makes IronClaw 1.0 from @NEAR Protocol worth examining.
#NEARAI Cloud provides the infrastructure behind this direction, giving developers a way to run AI workloads with stronger privacy and verifiable security. Its confidential computing approach uses Trusted Execution Environments (TEEs) to isolate sensitive AI workloads, while cryptographic attestation can provide evidence about where and how the computation was performed.
#ironclaw sits on the agent side of that infrastructure. Its purpose is to give autonomous agents a controlled environment for reasoning, using tools and carrying out tasks without giving the model unrestricted access to everything around it.
Architecture: Decision-Making vs Execution:
#IronClaw separates the AI model from the tools it controls through a guard layer.
The model makes the decision. The guard controls whether and how that decision becomes an action, with permissions, approvals and security controls in between.
That is a much more practical approach to agent security than simply relying on the model to follow instructions.
Benchmark Performance:
Using deepseek v4 flash as the base model, IronClaw leads across the three highlighted benchmarks:
• PinchBench — 93.5%
• ClawBench — 88.6%
• OfficeQA — 76.4%
The consistency across different types of tasks is what stands out to me.
Built for Real Work
The other part I find important is what happens when things don't go perfectly.
IronClaw supports explicit approvals, continuous checkpoints, and persistent state, allowing interrupted work to resume rather than being lost.
Its memory also works across CLI, Web, Slack and Telegram, while team isolation helps maintain individual permissions and workspace boundaries.
NEAR AI & Staking
NEAR AI extends this into the infrastructure layer, with confidential computing and TEE-based environments for AI workloads.
Its staking model connects NEAR staking to AI compute credits, meaning staking is not simply about yield. It helps support the infrastructure required to run agents and confidential inference.
My Take
For me, the interesting part isn't just that IronClaw scores well.
It is the decision to treat security, permissions and execution as part of the agent architecture itself.
If AI agents are going to handle serious business tasks, that distinction between what an agent wants to do and what it is actually allowed to do could become increasingly important.
Check out more LinkedIn article for more insights:
https://www.linkedin.com/pulse/ironclaw-10-secure-agent-harness-redefining-trust-autonomous-mary-xklle

AI agents are moving beyond answering questions.
They can browse websites, work with documents, use tools, interact with software and increasingly execute tasks on behalf of users.
But as agents gain more ability to act, one question becomes more important:
How do we give AI enough authority to be useful without giving it too much freedom?
This is where IronClaw 1.0 from @NEAR Protocol and NEAR AI becomes particularly interesting.
A different approach to AI agent architecture
Traditional AI systems largely focus on improving the model's ability to reason.
IronClaw 1.0 takes a different approach by paying close attention to what happens after the model makes a decision.
Its architecture separates decision making from execution through a coordination layer called the Guard.
Instead of allowing an agent to directly turn every decision into an action, the Guard sits between the two.
That creates an additional control point where sensitive actions can be checked and, when necessary, require explicit approval.
For an AI agent that can interact with real systems, this distinction matters.
The more capable an agent becomes, the more important controlled execution becomes.
The benchmark results are worth watching
IronClaw 1.0 also performed strongly across several agent benchmarks while using the same deepseek-v4-flash base model to isolate the performance of the agent harness itself.
The reported results include:
93.5% on PinchBench
88.6% on ClawBench
76.4% on OfficeQA
These benchmarks cover different types of real world tasks, including scheduling, email, coding, research, file management, browser based tasks and enterprise document analysis.
The numbers are interesting because they show that agent performance is influenced by more than the underlying language model.
The environment around the model matters too.
Persistence is another important piece
An AI agent that loses its state whenever something interrupts a task becomes difficult to rely on for complex workflows.
IronClaw approaches this through continuous checkpointing.
If a task gets interrupted, the agent can resume rather than starting everything again.
It also provides persistent memory across conversations and supports multiple interfaces including CLI, web, Slack and Telegram.
That means the user can interact with the same assistant across different environments while maintaining its state and safety rules.
For teams, IronClaw also supports workspace isolation, giving organizations a way to separate individual work while maintaining shared capabilities where appropriate.
Where NEAR AI and staking come in
The bigger picture becomes clearer when IronClaw is viewed alongside NEAR AI.
NEAR AI is building infrastructure for deploying autonomous AI agents with an emphasis on privacy and secure execution.
This is where staking becomes more interesting than simply earning rewards.
NEAR uses Proof of Stake to secure its network through validators and delegated stake.
For NEAR AI, staking can also connect the resources users hold with access to AI infrastructure.
According to NEAR AI, staking NEAR can help fund private inference and support the deployment of always on IronClaw agents.
That creates an interesting relationship between network security, AI infrastructure and actual usage.
Instead of thinking about staking only as a financial activity, it can also be viewed as part of the economic infrastructure supporting decentralized services.
In Conclusion
The AI agent race will not be determined solely by which model can produce the smartest answer.
As agents gain the ability to interact with software, manage information and execute real tasks, other factors become equally important.
Security.
Privacy.
Persistence.
Controlled execution.
Accountability.
IronClaw 1.0 is an interesting example of how the agent infrastructure itself can be designed around these requirements.
The next stage of AI is less about agents simply knowing what to do.
It is about building systems that can act responsibly when they do it.
#NEARAI #IronClaw

AI agents are entering a different phase.
They are no longer limited to generating text or answering questions. They can research, manage files, interact with websites, communicate across platforms and execute multi-step workflows. But as agents become capable of acting on our behalf, I think one question becomes increasingly important:
How do we give an AI enough autonomy to be useful without giving it unrestricted authority?
That is what makes IronClaw 1.0 from #NEARAI particularly interesting to me.
Separating Thinking From Acting
IronClaw approaches agent security at the architectural level.
Instead of allowing the model that makes a decision to directly execute the resulting action, #ironclaw places a guard layer between decision-making and execution. Actions pass through this controlled path, and sensitive operations can require explicit approval before they are carried out.
That creates a useful separation:
The agent can decide what it wants to do, but it doesn't automatically have unrestricted permission to do it.
For me, that's more interesting than simply adding another security feature to an AI agent. The control mechanism becomes part of how the agent operates.
#ironclaw also tackles another practical problem: what happens when an autonomous workflow gets interrupted?
Its continuous checkpointing allows work to resume instead of forcing the agent to start again. Persistent state and memory can also carry across CLI, Web, Slack and Telegram, allowing the same assistant to retain context across different interfaces.
For organizations, #ironclaw supports shared tools and skills through multi-tenant deployments while maintaining workspace boundaries, with single-tenant deployments available where complete isolation is required.
The Performance Behind the Architecture
The security model would be less compelling if it came at the expense of capability.
In NEAR AI's July 27 evaluation of Ironclaw 1.0, the system took the top reported position across three different agent benchmarks using the same DeepSeek-V4-Flash base model for the harness comparisons.
IronClaw recorded 93.5% on PinchBench, which evaluates 147 real-world tasks including scheduling, email triage, coding, research and file management.
On ClawBench, which tests multi-step tasks across more than 140 real production websites, IronClaw recorded 88.6%.
And on OfficeQA, which evaluates grounded reasoning over a large collection of U.S. Treasury documents, it achieved 76.4%.
These numbers should not be treated as directly comparable because each benchmark measures a different capability. What stands out to me is that the same architecture performed strongly across practical task execution, web interaction and document reasoning.
The Bigger NEAR AI Picture
IronClaw sits within the broader vision of #NEARAI , which focuses on private, confidential and verifiable AI infrastructure.
That brings the role of @NEAR Protocol and staking into the conversation.
Staking is often viewed primarily through the lens of rewards. At the protocol level, however, staked NEAR supports the validator infrastructure responsible for maintaining network consensus and security.
There is now an even more direct connection to AI infrastructure. #NEARAI has introduced staking-based access that allows users to stake NEAR for credits supporting confidential inference and always-on IronClaw agent hosting.
That changes how I look at the relationship between staking and decentralized AI.
The future isn't simply about building agents that can think better. It is about creating infrastructure where agents can act within boundaries, preserve their work, protect sensitive computation and operate on decentralized systems with meaningful security guarantees.
IronClaw 1.0 therefore represents something I find more valuable than another AI capability demo: a move toward making controlled autonomy a fundamental part of how AI agents are designed.
The question for the next generation of AI may not be how autonomous can agents become?
It may be:
How do we make autonomy trustworthy enough to use?

What I find interesting about @NEAR Protocol approach is that it treats AI agents as infrastructure, not just chatbots with more tools.
A lot of agent systems still have reasoning, execution, secrets, and internet access running through the same loop. That can look impressive in a demo, but real-world work is a different story. The more tools an agent can access, the more opportunities there are for something to go wrong.
IronClaw 1.0 takes a different approach.
The agent makes the decisions, while a separate coordination layer called the guard controls how those decisions are carried out. Every action goes through that layer, including new capabilities added later.
The benchmark results are interesting because the underlying model stayed the same: deepseek-v4-flash.
• PinchBench: 93.5% across 147 real-world tasks
• ClawBench: 88.6% across 140+ production websites
• OfficeQA: 76.4% on reasoning over decades of U.S. Treasury documents
Same base model. Different runtime. IronClaw performs better.
But personally, I think the architecture is more important than the numbers.
IronClaw is built around a few practical safeguards:
Safer by design: Sensitive actions can require explicit approval, while secrets can be issued when needed and then scrubbed.
Persistent state: Continuous checkpoints allow an agent to pick up where it stopped instead of losing its progress after an interruption.
Omni-channel memory: CLI, Web, Slack, and Telegram can work as one assistant while keeping the same rules and context.
Team isolation: Organizations can share tools without automatically exposing private workspaces.
Then there’s the bigger NEAR AI and staking picture.
NEAR AI is building infrastructure for decentralized AI, with a focus on things like confidential inference, compute, and AI agents. In that context, staking is about more than earning yield. It also helps support and secure the decentralized infrastructure these systems rely on.
Users can stake NEAR and receive recurring compute credits for confidential inference and IronClaw hosting, while the principal remains withdrawable.
That becomes increasingly relevant as AI agents move beyond simple conversations and start interacting with websites, tools, data, and sensitive systems. Upcoming deployments such as OpenClaw are part of that broader direction.
My main takeaway is simple:
AI agents don't just need better models. They need better systems around those models.
If security only exists in a policy document, it can easily become an afterthought.
With IronClaw, the idea is to make security part of the runtime itself.
And honestly, that’s the part of NEAR’s AI approach I find most interesting.
I also shared a deeper breakdown of IronClaw 1.0 and NEAR AI staking on X and LinkedIn if you want to go deeper.
X: https://x.com/sheishelen914/status/2096210978027303108
LinkedIn:
https://www.linkedin.com/pulse/ironclaw-10-near-staking-why-agent-architecture-now-matters-essien-6xfse?utm_source=share&utm_medium=member_android&utm_campaign=share_via
#NEARAI #ironclaw

AI agents are moving into a different phase.
They are no longer limited to generating answers. They can browse websites, manage files, write code, handle information, and execute multi-step workflows.
That added capability creates a new engineering problem.
When software can act on your behalf, how do you control what it is allowed to do? How do you make sure an interrupted task does not disappear? And how do you protect the infrastructure handling the data and computation behind it?
That is what makes IronClaw 1.0 from @NEAR Protocol interesting to examine.
The important boundary is between deciding and doing
IronClaw 1.0 is a rebuilt agent harness from #NEARAI . It is built around a simple architectural separation: the component that decides what to do is distinct from the component that executes the action.
Between them is a coordination layer called the guard.
Every action passes through this path. Sensitive actions can require explicit approval before execution. That creates a control point between an agent's reasoning and its ability to affect an external system.
The guard is not wrapped around the agent after launch. It is part of the execution path.
That is where being safer by design becomes practical. A rule set once is meant to hold when a new tool is added later.
Capability is not enough if the work cannot survive
An agent handling real work also needs persistence.
IronClaw continuously checkpoints its state. If a task is interrupted, paused for permission, or the session needs to restart, the work can resume from where it stopped instead of being lost.
An interruption becomes a pause rather than a reason to repeat the entire task.
The same principle extends across channels. CLI, Web, Slack, and Telegram can function as one assistant, with shared memory and the same safety rules.
For organizations, #IronClaw supports different isolation models. Multi-tenant deployments allow teams to share tools and skills while keeping individual workspaces private from administrators by default, with auditable access when required. Single-tenant deployments can provide complete isolation.
These details are easy to overlook when discussing AI agents. They become important once the software is expected to operate around real organizational data.
The benchmarks test whether control comes at a performance cost
A reasonable question follows: does adding another control point make an agent less capable?
NEAR AI tested IronClaw across three benchmarks using the same deepseek-v4-flash base model. That choice isolates the harness.
PinchBench: 93.5% across 147 real tasks involving scheduling, email triage, coding, research, and file management.
ClawBench: 88.6% across more than 140 real production websites, testing write-heavy, multi-step tasks.
OfficeQA: 76.4% on enterprise document reasoning across nearly 89,000 pages of U.S. Treasury Bulletins containing more than 26 million numerical values.
These tests expose different kinds of agent work: office workflows, live web interaction, and dense documents.
The numbers do not prove IronClaw will win every workflow. They show something narrower and more useful: adding a control layer did not prevent leading results across very different forms of agent execution.
Where NEAR AI and staking fit
IronClaw does not float on its own. It sits inside the broader NEAR AI infrastructure, which is built around private and verifiable AI.
NEAR AI Cloud uses confidential computing, including Trusted Execution Environments, for eligible workloads. Privacy is meant to rest on technical isolation and verification, not only on trusting whoever operates the machines.
I find this the more interesting half of the architecture, honestly. It is not just about controlling what the agent does anymore, it is about the privacy and verifiability of the environment the agent is even running in.
Staking is the part of this story that often gets flattened into yield. On NEAR, there are two related but distinct roles.
At the protocol level, staking supports Proof of Stake. Users delegate NEAR to validators who participate in validation and consensus. Economic stake is part of how the network stays secure.
NEAR AI also uses staking for services such as confidential inference and always-on agent hosting. In that model, staked NEAR is connected to usage credits for AI infrastructure.
Protocol staking helps secure the network. NEAR AI staking provides access to AI infrastructure and compute.
Seen together, the layers stack cleanly. IronClaw controls how an agent acts, NEAR AI gives it somewhere private to run, and underneath both of them, NEAR Protocol's staking is what keeps the whole network honest.
Staking on NEAR is not just about yields. Together, these layers support the infrastructure agents such as OpenClaw rely on, including OpenClaw deployments on NEAR AI Cloud.
For me, that is the actual story here, not a smarter agent, but one that finally has boundaries it cannot quietly step outside of.
Would you trust an AI agent with real work if there was a guard between its decisions and its actions?

AI agents are evolving from systems that simply respond to systems that can reason, and execute complex tasks in the real world.
They are moving beyond answering questions and beginning to browse the web, work with files, interact with applications, use APIs and execute multi-step tasks. But as agents gain more autonomy, a critical question emerges: how do we give AI the ability to act without sacrificing security, reliability and user control?
@NEAR Protocol ’s IronClaw 1.0 offers an interesting approach to this challenge by redesigning how an AI agent thinks, acts and maintains its progress.
IronClaw 1.0: Separating Thinking From Acting
At the core of #IronClaw 1.0 is a simple but important architectural idea: the agent that makes decisions should not have unrestricted control over the actions it takes.
IronClaw separates the reasoning process from execution through a dedicated guard layer.
The agent can reason about a task, determine what needs to happen and select the appropriate tools. The guard then provides a controlled coordination layer between that decision-making process and real-world execution.
This creates an additional layer where actions can be evaluated and, when necessary, explicitly approved before they happen.
For enterprise environments, this distinction is particularly important. An agent interacting with emails, files, websites, credentials or business systems needs more than intelligence. It needs predictable boundaries.
Benchmark Performance That Stands Out
Architecture is only valuable when it translates into real performance.
IronClaw 1.0 demonstrates that capability across three benchmarks using the DeepSeek-V4-Flash base model.
PinchBench: 93.5% IronClaw leads the benchmark, ahead of Hermes and OpenClaw.ClawBench: 88.6% It also ranks first in multi-step agent tasks, outperforming OpenClaw and Hermes.OfficeQA: 76.4% IronClaw leads again in tasks focused on reasoning over workplace and enterprise information.
The benchmark comparison shows IronClaw maintaining the lead across all three evaluations.
On ClawBench, IronClaw scores 88.6%, ahead of Hermes at 84% and OpenClaw at 82.5%.
On OfficeQA, IronClaw reaches 76.4%, compared with 73.2% for Hermes and 72.4% for OpenClaw.
On PinchBench, IronClaw records 93.5%, compared with 90% for Hermes and 88.6% for OpenClaw.
The results highlight IronClaw’s ability to perform consistently across different types of agent workloads.
The important point is that these benchmarks cover different challenges. Rather than measuring only how well an AI responds to prompts, they examine how effectively an agent can perform tasks in practical environments. IronClaw’s consistent first-place results therefore provide measurable evidence behind its approach to building more capable AI agents.
Designed for Real-World AI Workflows
IronClaw’s value also comes from the infrastructure surrounding its core architecture.
Safer by Design
Sensitive actions can require explicit approval, giving users greater control over what the agent is allowed to execute.
Persistent State
Continuous checkpoints allow IronClaw to preserve its progress. If a task is interrupted or requires approval, the agent can resume instead of starting from the beginning.
Omni-Channel Memory
The assistant can operate across CLI, Web, Slack and Telegram while maintaining the same memory and safety rules.
Team Isolation
Organizations can separate environments and workflows, making IronClaw more suitable for teams handling different projects, tools or levels of access.
IronClaw’s multi-channel approach demonstrates how AI assistants can move beyond a single interface while maintaining continuity across different environments.
Instead of treating each channel as a separate interaction, the same assistant can operate across CLI, Web, Slack and Telegram while preserving its memory, state and safety rules.
This creates a more connected experience for users and teams working across multiple platforms.
NEAR AI and the Role of Staking
IronClaw 1.0 is part of a broader direction around #NEARAI : building AI infrastructure where intelligence can become more private, verifiable and user-owned.
This vision requires more than capable AI models. It also requires infrastructure that can support decentralized applications, agents and services reliably.
That is where NEAR staking becomes relevant.
Staking is not simply about earning yield. At the network level, staked NEAR supports the validator system that helps secure the underlying blockchain. Validators are responsible for maintaining the network and processing transactions, while economic incentives help align participants with network security.
For decentralized AI, this foundation matters.
AI agents need infrastructure they can depend on as they become more capable and autonomous. As the ecosystem moves toward agent systems such as the upcoming OpenClaw, the relationship between AI infrastructure and decentralized network security becomes increasingly important.
The Bigger Picture
IronClaw 1.0 points toward a future where AI agents are judged by more than how intelligently they can respond.
The next standard will also involve how safely they act, how reliably they maintain progress, how consistently they operate across channels and how much control users retain.
#NEARAI represents the broader vision, while staking provides an important security foundation for the decentralized infrastructure beneath it.
The combination is compelling: AI that can think, infrastructure that can coordinate, networks that can be secured by economic participation, and users who can maintain greater ownership of the systems they depend on.
IronClaw 1.0 may therefore be viewed as more than another AI-agent release. It is a glimpse at what the infrastructure for a more capable, secure and decentralized AI ecosystem could look like.
References
IronClaw 1.0: https://near.ai/blog/introducing-ironclaw-1-0NEAR AI Staking: https://www.near.ai/blog/staking-for-near-aiNEAR Staking: https://docs.near.org/protocol/network/stakingNEAR AI Infrastructure: https://near.ai/blog/near-ai-launches-ironclaw-confidential-gpu-marketplace-and-multimodal-confidential-inference

AI has already moved beyond answering questions.
The more significant shift happens when an AI system can take action.
An agent can browse, research, work with files, use external tools, communicate through different channels and continue a task without being guided through every individual step.
That creates a different infrastructure problem.
When software can act on your behalf, capability is no longer enough. You also need to know what the agent is allowed to do, what stands between its decisions and its actions, and what happens when something goes wrong.
That is where IronClaw 1.0, developed within the @NEAR Protocol ecosystem, takes a different architectural approach.
The Agent Should Not Have a Direct Line to the Outside World
Most people think about an AI agent as a model connected to a collection of tools.
IronClaw treats that connection as something that needs a boundary.
Its architecture separates the part that decides from the part that acts, using a coordination layer called the Guard.
Think → Guard → Act
The agent can determine the steps required to achieve a goal. But before those decisions become external actions, they pass through the Guard.
Sensitive actions can require explicit approval, while secrets are designed to be single-use by default.
This matters because agents do not operate only on information supplied by their users.
A webpage, email, document or tool response can contain content that looks like an instruction. If the system gives that content the same authority as an actual user instruction, the line between information and permission starts to disappear.
NEAR AI has described this challenge as field-content trust.
The architectural principle is simple:
An agent should be able to read something without automatically being allowed to obey it.
That is a meaningful difference in how agent security is designed.
Security Still Has to Work Alongside Capability
A heavily restricted agent is not useful if it cannot complete real work.
IronClaw's reported results show the other side of the equation.
Using the same deepseek-v4-flash base model, IronClaw recorded:
93.5% — PinchBench
88.6% — ClawBench
76.4% — OfficeQA
The tests are deliberately different.
PinchBench covers 147 real tasks, including scheduling, email triage, coding, research and file management.
ClawBench evaluates multi-step work across production websites.
OfficeQA focuses on reasoning across large document collections, including historical U.S. Treasury material containing millions of numerical values.
The numbers matter, but the bigger lesson is the combination.
An agent needs to reason well, use tools appropriately and handle complex workflows while still operating within defined boundaries.
For businesses, that makes capability and control two sides of the same problem.
Real Work Also Needs Memory
Business processes rarely finish in one uninterrupted session.
An approval may be required halfway through a task. A system may restart. A user may switch from one interface to another.
IronClaw uses continuous checkpointing and persistent state so an interruption does not necessarily mean losing the work already completed.
Its memory and safety rules also extend across CLI, Web, Slack and Telegram.
That changes the role of an AI agent.
It is no longer simply something that answers a prompt and disappears. It can become part of an ongoing workflow.
For organisations, continuity matters because restarting work can create duplicated effort, inconsistent results and unnecessary human intervention.
IronClaw also supports team environments through multi-tenant deployment and fully isolated single-tenant options, giving organisations different ways to manage separation and access.
The Agent Is Not the Whole Trust Model
There is another question underneath the agent:
Where is the computation happening?
This is where #NEARAI enters the picture.
NEAR AI is building confidential AI infrastructure in which workloads can run inside hardware-enforced Trusted Execution Environments, or TEEs.
Its integration with Intel Trust Authority adds independent attestation, giving users a way to verify the protected execution environment rather than simply relying on the infrastructure operator.
That creates a layered approach:
The Guard controls action.
Confidential computing protects execution.
Attestation helps verify the environment.
And beneath those layers sits the network.
Why Staking Matters to the AI Stack
NEAR uses Proof-of-Stake, where delegated stake supports the validators responsible for securing the network.
That gives staking a role beyond the conversation around returns. It contributes to the economic security of the infrastructure underneath applications and services.
NEAR AI's staking model adds another connection between the network and AI infrastructure.
Users can stake NEAR to receive credits for services such as confidential inference and IronClaw hosting. The amount staked influences the available service budget and agent capacity.
So the relationship is not simply:
stake → return
It can also be understood as:
stake → network security + access to AI infrastructure
That does not mean staking alone makes an AI agent trustworthy. It means the economic layer supporting the network is connected to the infrastructure through which AI services can be accessed.
That connection is an important part of the broader NEAR AI model.
The Bigger Shift Is Controlled Agency
With #IronClaw ,the important development is not simply that an AI agent can do more.
It is that more thought is going into how much authority an agent should have while doing it.
The architecture separates decision from action.
Checkpointing protects continuity.
Persistent memory keeps context alive.
Confidential computing protects sensitive workloads.
Attestation provides a way to verify the environment.
Staking contributes economic security to the underlying network while connecting users to AI infrastructure.
None of these layers solves the trust problem alone.
Together, however, they point toward a different model for agentic AI.
The future of AI may not be defined by giving agents unlimited freedom.
It may be defined by giving them useful authority within boundaries that can be enforced and verified.
Because once an AI can act on your behalf, the most important question is no longer:
“How smart is the agent?”
It is:
“How much should we trust it to do?”
And that is ultimately an architecture question.

Introduction: The Next Phase of AI Agents
Artificial intelligence agents have moved beyond simple question-answering. Today's agents schedule meetings, manage files, conduct research, and interact across multiple platforms. But this evolution introduces a critical architectural challenge: how do we ensure AI agents act safely when they have real-world capabilities?
@NEAR Protocol addresses this with IronClaw 1.0, a revolutionary agent harness that fundamentally rethinks AI agent architecture by separating decision-making from execution through a secure coordination layer.
IronClaw 1.0: Architecture Built for Safety
Traditional AI agents follow a monolithic design where the same model that reasons also executes actions directly. #IronClaw breaks this pattern by introducing a "guard" layer between the decision-making model and the execution environment.
Every action an IronClaw agent wants to take must pass through this guard layer. Sensitive operations—like sending emails, making payments, or modifying files—require explicit user approval before execution. This design ensures that even highly capable agents operate within defined safety boundaries.
Benchmark Dominance: Performance Meets Safety
In NEAR AI's evaluations published in July 2026, IronClaw 1.0 achieved top positions across three major agent benchmarks, all using the same deepseek-v4-flash base model for fair comparison:
PinchBench: 93.5% – Evaluating 147 real-world tasks including scheduling, email triage, coding, research, and file management. IronClaw outperformed the nearest competitor by four percentage points.
ClawBench: 88.6% – Testing multi-step workflows across 140+ real production websites. The guard layer's ability to intercept irreversible submissions contributed to a 4.7-point advantage over industry averages.
OfficeQA: 76.4% – Assessing grounded reasoning over extensive U.S. Treasury document collections, reducing errors by 12% compared to alternatives like Hermes.
These results demonstrate that safety-by-design doesn't compromise performance—IronClaw leads precisely because its architecture enables more reliable, controlled execution.
Key Features: Built for Production
Beyond its core architecture, IronClaw 1.0 introduces several production-grade capabilities:
Persistent State Through Checkpoints: Unlike traditional agents that lose context between sessions, IronClaw continuously checkpoints its state. Work resumes exactly where it left off, even across days or platform switches.
Omni-Channel Memory: IronClaw maintains unified context across CLI, web interfaces, Slack, and Telegram. Actions started on one channel can be monitored or approved from another.
Team Isolation: Organizations can deploy multiple IronClaw instances with isolated memory and permissions, enabling secure multi-team AI operations without cross-contamination risks.
NEAR AI & Staking: Securing Decentralized AI Infrastructure
IronClaw 1.0 is part of NEAR's broader vision for user-owned, decentralized AI. #NEARAI enables users to stake NEAR tokens to access confidential AI inference and always-on agent hosting—transforming staking from a passive yield mechanism into active infrastructure participation.
When you stake NEAR for AI, your tokens do two jobs simultaneously: they set your monthly compute credit budget and determine how many parallel agents you can run. Over 500,000 NEAR is already staked, powering 40+ models from providers including Anthropic, OpenAI, Google, and NEAR AI's own IronClaw.
This staking mechanism secures the underlying decentralized infrastructure that AI agents like IronClaw—and the upcoming OpenClaw—will rely on. Rather than depending on centralized cloud providers, NEAR AI creates a user-owned compute layer where stakers directly fund and govern the network.
The Road Ahead
IronClaw 1.0 represents more than a technical achievement—it's a blueprint for how AI agents should operate in enterprise environments. By prioritizing safety through architectural separation, maintaining persistent state, and integrating with a decentralized staking economy, NEAR is building infrastructure for a future where AI is both powerful and user-controlled.
As decentralized AI matures, the projects that balance capability with control will define the next generation of intelligent systems. IronClaw 1.0 is leading that charge.
🎯 This article is based on official NEAR AI documentation and community analysis from Binance Square (August 2026).

AI agents are becoming more capable.
‎But the more capable they become, the more important one question becomes.
‎Can we actually control what they do?
‎That's one of the things that caught my attention while looking into IronClaw 1.0 from NEAR AI. @NEAR Protocol
‎Most people focus on what an AI model can think about.
‎IronClaw takes a slightly different approach by paying attention to what happens after the AI has made its decision.
‎The model thinks about what needs to be done.
‎Then the Guard sits between the model and the action.
‎So instead of simply:
‎AI → Action
‎you get:
‎AI → Guard → Action
‎That Guard provides a central point where actions can be controlled. Sensitive actions can require explicit approval, and sensitive credentials are handled through additional protections.
‎And the performance is worth mentioning.
‎Using the same deepseek-v4-flash base model, IronClaw 1.0 reported:
‎📌 93.5% PinchBench
‎📌 88.6% ClawBench
📌 76.4% OfficeQA
‎
‎These benchmarks look at different practical abilities.
‎
‎PinchBench covers 147 real world tasks.
‎
‎ClawBench tests agents across more than 140 real websites.
‎
‎OfficeQA focuses on reasoning through a large collection of U.S. Treasury documents.
‎
‎So the numbers give a broader picture of how the agent performs across different types of work.
‎
‎But one feature I personally find just as important is the ability to keep its progress. #NEARAI
‎
‎IronClaw continuously checkpoints its state.
‎
‎If a task gets interrupted, it can resume from its previous state instead of throwing away all the work.
‎
‎It also supports CLI, web, Slack and Telegram, while keeping memory and safety rules consistent across those channels.
‎
‎For teams, there are also different isolation options depending on how the organization wants to deploy the agent.
‎
‎Then we get to the wider NEAR AI ecosystem.
‎
‎NEAR AI is working on private and verifiable AI infrastructure, including confidential inference through Trusted Execution Environments.
‎
‎And staking is becoming part of that picture.
‎
‎NEAR AI allows users to stake NEAR to receive credits for confidential inference and IronClaw agent hosting, while keeping ownership of the underlying stake.
‎
‎So I don't think it makes sense to look at NEAR staking only through the lens of yield.
‎
‎There is also an infrastructure angle.
‎
‎Staking helps secure the underlying NEAR network, while the newer NEAR AI staking model connects that economic commitment with access to AI services.
‎
‎That's the part of this development I find most interesting.
‎
‎AI is getting better at thinking.
‎
‎Now we're building systems that allow it to act.
‎
‎The next challenge is making sure it can do that while users still have meaningful control.
‎
‎IronClaw 1.0 is one interesting attempt at solving that problem.
‎
‎What do you think matters more as AI agents become more autonomous?
‎
‎Better performance or stronger control?
‎#IronClaw

When AI Can Do Everything, Who Keeps Watch?
For a long time, AI agents have been a “Jack of all trades”, they are capable of researching, managing files, interacting with websites and communicating across platforms. But when one agent is responsible for both deciding what to do and actually doing it, the room for mistakes, security risks and loss of control grows
This is the challenge @NEAR Protocol is addressing with IronClaw 1.0. True to its name, IronClaw is built to give AI agents a stronger grip on how they act, separating decision-making from execution through a security-focused coordination layer called the Guard. This means one AI agent can determine what it believes should happen, while a separate layer governs what it is actually permitted to do
In this article, we will explore how #IronClaw works, its benchmark performance, the features designed to make agents safer and more reliable, and how NEAR AI and staking fit into the broader vision of decentralized AI.
What Is IronClaw 1.0?
IronClaw 1.0 is an open-source, Rust-based implementation inspired by OpenClaw and built by #NEARAI , but rebuilt around privacy, isolation and control. Instead of assuming the model can be trusted with sensitive information, IronClaw is designed to keep secrets outside the model wherever possible
Think of a bank employee who can receive your request but cannot open the vault on their own. A security system stands between the employee and the vault, checking whether the requested action is authorized before allowing it to happen
That security system is the IronClaw’s Guard.
Rather than connecting an AI model directly to every tool, credential and external system, IronClaw separates decision-making from execution. Actions pass through the Guard, and the result is an agent that can perform a wide range of tasks without requiring raw credentials to be directly exposed to the LLM.
The Benchmark Performance of IronClaw 1.0
Image showing The Benchmark Performance of IronClaw
IronClaw 1.0 takes the top spot across the three benchmarks that test different aspects of agentic work (i.e, what an AI Agent is expected to do). It is important to note that all three results use the same DeepSeek-V4-Flash base model in their testing.
PinchBench tests which is synonymous to everyday-work test, evaluates 147 practical tasks, including scheduling meetings, managing emails, writing code and handling files. IronClaw scored 93.5%, roughly four percentage points ahead of the next-best model.
ClawBench tests is real-world execution test which takes agents beyond controlled environments and onto more than 140 real production websites., involving multi-step activities like booking flights and making purchases and IronClaw scored 88.6%
OfficeQA tests is a deep-reasoning test which test reasoning through large collections of enterprise documents. Its dataset spans nearly a century of U.S. Treasury Bulletins, covering about 89,000 pages and more than 26 million numerical values and IronClaw scored 76.4%
What makes these results interesting is not any single number.
The three benchmarks test three different environments and IronClaw leads across all three, suggesting that its architecture is not merely optimized for one narrow type of task, meaning that, the same design, where actions pass through a controlled checkpoint, can also support an agent across very different kinds of work.
In other words, the Guard may be a gate between thought and action, but these results suggest that a gate does not necessarily have to become a bottleneck.
The Key Features That Make IronClaw Different
Safer by Design:
IronClaw uses explicit approvals for sensitive actions. Instead of an agent acting first and explaining later, certain operations can stop at the Guard until permission is given. Also Passwords and tokens are designed to be issued once only when needed and then removed from logs, errors and reports
Persistent State
IronClaw uses continuous checkpoints saving it's progress so that an interruption becomes a pause rather than a reset. The agent can resume from where it stopped instead of rebuilding its work from scratch. Think of it like a bookmark, you may close the book, but you don't lose the page.
Omni-Channel Memory
An assistant becomes less useful if its memory disappears whenever you change platforms. IronClaw is designed to work across CLI, Web, Slack and Telegram as one assistant rather than as separate assistants, while carrying the same memory and safety rules across those channels.
IronClaw is built for team
IronClaw supports multi-tenant deployments whereby tools and skills created by one person can be shared across the organization, while single-tenant deployments provide complete isolation for teams that need it.
Image showing what makes IronClaw different
NEAR AI and NEAR Staking
IronClaw solves the problem of how an AI agent can act while keeping control and security in place, however, an agent still needs somewhere secure to run, process information and interact with AI models, and this is where NEAR AI comes in.
NEAR AI is building infrastructure for more private, secure and user-controlled AI. Its stack includes confidential inference, where AI workloads can run inside hardware-isolated environments, as well as agent hosting for systems such as IronClaw.
You can think of it like a house where IronClaw is the security-conscious resident, while NEAR AI provides the protected environment in which it operates.
But as we all know, a decentralized ecosystem needs a way to keep the network secure, reliable and properly supported as more people and applications depend on it.
That is where staking becomes important
On July 30th, 2026, NEAR AI announced staking of NEAR as a way to access certain AI services.
The idea is instead of spending your NEAR directly on AI services, your stake can generate credits while the underlying $NEAR remains yours and can be withdrawn when you unstake. The more you stake, the more access or credits you can receive, depending on the service, and once you unstake, you lose access to the services tied to that stake.
It is somewhat like a fixed deposit, but without a fixed maturity date.
The two services currently supported are:
Confidential Inference: Staking can be used to access inference for open-source models such as DeepSeek, Qwen, etc. Here, it is not the staked NEAR itself that is spent. Instead, the staking yield your NEAR earns is converted into AI compute credits, which accrue over time based on the size of your stake.
Agent Hosting: You can also stake NEAR to access agent hosting, including IronClaw and upcoming agents. For agent hosting, the monthly credit budget follows a flat ratio:
Staked NEAR ÷ 100 = Monthly Credit Budget
For example, staking 500 NEAR gives you $5 in monthly credits, which refreshes each subscription period for as long as the NEAR remains staked.
And you need at least 50 NEAR to deploy your first IronClaw agent, according to the current policy.
Personal insight
Away from the research, personally, I think IronClaw is interesting because it approach AI from a direction that is easy to overlook and that is trust.
First, I like the fact that IronClaw does not simply give an AI agent access to everything and hope for the best.
Second, the fact that I can stake my NEAR to access IronClaw while still retaining my staked NEAR intrigues me.
Also as the saying goes, “A chain is only as strong as its links.” For decentralized AI, the agent is only one link. The security of the network, the privacy of computation and the infrastructure supporting the agent matter just as much.
That, to me, is what makes the IronClaw worth paying attention to.
Conclusion
As AI continues to evolve, ensuring safety and control becomes just as important as making AI more capable.
NEAR AI has built, and continues to improve, infrastructure focused on making AI more private and secure, while also making it more accessible through NEAR staking.
We all know that a powerful agent can open doors, but a well-designed architecture determines which doors it should be allowed to open.
And that brings me to the conclusion that the future of #crypto and Web3 belongs to agents that can do more with the right boundaries in place.

Imagine a company where anyone can propose a wire transfer. Marketing can request one, engineering can request one, HR can request one. But no matter who initiates it, the money does not move until it passes through a single approvals desk that applies the same checks every time. No department gets a side door. That is the basic idea behind NEAR AI's IronClaw 1.0: the agent can reason about what it wants to do, but the action itself must pass through a single coordination layer before it can execute.
That distinction matters because AI agents are moving beyond generating text and answering questions. They can browse websites, manipulate files, interact with external services, use credentials, send messages, and complete multi-step tasks on a user’s behalf. Once an agent can act in the real world, the challenge is no longer simply whether its underlying model is intelligent enough. It is whether the infrastructure surrounding that model can reliably control what it is allowed to do.
The Architecture: Separating Thinking from Acting
#IronClaw 1.0 takes a fundamentally different architectural approach. Rather than allowing reasoning, execution, memory, secrets, and tools to operate as tightly coupled components, it separates the reasoning layer from the execution layer and places a single coordination point called the “guard” between them. Every action, regardless of which capability initiated it, must pass through that checkpoint before execution.
The significance of that design is easy to underestimate. When safeguards are implemented independently across different tools and capabilities, every new feature creates another place where those controls have to be implemented correctly. A centralized guard creates a common enforcement path instead, allowing the same permission and safety logic to govern actions across the system. In practical terms, the architecture is closer to Think ➔ Guard ➔ Act than the conventional Think ➔ Act model.
The architecture also addresses a less obvious problem: continuity. IronClaw uses continuous checkpointing so an interrupted task can resume from its previous state rather than forcing the agent to start over. If a workflow pauses while waiting for approval, encounters a restart, or is interrupted midway through execution, the progress already made can be preserved and the task resumed from its last checkpoint.
Benchmarks: Performance Across Different Failure Surfaces
Architecture alone is not enough. An agent can be extremely cautious and still be practically useless if it cannot complete the tasks it is given. Using the same deepseek-v4-flash base model across the comparisons, #IronClaw currently leads three different agent benchmarks, each testing a different dimension of real-world performance.
On PinchBench, #IronClaw scores 93.5% across 147 practical tasks covering scheduling, email triage, coding, research, and file management. On ClawBench, which evaluates multi-step interactions across more than 140 live production websites, it records 88.6%. OfficeQA tests grounded reasoning over a large corpus of U.S. Treasury Bulletins spanning nearly a century, 89,000 pages, and more than 26 million numerical values; IronClaw scores 76.4%.
These benchmarks stress different capabilities: PinchBench emphasizes practical task completion, ClawBench introduces the unpredictability of live web environments, and OfficeQA tests reasoning over complex documents and numerical information. Leading across all three suggests that performance is not solely a function of the underlying model; the agent harness and architecture surrounding it are contributing meaningfully as well.
From a Demo to a System People Can Actually Use
The architecture becomes more compelling when paired with the controls designed for real-world use. IronClaw can require explicit approval before sensitive actions execute, rather than allowing an agent to act first and explain itself afterward. It also supports single-use secrets that can be scrubbed from logs after use, reducing the amount of sensitive information that persists within the system.
The same philosophy extends to memory and collaboration. IronClaw maintains consistent memory and safety rules across CLI, web, Slack, and Telegram rather than treating each interface as an isolated assistant. For organizations, team isolation allows tools and skills to be shared while keeping individual workspaces private by default, alongside a fully isolated single-tenant option for teams that require stronger separation. @NEAR Protocol and #NEARAI are already running IronClaw internally across their teams, giving these design choices a practical testing ground beyond a product demonstration.
Where NEARAI and Staking Fit
A capable agent still needs inference, compute, and reliable infrastructure to operate continuously. This is where #NEARAI enters the picture. Rather than treating AI compute as an entirely separate service paid for through conventional infrastructure contracts, NEAR AI connects access to AI services with participation in the NEAR ecosystem through its staking model.
For agent hosting, the structure uses a fixed ratio: staked NEAR ÷ 100 equals the monthly credit budget in dollars. Stake 500 NEAR and you receive $5 in credits every month for as long as the tokens remain staked. The Starter tier begins at 50 NEAR and activates the first IronClaw agent, while higher tiers unlock larger credit allocations and additional parallel agents. The underlying NEAR is not consumed; it remains the user’s asset.
Confidential inference works differently. Here, the staking rewards generated by the user’s position (current network APY sits around 4.5–4.7%) are directed toward NEAR AI in exchange for compute credits rather than being paid out as income. The principal stays under the user’s control and can be unstaked through the normal protocol process. The broader infrastructure also provides access to models from providers including Anthropic, OpenAI, and Google.
Importantly, staking on NEAR is not just about yields. It secures the underlying decentralized infrastructure that these AI agents, including the upcoming OpenClaw will rely on. By tying access to compute with network participation, #NEARAI creates a tighter relationship between securing the network and powering the applications that run on it.
The Bigger Picture
This is ultimately why #IronClaw 1.0 is more interesting than another announcement about a more capable AI agent. The important shift in autonomous AI is not simply that models are learning to do more. It is that the infrastructure around those models is beginning to treat autonomy as a systems problem involving permissions, execution, memory, recovery, isolation, and compute rather than intelligence alone.
IronClaw addresses that problem at the execution layer by separating reasoning from action, routing actions through a centralized guard, preserving state through interruptions, controlling sensitive operations, and maintaining consistent safety rules across different interfaces. #NEARAI addresses another part of the stack by connecting AI compute access to decentralized network participation and providing infrastructure that agents can actually run on.
Taken together, these pieces point toward a broader direction for AI infrastructure. The future of autonomous agents may not be determined simply by how much a model can accomplish without human intervention, but by how reliably the systems around that model can constrain its actions, recover when something goes wrong, preserve context over time, and provide the infrastructure required to keep it running.
Smarter agents are only one part of the equation. The more consequential challenge may be building the infrastructure that makes those agents trustworthy enough to act.
You can read on this on 𝕏: https://x.com/Cryptfancier/status/2096337705550434561
Sources
╰─➤ Introducing IronClaw 1.0 (NEAR AI Blog): https://near.ai/blog/introducing-ironclaw-1-0
╰─➤ Staking for NEAR AI (NEAR AI Blog): https://near.ai/blog/staking-for-near-ai
╰─➤ NEAR Protocol official announcement: https://x.com/NEARProtocol/status/2082875217995796606
╰─➤ IronClaw GitHub repository: https://github.com/nearai/ironclaw
╰─➤ NEAR AI Private Inference documentation: https://docs.near.ai/cloud/private-inference
╰─➤ Staking Rewards – NEAR live yield data: https://www.stakingrewards.com/asset/near-protocol

Artificial intelligence is moving beyond chatbots.
The next generation of AI is being built around agents that can reason, use tools, execute tasks and continue working with minimal human intervention.
But greater autonomy creates a fundamental challenge:
How do we give AI the ability to act without giving up security, privacy and user control?
@NEAR Protocol ’s IronClaw 1.0 offers an interesting answer.
IronClaw 1.0: A Different Architecture for AI Agents
IronClaw 1.0 is built around a simple but important architectural distinction: separating the part of an AI system that decides from the part that acts.
NEAR AI describes the architecture this way:
“the part that decides is distinct from the part that acts”
Between those two components sits a secure coordination layer called the guard.
The architecture can be understood as:
Think → Guard → Act
The AI model handles decision making.
The guard evaluates and controls the proposed action.
The execution layer then performs the approved action.
This separation creates a clearer boundary between intelligence and authority.
Instead of allowing an AI model to directly control every tool available to it, the guard becomes the checkpoint through which actions pass.
For sensitive operations, #IronClaw can require explicit approval before execution.
That distinction could become increasingly important as AI agents move from generating information to taking meaningful actions on behalf of users.
Benchmark Performance: Capability Meets Architecture
Security alone is not enough.
An AI agent also needs to perform.
IronClaw 1.0 has reported strong results across three benchmarks using the deepseek-v4-flash base model:
93.5% on PinchBench
88.6% on ClawBench
76.4% on OfficeQA
#NEARAI reports that IronClaw takes the top position across all three benchmarks highlighted in its announcement. The tests cover different aspects of agent performance, from real-world task execution and live web interactions to reasoning over enterprise documents.
What makes these results particularly interesting is the combination of performance and architecture.
PinchBench evaluates agents across 147 real tasks, including scheduling meetings, managing email, coding, research and file management.
ClawBench moves agents onto more than 140 real production websites and evaluates multi-step tasks.
OfficeQA focuses on grounded reasoning across a huge collection of enterprise documents.
So the numbers are not simply about how well a model can answer a question.
They are about how effectively an agent can get things done.
That is an important distinction in the emerging agent economy.
The Architecture Behind the Numbers
NEAR AI makes an interesting argument about why IronClaw was rebuilt rather than simply patched.
“Properties like those are not features you add; they are foundations you build on.”
That philosophy is visible in several IronClaw features.
1. Safer by Design
Every action passes through the guard.
Sensitive actions can require explicit approval instead of allowing the agent to act first and explain later.
IronClaw also uses protections around credentials and secrets, creating a more controlled environment for autonomous execution.
The bigger lesson is that security is being treated as part of the architecture rather than a feature added after the agent has already been built.
2. Persistent State
Autonomous workflows can involve multiple steps and may take considerable time.
An interruption should not mean losing everything.
IronClaw continuously checkpoints its progress, allowing work to resume instead of forcing the agent to start from scratch.
NEAR AI puts it particularly clearly:
“an interruption costs a pause, not the task.”
That may sound like a small technical improvement, but it changes the usability of autonomous AI considerably.
An assistant that remembers where it stopped can support longer and more complicated workflows.
3. Omni Channel Memory
IronClaw is designed to operate across:
CLI
Web
Slack
Telegram
More importantly, these channels operate as one assistant with shared memory and safety rules.
NEAR AI describes the experience as:
“CLI, web, Slack, and Telegram run as one assistant”
This matters because users increasingly work across multiple environments.
The value of an AI agent should not disappear simply because the user moves from a terminal to a messaging application.
4. Team Isolation
Enterprise AI introduces another challenge: who gets access to what?
Different employees and teams may need different workspaces, permissions and data boundaries.
IronClaw supports multi-tenant deployments where tools and capabilities can be shared across an organization while individual workspaces remain separated.
Organizations that require stronger isolation can also use single-tenant deployments.
This gives IronClaw a more practical enterprise dimension.
The challenge is no longer just creating an intelligent agent.
It is creating one that can operate inside an organization without turning every permission boundary into a security problem.
NEAR AI: The Bigger Vision
IronClaw 1.0 should not be viewed in isolation.
It is part of the broader NEAR AI vision around private, verifiable and user controlled artificial intelligence.
The infrastructure behind that vision includes confidential computing and Trusted Execution Environments, which are designed to protect sensitive workloads while providing ways to verify where computation took place.
This becomes increasingly important when AI moves from answering questions to handling private information and performing actions.
An agent may need access to email, documents, applications, financial information or business workflows.
In that environment, privacy cannot simply be a promise.
It needs to be part of the infrastructure.
Where NEAR Staking Fits
This is where the staking component becomes especially interesting.
NEAR AI has introduced Staking for NEAR AI, allowing users to stake $NEAR to obtain credits for confidential inference and agent hosting.
According to NEAR AI:
“You keep the NEAR, and it funds your NEAR AI usage at the same time.”
The model supports both confidential inference and IronClaw agent hosting.
For IronClaw specifically, the staked amount determines the monthly credit budget and how many agents can run in parallel.
This creates an interesting relationship between ownership and AI usage.
Instead of simply paying a centralized provider with a conventional subscription, users can connect their NEAR holdings directly to access AI infrastructure.
But there is a deeper point here.
Staking is not only about yield.
It can also be viewed as participation in the infrastructure that decentralized applications depend on.
AI agents need compute.
They need secure execution.
They need persistent infrastructure.
And decentralized infrastructure needs an economic mechanism that supports participation and security.
NEAR AI's staking model attempts to bring those elements closer together.
As NEAR AI explains:
“Staking closes the loop between what you hold and what you run”
That is perhaps one of the most interesting ideas surrounding the development of decentralized AI.
Why IronClaw Matters
The most interesting part of IronClaw 1.0 is not simply that it is another AI agent framework.
It represents a broader shift in how we think about autonomous AI.
The traditional model is:
AI generates → Human decides → Human acts
The emerging agentic model is closer to:
AI reasons → Guard verifies → Agent acts
That requires a different approach to security.
An autonomous agent needs boundaries.
It needs memory.
It needs persistence.
It needs controlled permissions.
And ultimately, users need confidence that the system remains accountable to them.
IronClaw addresses several of these challenges at the framework level.
NEAR AI extends the conversation into privacy, verifiability and user ownership.
Staking adds another layer by connecting users to the infrastructure powering AI services.
The Bigger Picture
The AI race is often framed around who has the smartest model.
But the next stage may be less about models alone and more about infrastructure.
Who controls the agent?
Who controls the data?
Who verifies the computation?
Who decides what actions can be executed?
And who secures the infrastructure underneath it all?
IronClaw 1.0 provides one possible answer to the first layer of that problem: build agents with a clear separation between thinking and acting.
NEAR AI addresses the infrastructure layer with privacy and verifiability.
Staking connects users to AI services through their NEAR holdings.
Together, these developments point toward a model of AI that is not simply more autonomous, but potentially more secure, persistent, verifiable and user controlled.
The real breakthrough in AI may therefore not be an agent that can do everything.
It may be an agent that can do more without taking control away from the person it serves.
References
1. NEAR AI — Introducing IronClaw 1.0: The Leader Across PinchBench, ClawBench, and OfficeQA Agent Benchmarks
July 27, 2026.
Primary source for IronClaw 1.0’s architecture, guard layer, benchmark performance, persistent state, omni channel support and team isolation.
2. NEAR AI — Announcing Staking for NEAR AI: Put Your NEAR to Work Powering Confidential AI
July 30, 2026.
Primary source for NEAR AI staking, confidential inference, AI compute credits and IronClaw agent hosting.
3. NEAR AI — Confidential AI Infrastructure
Official overview of NEAR AI’s confidential AI infrastructure and IronClaw ecosystem.
4. NEAR — The currency of agents
Official NEAR overview of its infrastructure for the emerging agent economy, including NEAR AI, confidential inference and IronClaw.

AI agents are becoming far more capable than chatbots. They are beginning to plan, execute tasks, interact with applications, and assist with increasingly complex workflows. As these capabilities grow, one question becomes more important: How do we make autonomous AI trustworthy?
This is where @NEAR Protocol is taking an interesting approach with IronClaw 1.0.
Rather than allowing an AI model to think and execute actions without oversight, IronClaw introduces a Guard layer that separates decision-making from execution. Sensitive operations require explicit approval, creating an additional layer of security for AI-powered workflows.
The results are backed by strong benchmark performance. Using the DeepSeek-V4-Flash base model, IronClaw achieved 93.5% on PinchBench, 88.6% on ClawBench, and 76.4% on OfficeQA, demonstrating that a security-first architecture doesn't have to compromise performance.
Another feature that stood out to me is its continuous checkpointing. Instead of losing progress after an interruption, IronClaw resumes exactly where it stopped. Combined with omni-channel memory across CLI, Web, Slack, and Telegram, it feels designed for real enterprise use rather than isolated demonstrations.
Looking beyond #IronClaw itself, @NEAR Protocol is building a broader decentralized AI ecosystem where users and developers can rely on confidential, verifiable AI infrastructure. In that vision, staking becomes more than a way to earn rewards—it helps secure the decentralized network that future AI agents will depend on.
As AI continues to evolve, architecture, security, and infrastructure may become just as important as model size.
What do you think will matter most for the next generation of AI agents: more powerful models or more trustworthy infrastructure?
#NEARAI

AI agents are entering a different phase.
The goal is no longer just to build models that can answer questions. The bigger opportunity is building agents that can take action, operate tools, maintain context, and complete real-world workflows.
But that creates an important problem:
How do you give AI the ability to act without giving it unchecked control?
@NEAR Protocol IronClaw 1.0 takes a fundamentally different approach.
The “Guard” Layer
IronClaw separates decision-making from execution through a secure coordination layer called the guard.
The AI can reason about what needs to happen, but actions pass through a controlled layer that can enforce policies, check permissions, and require explicit approval for sensitive operations.
That makes security part of the architecture rather than an afterthought.
The Numbers
IronClaw 1.0 also shows strong performance across different agent benchmarks using the deepseek-v4-flash base model:
📊 PinchBench — 93.5%
📊 ClawBench — 88.6%
📊 OfficeQA — 76.4%
The significance isn't just the individual scores.
These benchmarks cover different types of work, from productivity tasks and web interaction to reasoning across enterprise documents.
Beyond Performance
An AI agent also needs to be reliable once it leaves the demo environment.
IronClaw addresses this with persistent state and continuous checkpointing.
If an operation is interrupted, the agent can resume from its previous state rather than losing everything and starting over.
It also supports an omni-channel experience across:
CLI → Web → Slack → Telegram
For teams, isolation options provide additional flexibility around how environments and workloads are separated.
Where NEAR AI & Staking Come In
IronClaw sits within the broader vision of NEAR AI: building AI infrastructure around privacy, security, verification and user ownership.
This is where staking becomes particularly interesting.
NEAR staking isn't simply about earning a return. It can also help support the underlying infrastructure that decentralized AI services depend on.
As autonomous agents become more capable, infrastructure becomes just as important as intelligence.
The important questions become:
Who controls the agent?
What can it access?
Where does it execute?
What happens when something goes wrong?
IronClaw 1.0 is an interesting attempt to answer those questions at the architecture level.
The future of AI agents may not be determined by who has the smartest model alone.
It may be determined by who builds the most reliable infrastructure around that intelligent
#NEARAI #ironclaw

The best assistant is the one you stop noticing. You set a goal, move seamlessly from terminal to Slack, and never lose context or redo work because of an interruption. Most AI agents fail this everyday test for a structural reason: they tie every function thinking, acting, storing secrets, and reaching the internet into one tangled system. Each new capability becomes another point of failure or risk.
IronClaw 1.0, launched by @NEAR Protocol on July 27, 2026, takes a different path. It separates decision‑making from execution, with a single coordination layer called the guard between them. That checkpoint is not a marketing flourish; it’s the architecture that makes an always‑on assistant feel like a trusted colleague rather than a fragile script.
What IronClaw 1.0 Is
IronClaw is #NEAR🚀🚀🚀 AI’s secure, open‑source agent harness, written in Rust. It’s designed so agents can work productively without ever exposing your credentials. Key safeguards include:
Encrypted vaults for secretsWebAssembly sandboxes with allowlisted network accessTrusted Execution Environments (TEEs) on NEAR AI Cloud, ensuring even the host cannot inspect memory
The 1.0 release is a capability‑based agentic operating system. You define an outcome; #ironclaw decomposes it into actions. Each action must pass through the guard. Sensitive steps require explicit approval, and credentials are single‑use by default issued once, then scrubbed from logs and reports. Guarantees made once apply everywhere, including tools the agent builds later.
For people, this means you can trust an agent with inbox triage, research, or internal notes without handing over the keys to your digital life. Every employee at #Near Foundation and NEAR AI already runs their own IronClaw agent on this version.
Benchmarks: Harness Over Model
IronClaw’s performance is measured not by model quality but by harness design. All benchmarks use the same base model (deepseek‑v4‑flash), isolating the architecture’s impact:
PinchBench (93.5%) – Real work tasks like scheduling, coding, and research. IronClaw outperforms the next‑best harness by ~4 points.ClawBench (88.6%) – Live web tasks such as booking flights or applying for jobs. IronClaw scores ~5 points above the field average.OfficeQA (76.4%) – Enterprise document reasoning over 89,000 pages of Treasury Bulletins. IronClaw makes 12–15% fewer errors than competitors.
The takeaway: one guard in front of every action improves reliability across everyday work, live‑web operations, and document reasoning.
Human‑Centric Features
Safer by design – Explicit approvals, input sanitization, leak detection, WASM isolation, and network allowlisting.Persistent state – Tasks resume after interruptions instead of restarting from scratch.Omni‑channel memory – CLI, web, Slack, and Telegram share one assistant with consistent safety rules.Team isolation without friction – Multi‑tenant deployments spread workflows across organizations while keeping individual workspaces private.
IronClaw also adapts over time. It can schedule routines, remember preferences, and build new sandboxed tools when needed. The assistant you use in six months will reflect how you actually work.
NEAR AI and Staking: Ownership at the Core
IronClaw is one product within NEAR AI’s broader vision: confidential, verifiable infrastructure for a user‑owned AI economy. Models run inside TEEs, producing hardware‑signed attestations that prove confidentiality. Even providers like Anthropic or OpenAI cannot tie requests back to you.
Staking ensures this infrastructure remains user‑owned. On July 30, 2026, NEAR AI introduced staking‑based payments for confidential inference and agent hosting:
Agent hosting – Stake $NEAR to receive monthly compute credits.Confidential inference – Redirect staking yield into private compute.
This design ties capital and compute together. The same network that secures NEAR transactions also hosts the agents acting on them. Within weeks of launch, over 500,000 NEAR had been staked into the system.
Why It Matters
People don’t want a smarter chatbot. They want an assistant that remembers Tuesday’s brief, asks before sending an email, finishes work after Slack drops, and never leaks an API key. IronClaw 1.0 delivers that: decision and action separated by a guard, proven across benchmarks, persistent across channels, and isolatable for teams.
NEAR AI provides the foundation. Staking keeps ownership in the hands of users. Yield is incidental; the real value is securing decentralized infrastructure that makes assistants like IronClaw reliable, private, and genuinely useful in everyday work
#NEARAI

AI agents have stepped out of the chat box and into the corridors of the workplace.
They no longer simply answer questions. They sort emails, schedule meetings, conduct research, access files, and perform real actions across company tools. In short, they are evolving from software we talk to into digital colleagues capable of opening doors on our behalf.
But we would never hand an employee every key in the company and say, “They seem pretty smart. Hopefully, they open the right door.” With AI agents, focusing only on the quality of their decisions is no longer enough.
Who stands at the door between a decision and an action?
Open-source #ironclaw 1.0 , developed within @NEAR Protocol ’s #NEARAI vision, offers an architectural answer to that question. The component that makes decisions is separated from the component that acts on them in the outside world. Between the two sits a shared coordination layer called the “guard,” through which every action must pass.
🛂 The Guard at the Agent’s Security Gate
Think of the guard layer as the smart security gate of a corporate building. It is less concerned with what is being thought inside and more concerned with which permission is being used, which door someone is trying to enter, and why.
IronClaw can read an email, edit a file, or research something online. On the security side, however, three important rules come into play:
Sensitive actions require explicit user approval first.Passwords and access tokens are single-use by default.Once used, those secrets are scrubbed from logs, error messages, and reports.
This separation matters. When “thinking” and “doing” are tied into the same knot inside an AI agent, every new capability pulls that knot a little tighter. Eventually, you may end up with a highly capable colleague whose pockets contain plenty of keys, but no one is quite sure which key opens which door.
📊 Does Safety Put the Brakes on Performance
We often assume that more control means slower execution. IronClaw 1.0’s benchmark results suggest that fastening a seat belt does not necessarily slow down the car.
In the evaluations published by NEAR AI, every agent harness used the same base model, deepseek-v4-flash. IronClaw achieved the following results across three benchmarks:
PinchBench: 93.5%ClawBench: 88.6%OfficeQA: 76.4%
PinchBench measures performance across 147 real-world tasks, including meeting scheduling, email management, coding, research, and file operations. ClawBench tests agents on multi-step tasks across more than 140 live websites. OfficeQA evaluates information retrieval and reasoning across a collection of approximately 89,000 pages of enterprise documents.
The most interesting detail here is not only the scores, but the fact that every system raced with the same engine. Since the base model remained unchanged, the difference comes less from engine size and more from how the steering, brakes, and gearbox work together.
💾 No Starting Over When Work Is Interrupted
IronClaw continuously saves task progress through checkpoints. Think of them as save points from old video games adapted to corporate life. If the agent pauses for user permission or the system restarts, it does not forget the entire task and send you back to the first level. It resumes where it stopped.
In a business environment, this does more than save a few minutes. It also reduces the errors, repetition, and context loss caused by recreating unfinished work. Explaining the same task for the third time on a Monday morning is tiring enough with people; there is little reason to repeat the experience with software.
The same memory is preserved across CLI, web, Slack, and Telegram. Changing channels does not introduce you to a new intern on their first day every time. You continue speaking with the same agent, one that remembers your preferences, previous decisions, and security rules.
🧩 Team Memory Does Not Mean Opening Every Drawer
IronClaw’s team architecture addresses two different needs at the same time:
In a multi-tenant deployment, tools and skills developed by one person can be shared across the organization. The same workflow does not have to be rediscovered from scratch by every employee.Individual workspaces are not visible to administrators by default.A single-tenant deployment gives organizations with stricter data boundaries a fully isolated environment with no external access.
Building a shared organizational memory, therefore, does not mean opening every desk drawer for everyone to inspect.
🔐 Where NEAR AI and Staking Fit In
IronClaw is not a standalone product. NEAR AI is developing a broader infrastructure in which agents, models, and sensitive data can operate inside Trusted Execution Environments, supported by hardware-backed privacy and verifiability. This architecture is part of #Near Protocol’s vision for a more open and decentralized future in which AI systems belong to their users rather than closed platforms.
Staking plays two connected roles in this picture:
At the protocol level, users delegate $NEAR to validators, providing economic security to the Proof-of-Stake network.On the NEAR AI side, staked NEAR can provide access to confidential inference and IronClaw hosting credits. Agent hosting credits are determined by the amount staked, while confidential inference credits are generated from staking yield.
Users retain ownership of their principal, allowing their capital to support AI services without being sold.
For that reason, treating staking as nothing more than a passive yield faucet misses part of the picture. Here, capital acts like a circuit panel connecting network security and AI usage to the same system. On one side, it helps secure the network economically. On the other, it supports wallet-based access to user-focused AI infrastructure that agents such as IronClaw and OpenClaw can use.
The competition between AI agents will not be won solely by whoever has the largest model. The systems that coordinate decisions, permissions, memory, privacy, and economic infrastructure most effectively will stand out.
That is the powerful idea behind IronClaw 1.0: before making the agent’s brain a little bigger, redesign which doors the keys in its hands are allowed to open.
In your view, will the main bottleneck for enterprise AI agents be model intelligence, or turning that intelligence into safe action?