M_ORHAN

Newton Protocol is trying to solve a problem that looks simple from the outside but becomes much harder once real money, compliance rules, and outside data are involved. It is not enough for the project to approve a transaction quickly. The stronger test is whether that approval can still be understood months or even years later.
That is where Newton Protocol will either prove its value or expose its limits.
The project is designed to check transactions before they are completed. A user or application submits a request, Newton applies a policy, operators review the required information, and the transaction is either approved or rejected. The final result can then be verified onchain.
At first glance, this sounds like a clean process. The rule is checked, the answer is signed, and the transaction moves forward.
But compliance is rarely that clean.
A signed result can show that a decision was made. It does not always show why that decision was made.
Imagine a fund using Newton Protocol to control where capital can be deployed. Before a transaction is approved, the system may check the destination contract, the size of the transfer, the fund’s current exposure, a wallet risk score, and a sanctions result.
The transaction passes.
A year later, an auditor reviews it.
The auditor will need more than a record saying the transaction was approved. They may need to know which version of the policy was active, what data was used, where that data came from, when it was collected, and whether the policy settings had changed shortly before the decision.
They may also need to confirm that the transaction which finally happened was exactly the same transaction Newton Protocol originally approved.
This is the real difference between a transaction record and a decision record.
A blockchain can show that money moved. Newton Protocol must also show why the system allowed it to move.
That becomes difficult because many of the checks Newton may perform depend on information from outside the blockchain.
Sanctions data, identity checks, risk scores, market prices, collateral values, and wallet history may come from external services. That makes Newton more useful, but it also creates a problem for anyone trying to review an old decision.
Onchain data is usually easy to find later. External data is not.
A provider can change its model. A database can be updated. An error can be corrected. An endpoint can disappear. A company can stop offering the service completely.
The answer that existed at the moment of the transaction may no longer be available in the same form.
Newton Protocol can reduce disagreement by having operators collect data independently and agree on a shared result. That helps the network make a decision at the time.
It does not automatically create a complete record for the future.
A reviewer may still need to see the original responses, the final value used by the policy, the time each response was received, and the method used to combine the information.
They may also need to know whether any operator returned a very different result and whether that result was rejected.
If Newton stores only the final answer, then part of the reasoning disappears.
That matters even more when a transaction is rejected.
A blocked transaction may never appear on the destination chain, but the rejection can still have serious consequences. A customer may believe a sanctions check was wrong. A business may want to know why a normal payment failed. A regulator may need to review repeated attempts to move funds past a risk limit.
Those decisions deserve the same level of evidence as successful transactions.
Newton Protocol should also preserve cases where no clear answer was reached. Operators may disagree. Data may be missing. The required number of approvals may not be reached.
That failure is still part of the story.
A useful compliance system should not only record what passed. It should also record what failed, what was blocked, and what could not be decided.
Privacy makes this harder.
Newton Protocol may handle information that should never be placed openly on a public blockchain. Identity documents, financial records, private risk rules, customer information, and internal blocklists need protection.
The project’s privacy model is meant to keep sensitive inputs hidden while still allowing a policy to be checked.
That is necessary, but privacy cannot become an excuse for losing the evidence.
Private information does not need to be public. It does need to remain available to the right people under the right conditions.
A public record could show that an identity check passed without exposing the person’s documents. The original evidence could remain encrypted, while the record still shows who issued the credential, what type of check was used, which policy was active, and when the decision happened.
The same idea could apply to a risk score.
The public record might show the data provider, the model version, and a cryptographic commitment to the result. The full score could remain private but still be available to an approved auditor.
This is the balance Newton Protocol needs to get right.
A hash can prove that some data existed, but it cannot explain the data if the original file is gone. Encryption can protect information, but only while the keys, storage, and access process still work.
That means Newton’s long-term value will depend on more than signatures and smart contracts.
The project will need clear rules for how long evidence is stored, where it is stored, who can access it, and what happens when old providers or systems disappear.
It will need to preserve policy files, policy settings, outside data references, operator details, and the final transaction linked to the approval.
These may sound like operational details, but they are central to the product.
If the records cannot be recovered later, then the compliance system has a memory problem.
Newton Protocol is still developing, so it is easy to focus on transaction growth, integrations, supported chains, and total value moving through the system.
Those numbers will matter, but they can also hide weak foundations.
A project can process many simple transactions while still failing to preserve enough evidence behind them.
A better test would be to pick an old Newton decision at random and try to rebuild it from the beginning.
Can the reviewer find the exact policy that was used?
Can they see the settings chosen by the user or application?
Can they confirm which operators took part?
Can they verify the outside information used during the check?
Can they understand why the request passed or failed?
Can they connect the approval to the final onchain action?
If all of that can be done without asking Newton’s team to explain what happened, the system becomes much stronger.
The evidence should stand on its own.
This is also important for disputes.
Newton Protocol may allow incorrect decisions to be challenged, but a challenge process is only useful when the evidence is available to the people making the challenge.
If the important data is held only inside Newton’s own systems, users may still depend on the same infrastructure they are trying to question.
If the evidence disappears too quickly, the right to challenge becomes weak in practice.
The strongest version of Newton Protocol would give every transaction a complete and portable evidence package.
That package could include the original request, the policy, the policy settings, the outside data used, the operators who took part, the final result, the signatures, the expiry time, the challenge status, and the transaction that used the approval.
Private information could stay encrypted.
The key point is that the record should remain useful even if Newton changes its website, replaces a service, updates its interface, or loses an old data provider.
An auditor should not need the original dashboard to understand the decision.
That is where Newton Protocol can become more than a compliance label attached to a transaction.
A label says the transaction passed.
A full record explains why it passed.
The market will probably judge Newton by the usual numbers. Transaction count. Supported networks. Integrations. Fees. Value secured.
Those figures are useful, but they do not measure the quality of the system’s memory.
A more meaningful number would be the percentage of old decisions that an independent reviewer can fully reconstruct.
Newton could measure how many records still contain complete policy data, operator details, outside data evidence, and links to final execution.
It could track how long a reconstruction takes.
It could report how many rejected transactions have complete records and how often old external data can no longer be recovered.
Those numbers may sound less exciting than transaction growth, but they would tell serious users far more.
Newton Protocol is built around a strong idea. Rules should be checked before money moves, not after something goes wrong.
But checking the rule is only half the job.
The other half is preserving enough evidence to explain the decision later.
A fast system can approve a transaction in seconds.
A trustworthy system can still defend that approval years later.
That is the standard Newton Protocol should be measured against.
Not how many transactions it processes, but how many decisions remain clear, complete, and understandable long after the transaction is finished.
$NEWT
@NewtonProtocol #Newt $NEWT

