aiagents

Paid Partnership
AI agents are becoming more useful every day, but most of them still operate inside closed platforms where users have very little control. The next stage of AI should not only focus on intelligence—it should also focus on ownership, transparency, and open participation.
That's one of the reasons I'm following @NewtonProtocol l and the progress of its Newton Mainnet Beta. The project aims to build infrastructure where AI agents can interact with blockchain networks in a verifiable and decentralized way instead of relying on centralized systems alone.
As the AI economy grows, developers will need reliable infrastructure to create agents that can execute blockchain-based tasks with greater accountability. Users also benefit from a system where actions are transparent and easier to verify.
If this vision continues to develop, Newton Protocol could become an important building block for the next generation of AI-powered Web3 applications. I'll be watching how the ecosystem expands as more builders and communities begin experimenting with the Mainnet Beta.
What type of AI agent would you like to see built on Newton Protocol in the future?
@NewtonProtocol $NEWT #Newt #AIAgents #Web3 #blockchain #crypto

Capability and authority are not the same thing. People often say the future of AI depends on making models smarter—better reasoning, better planning, and better memory. I think that view is missing something. The bigger challenge may not be improving intelligence. It may be deciding when software should stop making decisions on its own.
The more I watch AI agents move from chatbots to systems that can execute financial transactions, trade assets, or interact with smart contracts, the more important that difference feels. Every new capability gives software more power. But just because software can perform an action does not automatically mean it should. Capability describes what a system is able to do. Authority describes what a system has been allowed to do. Many systems today treat those two ideas as if they were the same. I think that is where problems begin.
That idea became much clearer while I was reading Newton's documentation. The mechanism is called Conditional Authorization, but the name was not what caught my attention. According to the docs, every Policy starts with default allow = false. The system does not give permission automatically. Every action has to satisfy predefined rules before it can execute. I do not see that as just another security feature. I see it as a different way of thinking about authority. Instead of asking, "Why should I block this?" the system asks, "Why should I allow this?" That small change creates a very different security model.
The documentation also shows how that principle is enforced. A PolicyData oracle provides the off-chain context that smart contracts cannot see on their own, such as sanctions status, token prices, or spend history. The Operator Network evaluates the proposed action against the Policy, and once enough independent operators agree, they produce a BLS Attestation. Finally, the PolicyClient verifies that proof before the transaction can execute.
No single component makes the decision by itself. Authority comes from multiple verification steps working together instead of relying on one decision maker. To me, that is one of the most interesting parts of the design.
One documented policy pattern stood out to me even more. Newton shows that a Policy can require off-chain human confirmation when a transaction crosses a defined value threshold. This is not a backup plan for when the system becomes uncertain. It is a rule the developer decided in advance. Beyond that point, the authority moves from the software to a human. The software does not fail. It simply recognizes that the next decision is no longer its own to make.
That is not a limit on the agent's capability. It is one of the reasons the agent becomes trustworthy enough to use.
I think this changes how we should measure good software. For years the main question has been how many tasks automation can replace. I am starting to think another question matters just as much: Does the system know where its responsibility ends? Software that works inside clear boundaries is easier to trust than software that relies only on its own judgment about when to stop.
The documented pattern makes that idea practical. A human approval threshold is not added because the agent is unreliable. It is added because some decisions carry more responsibility than others. Trust grows when authority is clear, verifiable, and shared instead of sitting with a single system.
That also makes delegation feel less risky. People are much more willing to let software handle important work when they know clear authorization rules and cryptographic verification stand behind every critical action—and that some decisions will always be passed to a human. The agent does not become less capable. Its boundaries simply become clearer. To me, that clarity is what makes it trustworthy.
I do not think the next generation of software will be defined only by what it can do. I think it will also be defined by what it deliberately does not do without permission. The smartest software will not be the one that makes the most decisions. It will be the one that knows which decisions should never belong to it.
Source: Newton Protocol Documentation (Core Concepts, AI Agent Security, Writing Rego Policies, Architecture). Terms such as Conditional Authorization, Policy, PolicyData, Operator Network, BLS Attestation, PolicyClient, and default allow = false are taken directly from the documentation. The framing, comparisons, and conclusions are my personal analysis.
@NewtonProtocol $NEWT #Newt #Web3 #AIAgents #defi

