DANISH_BNB

I’ve been thinking a lot about what the next phase of crypto and AI might look like. What if every savvy trader had a tiny autonomous “genius” working in the background, sifting through signals and executing trades? Newton Protocol (ticker $NEWT ) is an idea that tries to make that possible—a new blockchain layer where on-chain agents can run AI-driven strategies in a trust-minimized way. In fact, their documentation even calls Newton “a decentralized infrastructure layer for verifiable onchain automation and secure agent authorization.” In other words, instead of whispering private keys to some bot in the dark, you set strict rules in a smart system so agents only do what you’ve explicitly allowed.
I think of it like this: normally, bots can trade really fast—maybe too fast—and if all bots chase the same signals, the game changes. One crypto writer put it well: if thousands of agents converge on the same signal, “spreads compress, profitable opportunities disappear faster, and execution becomes the real bottleneck rather than the strategy.” In other words, everyone’s model might be brilliant in theory, but if the infrastructure can’t keep up, even genius strategies lose their edge. She asked, “Will the infrastructure still deliver efficient execution once everyone is using similar AI models?” That question stuck with me: it’s not just about making smarter algorithms, but about building rails strong enough to carry them.
Newton’s answer is to bake trust into the rails. Instead of handing an agent your private key, Newton’s “Keystore” is like a sandbox of permissions. You grant the agent only very narrow, revocable rights—a session key that can do X or Y and nothing more. As one overview explains, you “grant it granular, revocable permissions via session keys or zkPermissions, which are securely managed by the Keystore.” That means the bot can trade tokens or rebalance a portfolio, but it literally can’t drain your wallet or wander off doing random things. In practice, this feels comforting: you’re in control of exactly how much control the AI has.
On the technical side, Newton layers in Trusted Execution Environments (TEEs) and zero-knowledge proofs so that every agent’s action is cryptographically verified. In human terms, it’s like the agent runs inside a sealed box (a TEE) and then hands in a proof of what it did. The system checks that proof against your rules. As one summary puts it, Newton “combines TEEs and ZKPs” so that automation isn’t a hidden gamble but “a foundation of trust.” You might say they’re trying to clean up the plumbing under automated crypto, making sure that before any token moves, there’s a proof it was approved by you.
The vision even includes a kind of AI app store. Newton talks about an on-chain “agent marketplace” where developers can publish their trading strategies (or “agent models”) and even combine them into swarms. Imagine it like the Google Play Store for bots: any AI developer can list a strategy, users can discover and plug it in, and operators run those agents for fees. To keep things honest, operators must stake NEWT tokens as collateral. If their agent misbehaves or fails validation, some of that stake can be slashed. Essentially, each agent has “skin in the game,” so creators are incentivized to write high-quality code and follow through.
I picture the Newton ecosystem as a small society with different roles: there’s me, the user, who sets up an intent; a developer who writes the bot; an operator who runs it on the Newton rollup; and validators who stake NEWT to secure the chain. Each part has a job. As Newton’s materials show, it’s not just one black box but four pillars—user, developer, operator, and validator—each connecting in a network. In practice, I might pick an agent from that marketplace and give it permission to “only buy ETH up to X amount.” The system records that permission on-chain. When the condition hits, the agent does the trade and proves it did so correctly. This should all happen without me worrying that my funds are at some unknown risk.
All of this fits into a bigger trend of tokenized AI and data. It reminds me of ideas like Ocean Protocol or SingularityNET, where creators sell AI services or datasets on-chain. Ocean, for example, lets data owners tokenize their datasets into ERC-20 datatokens so others can pay for access. It’s like selling a piece of your own genius dataset to anyone who needs it. Likewise, SingularityNET describes itself as a platform that lets anyone create, share, and monetize AI services—basically selling little bots or algorithms on a global market. Newton is tapping into that same spirit: turning bits of human insight into marketable code or data, with tokens handling the value exchange. In a way, it could be seen as building a “genius economy” of its own, where smart ideas and models find buyers as easily as songs on a streaming service.
Of course, I’m asking myself: can people actually use this? The concepts are neat, but crypto folks can be skeptical. As one observer noted, Newton isn’t trying to hype how smart its AI is—it’s focused on getting the security model right. It “doesn’t ask you to forget everything crypto taught you about minimizing trust,” but instead ensures an automated system has limits from day one. That rings true to me. Crypto veterans don’t want another “just trust us” black box. If Newton builds in programmable limits like “only trade if volatility > X” and proof of execution, that at least sounds like the right priorities.
There are still challenges, though. Even if the tech works, will traders and developers jump on it? Adoption is always a hurdle. Many may find the onboarding complex or wonder why they should trust a new layer. Regulators might wonder who’s responsible when a bot goes rogue. Plus, as we wondered above, if everyone uses similar on-chain bots, will the network get jammed? Newton’s designers talk about scalability upgrades and multi-chain rollups, but it remains to be seen if the system can handle hundreds of thousands of agents. It’s one thing to speculate about a bustling agent marketplace and another to see if it really thrives.
On the flip side, I see potential. This system could remove tons of daily nonsense from my crypto routine. No more endless clicking or watching for price dips—a well-behaved agent can handle routine buys, staking, or token sweeps. The site mentions a recurring buy agent demo with over a million sign-ups already, showing some real interest. The key will be trust and simplicity: if using an agent feels almost as natural as a new feature in a wallet, more people might try it.
At its heart, Newton—and ideas like it—are about value and trust. They’re asking: can our data and algorithms be treated as first-class assets in an open market? Can an everyday user effectively license a bit of AI “genius” safely? I don’t have full answers yet. I remain a bit cautious, wondering kya sach me chal payega? (Will it really work?) The system is intricate, and any weak link could undo user confidence. But the notion is intriguing: a future where anyone’s algorithm—even mine—can become a money-maker if it’s good enough.
In the end, I’m left thinking about how all this matters in the bigger picture. It’s not just about one protocol. It’s about whether we can build shared, trustful infrastructure for machine intelligence on the blockchain—an ecosystem where AI, blockchain, and data monetization evolve together. Projects like Newton are just one piece of that puzzle, inspired by the same ideas that drive data marketplaces and AI platforms. The road ahead will be long, with experiments and missteps. But it’s encouraging to see teams thoughtfully addressing trust and scalability, not just hyping the next AI craze.
I’ll remain watchful and curious. Maybe this is the “genius” idea that quietly takes hold, or maybe it’s a stepping stone to something else. What’s clear is that in a world where information is power, we’ll need smart ways to trade and secure that information. Newton’s attempt—building an authorization layer for on-chain automation—is a thoughtful take on it. I don’t have a definitive verdict yet. It feels more like a sunrise than a sudden blaze: we’re just beginning to see how AI and blockchain might co-create a new economy. That kind of thinking out loud feels right. This story isn’t done yet, and I’m eager to see how each new chapter unfolds.
Sources: Newton’s design and goals are described in its whitepaper and project reports. Commentators have noted both the promise and challenges of AI trading on-chain. Related projects like Ocean Protocol and SingularityNET illustrate how data and AI can be tokenized and monetized. Each citation is shown for reference.
@NewtonProtocol #Newt #Newt $NEWT