I spend a lot of time reading about new blockchain projects, and after a while many of them start blending together. The promises are usually familiar—faster transactions, lower fees, bigger ecosystems. There's nothing wrong with those goals, but they don't always answer the question I care about most: what problem is this project actually trying to solve?
That was the reason I stopped and looked more closely at @NewtonProtocol.
The idea that stood out to me wasn't about chasing the highest transaction speed. It was about making blockchain applications capable of following clear, verifiable rules without depending on a single company or service to make every decision. As more apps become automated, that's a challenge that feels very real.
Think about it this way. Not every on-chain action should happen automatically just because someone clicked a button. Sometimes there should be limits, approvals, or conditions that need to be checked first. Maybe a transaction should only go through if certain requirements are met. Maybe an automated service needs to follow rules before moving assets. Those situations become more common as blockchain technology grows beyond simple token transfers.
From what I've learned, Newton Protocol is building with that future in mind. Instead of treating policy checks as something that happens off to the side, the project is working toward making them part of the decentralized process itself. That approach makes sense to me because it keeps the focus on transparency rather than putting another trusted middleman in the middle of everything.
The Newton Mainnet Beta is also an interesting step. Every project looks impressive on paper, but a live network tells a much more honest story. That's when developers begin experimenting, validators test the system under real conditions, and the community starts discovering what works well and what still needs improvement. I always find that stage more interesting than flashy announcements because it's where real progress begins.
I'm also curious to see what developers build once the ecosystem grows. Good infrastructure usually isn't the part people talk about every day, but it's often the reason useful applications are possible in the first place. If builders have reliable tools and a network they can trust, the chances of seeing creative use cases become much higher.
Of course, every young project still has to prove itself over time. Adoption doesn't happen overnight, and strong technology alone isn't enough. It takes an active community, consistent development, and people willing to build real products instead of chasing short-term attention.
I'll be watching how Newton Protocol develops from here. The Mainnet Beta feels less like the finish line and more like the point where the real work begins. If the team continues improving the network while developers start creating practical applications, it'll be interesting to see where the ecosystem is a year from now.
$NEWT
@NewtonProtocol #Newt