AI Agents Are Now Trading and Signing Deals With Each Other — So Who Settles the Fights?
Autonomous AI agents are already negotiating, paying, and contracting with one another — with zero humans in the loop. Now a 27-firm coalition has built the first court designed to settle their disputes.
On July 10, 2026, the GenLayer Foundation led a group of major Web3 firms — including OKX, MetaMask, and Matter Labs — in launching "Internet Court," a dedicated dispute resolution protocol built specifically for the emerging agent-to-agent economy.
◆ The coalition spans 27 crypto and Web3 companies, with more than 69 reusable open-source components contributed by 23 of them
◆ The protocol uses 1,001 AI validators to resolve agentic commerce disputes — no human arbitrator required
◆ Published resolution times run 30 to 60 minutes, at costs ranging from roughly $0.85 to $1.45 per case, depending on complexity
◆ GenLayer integrates the MetaMask Smart Accounts Kit, including ERC-7710 delegation standards and the x402 Facilitator, to let agents securely authorize transactions
◆ OKX has already named GenLayer as the dispute-resolution provider for its own AI agent marketplace, launched in beta the same day
◆ The system layers on top of existing standards rather than replacing them — Coinbase's x402 handles payments, ERC-8004 manages agent identity, and Google's A2A protocol governs agent-to-agent communication
◆ A competing framework, the Legal Context Protocol, launched just two weeks earlier with backing from Google, IBM, Circle, and Ava Labs — but takes a fundamentally different approach, attaching cryptographic fingerprints to transaction terms instead of using AI adjudicators
◆ GenLayer plans to expand its validator pool through a public token launch later in 2026
The core problem this solves is straightforward but urgent: as AI agents increasingly negotiate terms and commit funds in real time, there has been no mechanism to resolve disagreements when something goes wrong — a service falls short, a payment condition is disputed, a delivery doesn't match the agreement. Traditional legal systems simply were not built to operate at machine speed.
What's still unclear is whether rulings from Internet Court carry any binding legal weight outside the blockchain itself, or whether adoption spreads meaningfully beyond the founding coalition. Many open standards in Web3 have struggled to reach critical mass beyond their initial backers.
As agentic commerce moves from experiment to infrastructure, questions about accountability, verification, and enforcement are becoming just as important as the transactions themselves.
Do you think AI-run arbitration can earn the same trust as human dispute resolution, or does something get lost when no person is involved in the decision?
#Web3 #AIAgents #CryptoInfrastructure #DeFi #BlockchainTechnology

"AI-powered automation" pitches to default to skepticism whenever a project promises seamless agents managing money for you. Most of them turn out to be a nice UI wrapped around zero accountability.
What made me pay closer attention to Newton Protocol wasn't the AI narrative, it was a smaller detail buried in the mechanics: operators who run agent models from the marketplace have to stake real $NEWT as collateral first. Mess up the permissions, violate a verifiable policy, and that stake gets slashed.
Honestly, that's the part most people are skipping past while they chase whatever's pumping this week. An accountability layer that doesn't rely on a central authority babysitting every agent is a genuinely different structure than what most "AI trading bot" projects have offered so far — those usually had no teeth at all, just a dashboard and a promise.
The framework I keep coming back to for anything automation-related: does bad behavior actually cost the operator something, or is the only risk borne by the person who trusted the automation? Slashing flips that. It makes misbehavior expensive for the party actually running the agent, not just the end user holding the bag.
The mindset takeaway, and this one's personal: I got rugged on a similar automation play last cycle that had all the marketing language and none of the enforcement mechanism. Boring, unglamorous coordination infrastructure like collateral and slashing doesn't get the same attention as a flashy roadmap graphic, but it's usually the part that determines whether a system survives contact with bad actors. I'd rather bet on infrastructure with teeth than a pitch deck with a nice narrative.
#NewtonProtocol #NEWT #AIAgents

The future of AI agents is already here—and it’s being built on trust. 🤖🌐
We live in an era where autonomous agents distribute computing resources themselves. But how can you be sure they play by the rules? The answer is simple: decentralization.
We are pleased to announce: io.net is joining the Internet Court as a founding partner. 🤝

My technical assumption on@NewtonProtocol for AI Agents:
I recently started delegating real onchain tasks to AI agents which is automated yield strategies, position rebalancing, and trade execution. The shift felt exciting until I realized the core problem: capability is easy, but verifiable containment is hard.
NEWT Protocol has become my practical solution. It functions as a decentralized policy engine that intercepts agent decisions before they hit the blockchain. I code my constraints once — maximum daily volume, allowed contract addresses, risk thresholds, sanctions lists, and injection protections. These policies are then evaluated by Newton’s operator network. Only actions that pass receive a BLS-based attestation, which acts as cryptographic proof of compliance. The transaction is blocked otherwise.
What stands out technically is the clean architecture. Newton decouples policy logic from smart contract code, allowing dynamic, off-chain context awareness without bloating contracts. This means I can update rules or add new conditions without redeploying contracts. I also like the verifiable execution flow: the agent proposes an action, Newton validates it against my current policy state, and the attestation provides an immutable record I can audit later.
In my setup, I run agents with graduated authority. I begin with narrow scopes and short time windows, then expand based on clean attestation history. The logs give me a clear trace of every decision path. It’s not fully autonomous yet, but it’s the closest I’ve found to safe delegation with real capital involved.
@NewtonProtocol doesn’t solve every long-term coordination challenge (like multi-agent orchestration or intent drift over weeks), but it delivers one of the strongest practical enforcement layers available today. For anyone moving from experimentation to production-grade agent use, it’s a solid foundation. I’m now looking at layering higher-level authority structures on top of Newton’s base. Overall, it has noticeably increased my confidence in running agents 24/7. Curious — what technical setup are you using for agent guardrails?
#NewtonProtocol #NEWT $NEWT
#AIAgents

There’s a conversation the crypto ecosystem is having loudly: AI agents are going to transform DeFi. They’ll manage portfolios, execute strategies, rebalance vaults, and move capital at machine speed without human intervention.
It’s an exciting conversation. And it has a huge problem that almost nobody is talking about.
When an AI agent executes an onchain transaction, who verifies that it acted within the limits that were defined for it? Who confirms that the market conditions at that moment justified the action? Who ensures that the destination address isn’t on a sanctions list? Who checks that the price oracle it used to make the decision wasn’t corrupted?