I’ve been thinking a lot about how AI and blockchain might really come together, and Newton Protocol keeps popping up in those musings. Imagine this: you want an AI “agent” to manage your crypto trades or move your funds when certain conditions are met – but you don’t want to just hand it your private keys and pray. In the real world, that’s like trusting a self-driving car with your life without any safety checks. Newton’s idea, as I’ve been reading, is to build a “secure rollup” layer specifically for AI-driven strategies and automated trading, plus a kind of marketplace where developers can list and share their smart AI agents. Instead of trusting these agents as black boxes, Newton insists on verifiable “guardrails” that the AI must follow. It’s like having a trusted conductor who checks every move the orchestra (AI agent) makes, ensuring it only plays notes we authorize and never goes off-script.
On a gut level, this feels important. We’ve seen what happens when wild bots or algorithms run loose without checks – crashes, hacks, or just plain unpredictable mistakes. Newton tackles this by splitting the problem into parts. There’s an on-chain Model Registry where developers publish their AI “agent models” (essentially smart contracts defining trigger-action logic). Think of it like an open library of recipe cards for trading strategies or financial moves. Then there’s a special layer called the Keystore Rollup. Instead of giving an AI your full car keys, you give it a valet key with very limited permissions: you can say, “Drive my car to the grocery store and back, but don’t take it out of the driveway.” In Newton’s world, you grant granular, revocable permissions (possibly using session keys or zero-knowledge proofs) for exactly what the AI agent is allowed to do. Finally, you submit an “Intent” – a user instruction linking your wallet to the agent model you picked. The Newton network then makes sure the agent executes that intent exactly as instructed, and crucially, only within those permission boundaries.
Under the hood, it’s a three-layer design: the policy or intent layer, the off-chain compute and consensus layer, and an on-chain verification layer. What I found fascinating is that when an agent is about to act, Newton’s decentralized operator network (secured by staking NEWT tokens and restaking through EigenLayer) independently evaluates the policy (the rules you set) off-chain. Each operator signs the result, and a BLS cryptographic aggregator combines these signatures into a single proof. This proof is then verified on-chain before the transaction executes. In simple terms, it’s like having dozens of librarians each verify your cookbook instructions and all signing off before the stove is even turned on. If the proof checks out, the action goes through; otherwise it’s blocked. Every step is logged on-chain, so there’s an auditable trail that anyone (or any auditor) can check.
What excites me is how this solves the trust gap. Usually, AI-based automations demand a lot of blind faith. But now, “verifiable decision-making” becomes the norm. As one observer noted, instead of trusting outputs blindly, systems built on Newton actually verify each reasoning step. It’s the difference between letting an algorithm roam free versus putting it on a leash with a GPS tracker that we control. The longer-term vision even hints at “verifiable AI reshaping decision layers in systems that depend on uncertainty”. For example, in DeFi or real-world logistics, correctness and auditability could become more important than raw speed. The AI isn’t just optimizing for profit; it’s optimizing for correctness under known constraints. The Newton token ($NEWT ) ties into this by staking operators and incentivizing honest service, so if an agent misbehaves, its collateral can be slashed.
All of this reminds me of building a car with an autopilot: you need seatbelts, regulations, and the ability to override if something goes wrong. Newton’s use of TEEs (Trusted Execution Environments) and zero-knowledge proofs is like having a black box flight recorder and privacy layer all at once – it verifies the outcome without exposing your sensitive data. The protocol even uses the latest cryptography (BLS signatures and ZK proofs) to keep user info private while still proving compliance. It’s like whispering to a bodyguard what’s allowed, who then nods and steps in only if the orders are followed, all without you shouting on a loudspeaker.
On the blockchain architecture side, Newton is essentially a specialized Layer-2 rollup with a delegated proof-of-stake consensus. The NEWT token is used in multiple ways: securing the network by staking, paying gas fees on this rollup (for submitting intents and managing permissions), and even as collateral for agent operators. There's also governance in the mix. So it’s not just a one-trick pony: it’s planning an entire economy for AI agents. In fact, one write-up compares Newton to Ethereum by saying it’s “not an Ethereum killer; rather, a specialized Layer-2 leveraging Ethereum’s security to perform a function that a general-purpose chain is not optimized for”. In other words, Newton is like building a dedicated high-speed train on top of existing tracks, just for AI agents.
Reading about Newton also made me think of the broader data-monetization angle. Developers can list their AI models in the onchain registry and earn NEWT tokens when users run them. It’s like an app store or marketplace for AI strategies, but open and crypto-native. A hit algorithm could become a digital cash cow, and users pay small fees (in NEWT) to use it under strict rules. The hope is to reward innovation: if someone builds a genius trading strategy or a smart insurance agent, they get paid directly. This aligns with the idea that knowledge (or genius) deserves value. It reminds me of saying “Genius ko pehchaan do, bhai – give credit and value to the smart brains” in more casual terms. By embedding royalties and collateral into the system, Newton tries to make it practical to buy and sell AI-driven services onchain.
Of course, I also wonder: can this really work in the messy real world? There are challenges. For one, users and institutions have to actually trust the Newton stack. Integrations with players like Magic Labs (a wallet and identity provider) are promising – Magic announced they’re baking Newton’s compliance engine into their tools. That suggests big wallets will have built-in seatbelts. Regulators will want to see those compliance checks (KYC, sanctions lists, etc.), and Newton is even advertising that it can enforce those at the transaction level. But getting average users to adopt this kind of automated system might be slow. People still worry about handing control to bots, whether in Hinglish or English. Some will say “yeh kaise patta chalega ki AI sach-me safe hai?” (“How will I know the AI is truly safe?”). Newton’s answer is transparent proof, but will that reassure them enough to try it?
Scalability and security are also on my mind. Tying the rollup security to EigenLayer restaking is clever, but it’s a young approach. If the operator network is too small or if threshold failures happen, those guardrails weaken. On the flip side, with enough validators, it might become more robust than some centralized oracle or offchain service. Performance is another question: can all these policy checks and ZK operations happen quickly enough for real-time trading? The enthusiasts say Newton’s not about millisecond HFT, but about “agent economy” things that can tolerate a short delay for a big gain in trust. I guess we’ll see if people are okay waiting a moment for peace of mind.
I also compare Newton’s vision to other projects. There are AI data networks like SingularityNET or Ocean Protocol that let you trade models and data, but they don’t enforce execution of those models onchain. There are some compute-rollup ideas (like Render Network for GPUs), but Newton is more about decision-making and finance. An interesting mention I saw was that venture capital has been eyeing “AI rollups” in general – frameworks like a16z’s Eliza – so Newton is part of a wave. But each has a different flavor: Newton’s heavily focused on compliance and finance from day one, whereas others might be more general or data-focused.
At the end of the day, I find Newton’s mix of AI + blockchain pretty thought-provoking. It’s a calm but ambitious attempt to thread that needle: giving AI agents autonomy while keeping them in chains of trust. As someone who likes both cutting-edge tech and good old human assurance, this is the kind of hybrid idea that intrigues me. Will it catch on? Maybe. It feels a bit like we’re witnessing the early days of an “autonomous agent economy” – crypto traders using bots on bots. If enough people buy into the idea of “verifiable automation,” we might see more projects putting policies on autopilot. Or maybe we’ll find that some tasks just aren’t ready to be handed over that way.
In any case, Newton suggests a future where every AI-driven action has a little certificate attached, saying “Yes, this was allowed.” That kind of transparency is worth reflecting on. Perhaps, as I sip my chai and consider our techy future, I find some comfort in the idea that even self-driving markets could obey the traffic lights. Perhaps the real genius of Newton is simply that: it forces us to prove to ourselves that we trust the machine – not just hope. That thought, at least, leaves me with more questions than answers, but also a bit more clarity about what good trust onchain might look like. It’s an ongoing story, and I’m keen to see where we drive next.
Sources: Technical and conceptual details drawn from Newton Protocol documentation, Magic Labs and Newton announcements, and recent deep dives and community insights.
@NewtonProtocol $NEWT #Newt