Newton Protocol is built around a simple but increasingly important idea: autonomous software should not be able to execute onchain actions without clear, verifiable authorization. As blockchain applications become more capable, users, institutions, and developers are beginning to rely on software agents to perform tasks such as managing assets, interacting with decentralized applications, and executing transactions automatically. Newton Protocol focuses on providing the infrastructure that allows these actions to happen within predefined rules instead of giving software unrestricted authority over digital assets.
The protocol introduces a decentralized authorization layer that sits between an autonomous agent and blockchain execution. Before an action is completed, the protocol evaluates whether it satisfies a set of programmable policies created by the asset owner or application. Rather than depending on a centralized server or application interface to approve or reject requests, Newton Protocol enables authorization decisions to be verified through its decentralized network. This approach is intended to give users greater confidence that automated actions remain within approved limits.
Newton Protocol is designed for an environment where software agents are expected to perform increasingly complex tasks. These agents may execute trades, move assets between protocols, participate in decentralized finance, manage treasury operations, or interact with tokenized real-world assets. As the number of autonomous agents grows, managing permissions becomes just as important as enabling execution. The protocol focuses on making authorization programmable so that permissions can be tailored to different applications, users, and organizations.
A key part of the protocol is its policy engine. Policies define the conditions that must be satisfied before a transaction or action is approved. These conditions can include spending limits, approved counterparties, identity requirements, geographic restrictions, time-based permissions, or application-specific rules. Because policies are programmable, developers can create authorization frameworks that reflect the requirements of their own products instead of relying on fixed permission models.
Newton Protocol also separates authorization from execution. Blockchain transactions may ultimately be processed by existing networks, but the decision about whether an action should proceed is evaluated through the protocol's authorization process. This separation allows applications to introduce security and governance controls without changing the underlying blockchain itself.
The protocol is designed to work with information that exists both onchain and offchain. Many important decisions cannot be made using blockchain data alone. Identity credentials, compliance information, risk assessments, and other external signals may all influence whether a transaction should be approved. Newton Protocol provides a framework for incorporating verified external information into policy evaluation while maintaining decentralized verification of authorization decisions.
Privacy is another important consideration within the protocol's design. Many applications require sensitive information during authorization, yet users and organizations may not want that information permanently exposed on a public blockchain. Newton Protocol describes an approach that allows policies to evaluate credentials and other required data while limiting unnecessary disclosure of private information during the authorization process.
The protocol also introduces a decentralized network of operators responsible for evaluating policies and producing verifiable authorization results. Instead of trusting a single organization to determine whether an action is allowed, multiple participants contribute to the authorization process. This design supports transparency and reduces dependence on centralized decision-makers while allowing applications to verify that required policies have been satisfied.
Newton Protocol's documentation describes a streaming consensus mechanism that helps operators evaluate policy decisions using a consistent view of external information. This is intended to reduce inconsistencies that may occur when different participants receive changing data at different times. By coordinating policy evaluation before authorization is finalized, the protocol aims to improve reliability for applications that depend on external information.
The protocol is designed to support a wide variety of blockchain applications. Developers can integrate Newton Protocol into decentralized finance platforms, payment systems, tokenized asset platforms, autonomous software agents, institutional blockchain applications, and other environments where programmable authorization is required. Rather than replacing existing smart contracts, the protocol is intended to complement them by adding an additional layer of policy-based authorization.
Newton Protocol also emphasizes flexibility for developers. Different applications have different security requirements, governance models, and compliance obligations. The protocol's programmable policy framework allows developers to define authorization logic that reflects their own operational needs without requiring every application to follow the same permission structure.
As blockchain ecosystems continue to evolve, autonomous software is expected to perform increasingly valuable financial and operational activities. Newton Protocol addresses one of the central challenges created by this shift: ensuring that automated actions occur only within clearly defined and verifiable boundaries. By focusing on decentralized authorization, programmable policies, privacy-aware verification, and coordinated policy evaluation, the protocol aims to provide infrastructure that supports secure and responsible onchain autonomy while preserving the decentralized principles of blockchain technology.
@NewtonProtocol #Newt $NEWT

