Recently, the automation level of the vault has taken another step forward. We started experimenting with using an AI Agent to drive the strategy on @NewtonProtocol . This isn’t about simply having GPT generate strategy code; instead, it lets the Agent directly operate the strategy engine’s API, dynamically creating, modifying, starting, and stopping strategies based on real-time market sentiment, contract funding rates, and even the trending heat of specific keywords on social media. After running it for a week, our return rate did outperform all static strategies, but it also sparked a deep debate between me and the developers in the Newton community.

The crux of the debate is this: when an Agent’s “intent” conflicts with the definition of a strategy, who should be the final judge?

Here’s a real example. Our AI monitored a USDC vault on a certain public chain and detected signs of panicked capital flight. It then decided to create a new “hard stop-loss” rule for our cross-chain lending strategy: immediately lower the collateral ratio cap for all our assets on that chain from 80% to 30%. This is a decisive move and could very well be correct. The AI wrote this new rule in Rego, called PolicyFactory’s API, deployed it to Newton, and the whole process took less than 3 seconds.

The issue is that this newly deployed “stop-loss rule” directly conflicts with the “maximize profits” rule we deployed earlier. The latter allows the vault to automatically compound when the collateral ratio is healthy. With both strategies active at the same time, they received the same price signal. Under Newton’s concurrent scheduling, the “undefined execution order” problem I mentioned in my previous report occurred. Ultimately, the compounding strategy executed first and fired all the bullets. Then the stop-loss strategy executed, but because the vault was already empty, it could only sell off the tiny remainder of assets.

AI’s intent is good—absolutely risk-averse. But the way it expresses that intent by combining existing strategies is crude and lacks global understanding. It takes a holistic decision that needs atomic execution, splits it into two independent, parallelizable modules, and then throws them into Newton’s machine of uncertainty. The result is ultimately worse than doing nothing at all.

This incident sparked a debate between me and some developers about the future form of “autonomous finance.” My view is that, with Newton’s current architecture, it’s just an intention-execution layer—it honestly and verifiably executes the specific rules (strategies) you tell it to. It’s not inherently a good intention-interpretation layer.

When AI is the brain, there’s a huge gap between it and Newton. AI outputs high-level, vague, and sometimes even contradictory multiple intentions. The process of translating those intentions into unambiguous, executable, non-conflicting low-level code (WASM strategy) is full of semantic loss and logical traps. AI might say, “Maximize the returns on chain A while ensuring safety.” But Newton’s engine can’t understand “while ensuring safety”; it can only understand code like: if (collateralRatio > 30%) { compound(); }. This code completely fails to capture the premise of “ensuring safety” unless you define all the dimensions of “safety” as quantifiable, non-conflicting mathematical constraints.

So whose responsibility is it? AI developers will say that Newton’s execution environment isn’t deterministic enough, leading to concurrency conflicts. Newton developers will say the protocol only faithfully executes the inputs; the responsibility lies with the AI’s decision logic because the instructions themselves are conflicting.

This debate points to a deeper need: we may require middleware like a “strategy compiler” or an “intent settlement” layer. It would receive AI’s high-level intentions, compile them into one or more Newton strategy packages that won’t conflict with each other, and that account for all boundary conditions and concurrency locks. It would be the Babel between the autonomous AI world and the off-chain deterministic execution world. $BTC

For NEWT, if the protocol can truly get to the point of becoming the “execution standard for autonomous agents,” its value would be immeasurable. But this road is far longer than you might think. We’re not only building an execution engine—we may have inadvertently touched the on-chain governance and decision automation version of Gödel’s incompleteness theorem. Any attempt to map a changing real world perfectly onto a fixed set of rules will ultimately see chaos and entropy growth in the gaps between the rules. Newton hands execution to cryptography, but the coursework of decision-making still has far to go. #Newt $NEWT @NewtonProtocol