I’ve been thinking about Newton Protocol, and the more I sit with it, the more it feels like one of those ideas that is trying to solve a problem people only fully notice once money, automation, and trust are all in the same room. On the surface, the pitch sounds straightforward enough: a system for AI-driven strategies, automated trading, and developer participation. But underneath that, the real question is bigger and a little more interesting. What does it actually mean to let an AI act inside a financial system without turning the whole thing into a leap of faith?
That is where the Genius-like lens becomes useful. Not as a literal comparison, but as a conceptual one. The deeper attraction of these ecosystems is rarely just AI or blockchain in isolation. It is the possibility of making data, permissions, incentives, and execution feel like one connected system instead of four separate systems that barely speak to each other.
The AI story has already moved beyond simply building smarter models. The more interesting challenge is delegation. Who decides what an AI is allowed to do? How much authority should it have? What limits should exist before it moves assets, executes trades, or interacts with decentralized applications? Newton Protocol appears to be exploring that space by combining AI with blockchain-based verification and programmable permissions.
Imagine giving someone the keys to your house. You probably would not hand over unrestricted access forever. You might say they can enter only during certain hours, only specific rooms, and only for a particular purpose. AI systems deserve similar boundaries. Instead of unlimited authority, they need clearly defined permissions that can be verified before actions happen rather than explained afterward.
That is what makes Newton Protocol interesting to me. It shifts attention away from making AI more powerful and toward making AI more accountable. Those two goals are related, but they are not the same thing. An intelligent system without meaningful constraints can create just as many problems as opportunities.
This idea also connects with something I keep noticing across decentralized AI ecosystems. Data is slowly becoming more than information. It is becoming context. It determines what an AI knows, what it can access, how it behaves, and ultimately who benefits from the value it creates. In that sense, blockchain is not simply recording transactions. It can also become a framework for recording permissions, incentives, and trust relationships.
Of course, turning that vision into reality is another challenge entirely. Technology often looks elegant on paper. Real-world adoption is much less predictable. Developers need tools that are easy to integrate. Users need experiences that feel simple instead of complicated. Institutions need compliance without sacrificing efficiency. Every additional layer of security introduces additional complexity, and finding the right balance is never easy.
Sometimes I wonder whether people actually care about decentralized AI infrastructure or whether they simply care about applications that work. Most users do not think about protocols when they send an email or make an online payment. They care about reliability. Maybe decentralized AI will follow a similar path where the infrastructure becomes almost invisible once it matures.
There is also the question of trust. Blockchain provides transparency, but transparency alone does not automatically create confidence. People still need to understand what they are trusting and why. If AI agents begin making financial decisions, users will naturally want evidence that those actions followed predefined rules instead of unpredictable behavior.
This is where Newton Protocol feels aligned with a broader shift happening across the industry. The conversation is gradually moving away from simply building autonomous AI toward building verifiable AI. Intelligence is valuable, but accountability may become even more valuable as these systems begin interacting with real assets and real economic activity.
The developer marketplace aspect is equally interesting because sustainable AI ecosystems rarely emerge from a single company. They grow when independent developers can contribute models, strategies, applications, and infrastructure while receiving incentives that match the value they create. Blockchain can help coordinate those incentives in ways that traditional platforms often struggle to achieve.
Still, questions remain. Will developers embrace another protocol? Will institutions feel comfortable allowing AI agents to execute meaningful financial actions? Can decentralized governance evolve quickly enough to keep pace with rapidly improving AI capabilities? These are not easy questions, and they probably will not have immediate answers.
Maybe that uncertainty is exactly why projects like Newton Protocol deserve attention. Not because success is guaranteed, but because they explore problems the industry will eventually have to solve. As AI becomes increasingly capable, governance, verification, and programmable trust may become just as important as model performance itself.
I do not see Newton Protocol as a finished destination. I see it as part of a much larger conversation about how intelligence, incentives, and decentralized infrastructure might evolve together. Whether this particular approach becomes widely adopted or simply influences future systems remains to be seen.
For now, I keep coming back to the same thought. The future of AI may not belong to the systems that can think the fastest. It may belong to the systems that people feel comfortable trusting. If blockchain can help create that trust while AI continues expanding what machines can do, then projects like Newton Protocol represent something worth watching, not because they promise certainty, but because they invite us to think more carefully about the kind of digital economy we are actually building.
@NewtonProtocol $NEWT
#Newt