I'll admit it—I usually scroll past crypto projects that casually mix "AI" and "blockchain" into the same sentence. It has become an easy way to grab attention, and most of the time there's not much underneath. Newton Protocol feels a little different. Maybe it works out, maybe it doesn't, but at least it's trying to solve a problem that seems real rather than inventing one.
The idea behind Newton Protocol (NEWT) is surprisingly straightforward. Instead of creating another blockchain that tries to do everything, it's focused on building a secure rollup for AI-driven strategies, automated trading, and a marketplace where developers can build and share AI agents. That sounds technical at first, but the thinking behind it is actually pretty simple.
Blockchains were designed with people in mind. We open wallets, approve transactions, wait for confirmations, and make decisions one step at a time. AI doesn't work like that. An autonomous agent can monitor several markets simultaneously, react within seconds, and execute dozens of actions before a human has even finished reading a price chart. Those are two completely different ways of interacting with a network.
That's why the project caught my attention.
If AI is going to become more involved in decentralized finance—and it honestly looks like it's heading that way—it probably shouldn't rely on infrastructure built for occasional human activity. A specialized environment starts to make sense once software begins making financial decisions on its own.
The security angle is what interests me the most. Speed is nice, but speed without safeguards can become a disaster. An AI model doesn't get distracted or tired, but it can absolutely make the wrong decision. The difference is that it can repeat that mistake over and over again at machine speed. Imagine an automated trading strategy placing hundreds of bad trades before anyone realizes what's happening. Not exactly something you'd want to experience.
Newton Protocol seems to recognize that risk. Rather than treating security as another marketing slogan, it places secure execution at the center of the conversation. Personally, I think that's a smarter approach than endlessly competing over who has the fastest blockchain.
There's another piece that deserves attention too—the marketplace for AI developers.
As AI tools become more specialized, developers will need places where they can distribute their work and earn from it. Newton Protocol imagines an ecosystem where people build autonomous agents for trading, portfolio management, market research, or other financial tasks, while users choose the ones they trust. It's an interesting model because value comes from useful software instead of endless speculation.
Of course, reality won't be perfect.
Some AI agents will perform brilliantly. Others won't. A few will probably gain popularity simply because they're marketed well rather than because they're genuinely effective. That's how open markets have always worked. Users will still need common sense. AI isn't a replacement for critical thinking, no matter how advanced the technology becomes.
One thing I appreciate is that the project doesn't rely entirely on futuristic promises. It focuses on infrastructure, and infrastructure is usually less exciting than flashy consumer products. Funny enough, that's often where the real value ends up being created.
The NEWT token supports activity across the ecosystem, but like every blockchain project, its long-term relevance depends on adoption rather than hype. Tokens can generate excitement for a while, yet excitement fades. Actual usage is much harder to fake.
Competition won't be easy either. Nearly every crypto project now claims to have an AI strategy. After hearing the phrase hundreds of times, it's difficult to get excited simply because those two letters appear in a whitepaper. Newton Protocol will have to prove that developers actually want to build there and that AI agents genuinely perform better within its ecosystem.
Looking at the bigger picture, this project is really making a bet on where technology is heading. It assumes that AI won't just recommend financial decisions—it will eventually make many of them. If that happens, blockchain networks may need to evolve from systems designed for human users into systems designed for autonomous software acting on behalf of humans.
Will that future arrive exactly as imagined? Honestly, nobody knows. Technology has a habit of surprising both its biggest supporters and its harshest critics. But the question Newton Protocol is asking feels worth taking seriously.
If intelligent software is going to trade, manage assets, negotiate transactions, and interact with decentralized applications every hour of every day, building infrastructure specifically for that world doesn't sound unrealistic anymore. It sounds like something that might eventually become necessary.
@NewtonProtocol #Newt $NEWT

I've become pretty skeptical whenever a crypto project throws the words AI and blockchain into the same sentence. Most of the time, it feels like marketing dressed up as innovation. Newton Protocol, though, takes a different route. Instead of trying to convince everyone that artificial intelligence will magically transform finance overnight, it focuses on something much more realistic: making sure AI can actually be trusted before it's allowed anywhere near people's money.
That might not sound exciting at first, but it's probably the smartest place to begin.
Newton Protocol is developing a secure rollup built specifically for AI-powered applications. In simple terms, it's creating an environment where AI agents can perform tasks like executing trades, managing digital assets, or interacting with decentralized finance protocols without having unlimited control. The emphasis isn't on giving AI complete freedom. It's on keeping automation useful while making sure it stays within clearly defined limits.
That idea matters because AI has become incredibly capable in a very short time. It can scan markets every second of the day, compare prices across exchanges, analyze trends, and even generate trading strategies faster than any human ever could. But speed and intelligence don't automatically mean reliability. AI can misunderstand data, react to unexpected market conditions, or make decisions that simply don't make sense. When real money is involved, even one mistake can become an expensive lesson.
This is where Newton Protocol separates itself from many other projects. Rather than assuming AI will always make the right choice, it assumes that mistakes are inevitable. So instead of relying on blind trust, it builds safety mechanisms directly into the protocol.
Imagine hiring an assistant to manage your finances. You probably wouldn't hand them your entire bank account and disappear. You'd set spending limits, define what they're allowed to do, and expect them to follow certain rules. Newton Protocol applies that same logic to AI. Every automated action can be restricted through programmable permissions, ensuring that AI agents only operate within boundaries chosen by the user.
It's a practical approach, and honestly, it feels like common sense.
The protocol also uses its own rollup architecture because traditional blockchains weren't designed for constantly running AI systems. Autonomous software may need to process hundreds or even thousands of actions each day. Running all of that directly on a main blockchain could become slow and expensive. A dedicated rollup allows those operations to happen more efficiently while still benefiting from the security of the underlying network.
Another interesting piece of the ecosystem is its marketplace for AI developers. Instead of one company creating every tool, Newton Protocol allows developers to build and publish AI agents for different financial purposes. Some may focus on automated trading, while others specialize in portfolio management, yield optimization, risk monitoring, or treasury operations.
This creates an open environment where developers compete by building better products rather than making louder promises. If an AI agent consistently performs well and earns users' confidence, it naturally gains more adoption. In many ways, that's a healthier system than relying on centralized financial platforms where users have little visibility into how decisions are made.
Transparency is still a challenge, though. AI models often function like black boxes, producing answers without clearly explaining how they arrived at them. Newton Protocol doesn't pretend to solve that problem completely. Instead, it separates decision-making from execution. An AI model can suggest an action, but predefined security rules determine whether that action is actually carried out. That extra checkpoint adds another layer of protection without slowing down the entire system.
Of course, automated trading is one of the most obvious use cases. Cryptocurrency markets never close. Opportunities can appear in the middle of the night, disappear within seconds, and return again before most people even wake up. AI doesn't need coffee breaks or sleep, which makes it well suited for monitoring markets around the clock. Still, giving software unlimited authority would be risky, and that's exactly why Newton Protocol's security-first design feels so important.
The protocol also supports interactions across multiple decentralized finance platforms. Modern crypto users rarely keep all their assets in one place. They move between decentralized exchanges, lending protocols, staking platforms, liquidity pools, and cross-chain bridges. Managing all of these manually is becoming increasingly difficult. Newton Protocol aims to simplify that complexity by allowing AI agents to coordinate these activities while remaining within user-defined safety rules.
The NEWT token plays a central role in the ecosystem, supporting governance, incentives, and network participation. Like most blockchain projects, however, the long-term success of the token depends on whether the platform attracts real users and active developers. A useful ecosystem creates demand naturally. Marketing alone doesn't.
What I appreciate most about Newton Protocol is its mindset. It doesn't present AI as something that should replace human judgment entirely. Instead, it treats AI as a tool that should operate under supervision. That's a much more realistic vision than the idea of fully autonomous systems making unrestricted financial decisions.
The competition in AI-powered blockchain infrastructure is growing quickly, and Newton Protocol certainly isn't the only project working in this space. Even so, its focus on secure execution rather than flashy automation gives it a clear identity. It isn't trying to prove that AI is perfect. It's trying to make AI dependable enough to handle financial tasks responsibly.
Whether Newton Protocol becomes a major player will depend on adoption, developer activity, and how well its security model performs in real-world conditions. Those are things that only time can answer.
For now, Newton Protocol represents a thoughtful step toward a future where AI and blockchain work together without sacrificing trust. And honestly, that balance between innovation and caution may end up being its biggest strength.
@NewtonProtocol #Newt $NEWT