I’ve been thinking about Newton Protocol in the same way I think about a lot of the more interesting crypto ideas: not as a shiny token story first, but as a question about what kind of system people actually need once automation stops being a toy and starts touching real money. Newton describes itself as “the authorization layer for onchain finance,” and more specifically as a decentralized policy engine for onchain transaction authorization built as an EigenLayer AVS. In plain terms, it is trying to solve a very unglamorous but very important problem: how do you let AI agents, smart contracts, and automated workflows move value without giving them a blank check? That question feels almost obvious once you say it out loud, but in practice it is where a lot of the real design work begins.
What makes the idea compelling is that Newton is not really promising magic. It is promising guardrails. The docs describe smart contracts as being blind to offchain context, things like whether a user is sanctioned, whether an AI agent is behaving badly, or whether a transaction violates a corporate policy. Newton’s answer is to bridge that gap with real-time offchain data such as KYC status, market feeds, and proof of reserves, evaluated by a decentralized operator network and enforced at the smart-contract level. That is a much more grounded ambition than the usual “AI plus blockchain” pitch. It is less about making everything autonomous and more about making autonomy survivable.
The part that keeps pulling me in is how close this gets to the idea behind Genius, where the deeper value is not simply data floating around on a chain, but data becoming usable inside a system of trust, incentives, and monetization. Newton’s version of that logic seems to be: if AI agents are going to act on behalf of people, then the system should not trust the agent alone, or the wallet alone, or the interface alone. It should verify the intent against a policy before the transaction settles. On the homepage, Newton says that a lightweight snippet can connect a smart contract to policy enforcement, that the Newton AVS evaluates each transaction before settlement, and that every evaluation produces a signed onchain receipt anyone can verify. That is the kind of architecture that turns a vague promise into something closer to infrastructure.
And honestly, that is where the story becomes more interesting than the marketing. Because the real world does not run on clean assumptions. Businesses have restrictions. Users make mistakes. AI systems hallucinate. Regulations shift. Counterparties fail. In that environment, the value of a protocol like Newton is not that it makes everything permissionless in some dramatic way. It is that it tries to make permissioned behavior programmable, portable, and verifiable. The site says it supports policies written in Rego and can combine onchain and offchain signals such as sanctions, identity, and risk limits. It also points to use cases like DeFi vaults, RWAs, stablecoins, and agentic finance, where spending caps, approved payees, mandate enforcement, and prompt-injection defense matter a lot more than ideology. That feels practical. Thoda boring, maybe, but boring is often what makes systems usable.
In the AI economy, that practicality matters even more. If an AI developer wants to build an autonomous trader, or a treasury agent, or a policy-aware assistant that can move funds, the question is not only whether the model is smart. The question is whether the model can be contained. Can it operate within limits? Can it prove that it followed the rules? Can a user or institution audit what happened after the fact? Newton’s docs lean into this by emphasizing verifiable trust, privacy-preserving design, and chain-agnostic verification across EVM networks like Ethereum, Base, and Arbitrum, with non-EVM support on the roadmap. The whitepaper frames the protocol as filling a missing authorization layer in onchain finance and explicitly connects it to stablecoins, RWAs, institutional DeFi, and agentic commerce. That positioning matters because it shows Newton is not just chasing “AI trading” as a narrative; it is trying to become the control layer underneath it.
Still, this is where the reflective part of the conversation has to stay honest. A protocol can define elegant rules, but adoption is never just about elegance. It is about whether people can integrate the thing without friction, whether the policy logic is understandable, whether operators are trusted, and whether the system is fast enough not to feel like a tax on every transaction. Newton says the setup can go live quickly, with templates, SDKs, and a dashboard, and it claims that only compliant transactions go through while keeping the user experience unchanged. That sounds good on paper. But in real life, “simple” often hides a lot of complexity. Who writes the policy? Who updates it when the market changes? What happens when a rule is too strict, or too loose, or just poorly designed? A system like this only earns trust if it makes those tensions visible instead of burying them.
There is also the unavoidable question of scalability. Not just throughput in the narrow technical sense, but social scalability. Can enough people agree on these policy frameworks for them to matter across ecosystems? Can institutions trust a decentralized operator network as much as they trust a familiar centralized compliance provider? Can developers see enough demand to build on top of the marketplace layer rather than treating it as one more tool that sounds promising but ends up underused? The docs say Newton is modular and chain-agnostic, with standardized SDK interfaces for wallets, dApps, AI agents, and DeFi protocols, which is a strong start. But the harder part is getting a network effect around trust itself. Trust is not just code. It is habit, reputation, and precedent.
That is why the token snapshot on Etherscan feels useful as a grounding detail rather than a headline. At the moment, Etherscan lists NEWT as an ERC-20 token with 18 decimals, a max total supply of 1 billion, about 215 million circulating supply, roughly 12,988 holders, and a price around five cents in the current snapshot. It also shows the contract as an ERC1967Proxy and notes that no contract security audit has been submitted on the page. None of that decides the future, of course, but it does remind you that behind the conceptual architecture there is still a live asset, live ownership distribution, a proxy contract, and the usual mix of maturity and unfinishedness that comes with young networks.
Maybe that is the most honest way to read Newton: as a serious attempt to make onchain automation less reckless. The project is not really saying AI should replace human judgment. It is saying AI should be allowed to act only inside a verifiable frame of rules. That is a subtle but important difference. In a way, it fits the broader Genius-style thesis: the future of decentralized systems may not belong to the loudest narratives, but to the protocols that make data, intent, and value interact in a way people can actually trust. Whether Newton becomes one of those protocols will depend on adoption, yes, but also on whether its policies feel real to institutions, legible to developers, and invisible enough to users that the experience still feels natural. And maybe that is the real test for any AI-blockchain system: not whether it sounds futuristic, but whether it can disappear into the background while quietly doing the hard work. That is the kind of infrastructure people eventually rely on without even noticing, and maybe that is where the strongest projects are heading all along.
@NewtonProtocol
$NEWT #Newt