Letting Agents Off the Leash Is Marketed as Freedom. Read the Docs Again. That phrase captures the conversation surrounding autonomous AI agents better than most product announcements do. The project itself is built around a simple but provocative idea: giving software enough independence to complete real tasks instead of waiting for someone to approve every single step. It is an exciting direction, but once you move beyond the demonstrations and polished marketing, the project reveals a more thoughtful message. The closer you look at the documentation, the clearer it becomes that responsible autonomy has always been part of the design.
There is a noticeable gap between how autonomous agents are often presented and how they are actually expected to operate. Public demonstrations usually show an agent completing a series of actions without interruption. It opens applications, searches for information, edits files, writes code, and finishes complex workflows in what looks like a seamless process. Those examples are impressive, but they happen in controlled conditions. Real environments are far less predictable, which is why the project's technical guidance spends much more time discussing permissions, oversight, and safe execution than unlimited freedom.
That difference matters because autonomous agents do more than answer questions. They make decisions about what action to take next, select tools, and continue working until they believe a task has been completed. Every new capability also introduces new responsibilities. If an agent has access to calendars, cloud storage, email, databases, or production systems, even a small misunderstanding can affect far more than a single conversation.
The project's documentation reflects that reality. Instead of encouraging unrestricted access from the beginning, it repeatedly points toward careful permission management. An agent should receive only the access required for the task in front of it. If there is no reason to modify files, it should not have permission to edit them. If financial records are unrelated to the assignment, those records should remain inaccessible. These recommendations may sound cautious, but they are rooted in practical experience rather than unnecessary restriction.
Another point that deserves attention is visibility. People naturally trust software when it appears confident, yet confidence alone tells us very little about what actually happened behind the scenes. The project places significant value on transparency by encouraging clear records of the actions an agent performs. Being able to review which files were opened, which tools were used, and which decisions were made helps users understand both successful outcomes and unexpected mistakes.
This becomes especially important when agents interact with external information. Websites, uploaded documents, shared files, and emails can all contain inaccurate, outdated, or even intentionally misleading content. Without appropriate safeguards, an autonomous system may treat that information as reliable and continue acting on it. Rather than ignoring this possibility, the project acknowledges it directly and encourages developers to verify inputs, separate trusted data from untrusted sources, and maintain human oversight for sensitive operations.
The same philosophy appears when software development enters the picture. Many people imagine coding agents writing complete applications without supervision. In reality, experienced developers rarely view unrestricted execution as the ideal approach. Code can be generated quickly, but deploying changes to live systems requires much greater confidence. The project therefore encourages review processes, testing environments, and approval checkpoints before important changes become permanent.
One of the more refreshing aspects of the project is that it does not treat safeguards as obstacles. Instead, they are presented as practical tools that make autonomous systems more dependable. A confirmation request before deleting important files or updating production infrastructure may slow the workflow by a few seconds, but it can prevent hours of recovery later. That is not a limitation of the technology; it is part of using powerful tools responsibly.
There is also an important human element that often gets overlooked. Giving software greater independence does not remove accountability from the people deploying it. Someone still decides which systems an agent can access, what actions require approval, and how activity is monitored. Those decisions shape the reliability of the entire deployment far more than flashy demonstrations ever could.
As organizations continue experimenting with autonomous workflows, it becomes increasingly clear that success is not measured by how little human involvement exists. Instead, it depends on choosing the right balance between automation and oversight. Routine administrative work may benefit from high levels of autonomy, while financial transactions, legal documents, customer records, and infrastructure changes deserve additional review before they are finalized.
That balance is ultimately what makes the project stand out. Rather than encouraging users to hand over complete control, it encourages thoughtful deployment based on context and risk. The documentation consistently reminds readers that trust should be earned through predictable behavior, clear boundaries, and transparent decision-making rather than assumed from impressive demonstrations alone.
The project serves as a useful reminder that autonomy is not simply about allowing software to do more. It is about deciding where independence genuinely creates value and where careful supervision remains the better choice. Read closely, and the documentation tells a story that is quieter than the marketing but far more useful. The real strength of autonomous agents is not unlimited freedom. It is the ability to work effectively within well-designed limits that keep both users and their data protected.
@NewtonProtocol #Newt $NEWT