W Shakespeare

Перед развертыванием policy протокол Newton Protocol требует пройти три шага: unit test для Rego Policy, отдельное тестирование каждого WASM Oracle, а затем симуляцию всего policy с данными из реального мира.
Эти шаги не просто проверяют отдельные компоненты по очереди. Их последовательность устроена так, чтобы постепенно сужать круг неизвестного в отношении конкретного decision. После раундов валидации область того, что придется ждать до deployment, чтобы подтвердить, становится все меньше.
Как правило, deployment — это момент, когда становится ясно, работает ли decision так, как ожидалось. Несмотря на множество раундов тестирования, production остаётся тем местом, где многие команды учатся тому, чего они не могли знать заранее.
Но в Newton Protocol большая часть этого процесса происходит прямо в разработке. Rego Policy, WASM Oracle и данные объединяются, чтобы симулировать весь decision до того, как произойдет deployment. Это заставляет думать, что Newton Protocol стремится к архитектуре Pre-validated Deployment.
В таком случае deployment в основном превращается в шаг релиза уже валидированного decision, а не в место, где система продолжает учиться тому, верное это decision или нет.
Особенно заметно то, что Newton Protocol, похоже, меняет роль Deployment. Когда Deployment больше не является источником создания валидации, он перестает быть и тем местом, где система учится, является ли Decision правильным или ошибочным.
Возможно, именно в этом и заключается смысл архитектуры Pre-validated Deployment. Это не обязательно более полный процесс тестирования, а архитектурный принцип, который смещает валидацию из Production. Мне довольно интересно, будет ли это лишь выбором Newton Protocol или со временем станет подходом, который будет всё чаще использоваться при построении многих программных систем в будущем? $EVAA $NEWT #Newt @NewtonProtocol

На днях я смотрел раздел Writing Data Oracles в Newton Protocol и наткнулся на довольно интересную вещь: если HTTP Fetch завершается ошибкой, Data Oracle нельзя просто проигнорировать или вернуть данные по умолчанию. Вместо этого Oracle возвращает namespaced error, чтобы Rego Policy могла сразу запретить Decision.
Похоже, Newton Protocol меняет роль failure в процессе генерации Decision. Раньше ошибка была просто информацией для разработчика, которую тот читает после завершения работы системы. Теперь, как только Data Oracle возвращает namespaced error, состояние сбоя становится частью данных, которую Rego Policy должна оценить. Decision не останавливается из‑за того, что в системе произошла ошибка. Оно останавливается потому, что система только что получила новый сигнал.
И тут мне внезапно стало ясно: Newton Protocol выбирает Fail-Closed Architecture. Эта архитектура не пытается скрыть то, что еще неизвестно, чтобы продолжать выполнение. Вместо этого она расширяет само понятие Evidence. Ценность имеют не только данные, которые успешно удалось собрать. То, что Data Oracle не смог подтвердить информацию, тоже становится разновидностью Evidence, которую Rego Policy обязана оценить.
Когда failure рассматривается как Evidence, Decision больше не имеет права его игнорировать. Decision не может продолжать работу только потому, что остальные данные выглядят правдоподобно. Он должен отражать все Evidence, которыми располагает система, включая то, что невозможно подтвердить. Если Evidence недостаточно, чтобы обосновать вывод, Decision не имеет права сам «дорисовать» недостающее с помощью предположений.
Если смотреть с этой точки зрения, Fail-Closed Architecture в Newton Protocol уже не просто механизм обработки failure. Она заставляет каждое Decision быть честным по отношению к тому Evidence, которое у меня реально есть, а не к тому Evidence, которого система ожидала бы иметь. #Newt $LAB $TRIA $NEWT @NewtonProtocol

Протокол Newton был разработан Magic Labs — командой, стоящей за многими продуктами, соответствующими требованиям Enterprise Standards, таким как SOC 2 Type II и ISO 27001.
Эти Enterprise Standards требуют, чтобы организация имела достаточно строгий процесс разработки для управления изменениями, оценки рисков и гарантии того, что каждое решение можно проследить на протяжении всего жизненного цикла разработки.
Более того, этот процесс разработки должен служить не только одному релизу. Он должен быть достаточно согласованным, чтобы использоваться в течение многих релизов, независимо от того, как постоянно меняется продукт.
По моему мнению, когда команда Magic Labs годами работает в рамках одного и того же процесса разработки, этот процесс перестаёт быть просто внутренним workflow. Он становится способом по умолчанию для того, чтобы команда подходила к задачам и принимала решения. Именно поэтому я считаю, что при разработке протокола Newton Magic Labs привнёс не только Enterprise Standards, а именно Process-First Mindset (мышление, ставящее процесс во главу угла).
С таким подходом каждый релиз протокола Newton по-прежнему может быть сильно отличающимся, поскольку требуется решать новые задачи. Но все изменения исходят из одного и того же фреймворка решений, из одного и того же способа оценки рисков и из одного и того же инженерного процесса.
Эта согласованность заключается не в отдельных релизах, а в том, как именно Newton Protocol был спроектирован (Engineered). Когда @NewtonProtocol продолжит расширяться, новые функции не станут «пазлами», собранными из разных инженерных философий. Они по-прежнему будут строиться на той же ментальной основе, которая сформировала протокол с самого начала.
Наверное, самое ценное, что команда Magic Labs принесла с собой при разработке протокола Newton, — это Process-First Mindset. Он помогает протоколу Newton продолжать развиваться и расширяться, сохраняя при этом согласованность в том, как он был спроектирован.#Newt $LAB $NEWT

Прочитайте Integration Guide от Newton Protocol — есть одна деталь, которая показалась мне довольно странной: Data Oracle можно написать на JavaScript, Rust или Python. Сначала я подумал, что @NewtonProtocol просто пытается расширить выбор для builders.
Но примечательно тут не то, какой это язык программирования. А то, что независимо от языка в итоге всё компилируется в один и тот же WIT-интерфейс.
Тогда я понял: JavaScript, Rust или Python — лишь внешнее проявление. Самое быстрое изменение в каждом экосистеме ещё никогда не было связано с языком программирования — это была инновация. В Python постоянно появляются новые AI-пакеты. В Rust есть оптимизации по производительности и безопасности. JavaScript развивается очень быстро на уровне приложений и инструментов. У каждой экосистемы свой темп эволюции, и никто не знает, откуда придёт следующее прорывное решение.
Если протокол жёстко привязан к экосистеме конкретного языка программирования, он невольно ставит на то, что самые важные инновации будут продолжать появляться именно там. Всё, что приходит извне, либо придётся переносить, либо оно никогда не попадёт в систему.
Newton Protocol, похоже, выбрал позицию в стороне от этой гонки и принял стратегию Innovation Neutrality. Newton Protocol не стандартизирует, где именно создаются инновации. Единственное, что стандартизировано — это то, как инновации появляются перед протоколом через общий интерфейс.
Тогда эволюция Data Oracle не зависит от какого-то одного языка программирования или единственного сообщества разработчиков. Прорыв, появившийся в Python, Rust или JavaScript, может стать частью Newton Protocol. Это и есть преимущество позиции Innovation Neutrality. Newton Protocol не нужно ставить будущее на какую-либо одну экосистему языков программирования. #Newt $LAB $HMSTR $NEWT

Прочитав раздел Verifiable Credentials в документации Newton Protocol, я снова остановился на одной совсем маленькой детали.
Посреди множества SDK-методов, предназначенных для Identity, Verification и Credential Management, номер @NewtonProtocol по-прежнему выделяет целый метод под unlinkApp().
На первый взгляд, это просто API для отзыва связи между пользователем и приложением.
Но чем больше я об этом думаю, тем больше мне кажется, что само его наличие, вероятно, более примечательно, чем выполняемая им функция.
Система действительно нуждается в unlinkApp(), только если с самого начала команда приняла, что у пользователей всегда есть Exit Rights.
Если это предположение верно, то Newton Protocol, возможно, преследует стратегию в духе Voluntary Lock-in.
Звучит несколько противоречиво.
Обычно Lock-in создают, постепенно повышая Switching Costs, из-за чего пользователям все сложнее покинуть систему. Но при Voluntary Lock-in возможность уйти всегда остается.
Единственное, что удерживает пользователя, — это его собственное решение.
Это также означает, что Newton Protocol фактически почти отказывается от одного из самых распространенных Competitive Moats Web3-платформ.
Поскольку Exit всегда сохраняется, Newton Protocol не может полагаться на Switching Costs, чтобы удерживать Users.
По моему мнению, именно в этом и стоит поразмышлять.
Если Voluntary Lock-in действительно является вариантом в Product Design, то каждый Active User больше не просто показатель роста.
Они становятся доказательством того, что даже когда Exit всегда есть, люди все равно продолжают выбирать Stay.
Иными словами, unlinkApp() может быть не просто методом SDK.
Это может быть небольшой сигнал о том, что Newton Protocol не рассматривает Lock-in как результат барьеров, а как следствие повторяющихся со временем добровольных решений.
#Newt $MAGMA $LAB $NEWT

"Рынок действительно существует только тогда, когда обе стороны начинают находить друг друга."
Эта мысль внезапно пришла мне в голову, когда я узнал, что Newton Protocol строит Policy Marketplace.
Сначала я думал, что это просто место, где билдеры могут находить и интегрировать политики.
Но если смотреть внимательнее под углом Platform Economics, я вижу, что это больше похоже на Two-Sided Market, а не на обычный маркетплейс.
Одна сторона — Supply. Они упаковывают безопасность, соответствие требованиям (compliance) и юридическую экспертизу в Policy-as-Code, которые можно многократно использовать.
Другая сторона — Demand. Они не покупают политику просто потому, что она им нравится. Им нужны доверие и соответствие требованиям, без того чтобы каждый раз с нуля самим строить все для разработки Vault, RWA-протокола, Stablecoin или AI Agent.
В таком рынке ценность определяется не тем, сколько на нем Supply и сколько Demand.
Она определяется Matching Efficiency.
Если качественная политика не доходит до того билдерa, который в ней действительно нуждается, то эта экспертиза почти не создает экономической ценности. И наоборот: если билдер не находит подходящую политику, он возвращается к самостоятельной разработке, и тогда Demand так и не превращается в сделки.
Когда Matching Efficiency растет, меняется поведение обеих сторон. Supply получает стимул создавать больше Policy-as-Code, потому что выше вероятность использования и, как следствие, больше revenue. Demand тоже стремится приходить на маркетплейс раньше, чем начинать разрабатывать самостоятельно, поскольку стоимость поиска и интеграции становится все ниже.
Возможно, именно в этом и заключается то, что мне кажется особенно интересным в Policy Marketplace от Newton Protocol. @NewtonProtocol — это не просто связь между Supply и Demand. Это еще и попытка оптимизировать Matching Efficiency, чтобы сама способность соединять две стороны стала источником ликвидности и помогала всему Two-Sided Market работать более эффективно.
#Newt $LAB $NEWT

Сначала, когда я узнал, что Newton Protocol использует TypeScript для Newton Vault SDK,
мне пришлось воскликнуть: "А почему они не используют Python, а выбирают TypeScript?"
Потому что если цель — обслуживать AI Agents, Python почти наверняка является самым привычным выбором. В нём есть огромная экосистема для machine learning, количественных финансов.... С точки зрения возможностей это, пожалуй, самый понятный вариант.
Но, возможно, Newton Protocol совсем не соперничает по возможностям.
То, на что они нацелены, — это Technology Half-life.
AI-экосистема имеет крайне короткий жизненный цикл. Сегодня все говорят о новой модели, через пару месяцев появляется новый фреймворк, новый agent framework или новая библиотека. Python всегда находится в центре этих изменений.
А вот Execution Stack имеет Technology Half-life гораздо дольше. Кошельки, браузеры, подпись и смарт-контракты постоянно улучшаются, но их редко заменяют.
И именно там господствует TypeScript.
Это заставило меня иначе взглянуть на Newton Vault SDK.
Если бы Newton Protocol выбрал Python, им пришлось бы жить в ритме изменений AI-экосистемы. Каждый раз, когда рынок сдвигается, SDK будет испытывать давление, заставляющее адаптироваться.
Но когда Vault SDK размещается поверх TypeScript, Newton Protocol привязывается к инфраструктурному слою с гораздо более длинным Technology Half-life. AI может постоянно менять «мозг», но когда власть передаётся и транзакция подписывается, рабочий процесс всё равно возвращается к одному и тому же execution environment.
Пожалуй, самое примечательное в Newton Protocol — то, что они не пытаются стоять на самом быстро меняющемся технологическом слое. Вместо этого Vault SDK размещён на Execution Stack с более длинным Technology Half-life. Когда AI-экосистема постоянно меняется, @NewtonProtocol не нужно побеждать в каждом AI cycle. Им достаточно пережить эти AI cycle. #Newt $TAIKO $NEWT

Сначала я думал, что VaultKit от Newton Protocol — это SDK, чтобы билдеры могли быстрее создавать vault.
Но с помощью того же самого VaultKit Newton Protocol говорит об Institutional DeFi, AI Agents и даже о DeFi Whales. Эти три группы пользователей почти не имеют общего.
Потом я понял: то, что распространяет Newton Protocol, никогда не было «vault».
Это — Constraint Boxes.
Институту нужна Compliance Box. Деньги продолжают работать, но нельзя трогать sanctioned addresses, нельзя выходить за рамки approval workflow и нельзя выезжать за пределы инвестиционного мандата.
AI Agentу нужна Behavior Box. Он по-прежнему может совершать сделки, но каждое действие ограничено лимитами по расходам, протокольным whitelist и заранее заданными правилами.
А в случае DeFi Whale, который заводит средства в vault, достаточно Trust Box, где куратор не может тайно менять стратегию или переводить активы туда, где ранее не было договоренностей.
Интересно, что эти три Boxes совершенно разные, но решают одну и ту же задачу: ограничивать authority, не теряя автоматизацию.
И вот тогда я стал смотреть на VaultKit иначе.
Вместо того чтобы продавать универсальный слой безопасности всем, Newton Protocol упаковывает разные Constraint Boxes для разных типов капитала и для разных моделей делегирования. Каждой линии капитала может понадобиться своя стратегия, но в итоге все это должно работать внутри Box, спроектированной под тот уровень authority, который владелец готов передать.
Пожалуй, именно в этом и заключается самое заметное в Newton Protocol. Проект не пытается создать одну Box, подходящую всем. Вместо этого @NewtonProtocol đang строит инфраструктуру, где каждый тип капитала может самостоятельно определить свою Constraint Box до входа в onchain-экономику.
#Newt $SYN $NEWT

Сначала я думал, что VaultKit от Newton Protocol был создан для институциональных участников.
Политики, риск-контроль или governance — это язык фондов, а не retail.
Потом я задумался:
«Если так, то что тогда получает retail?»
Retail ведь не пишет policy.
И не управляет vault напрямую.
Но чем больше я смотрю на механику VaultKit, тем яснее, что я задаю неправильный вопрос.
Мое внимание не на policy.
А в том, что любое действие куратора или AI Agent должно проходить через policy, прежде чем быть выполненным.
То есть право решать больше не равно праву делать всё.
Это приводит к довольно интересному изменению.
Раньше, когда retail отправлял деньги в vault, по сути он полагался на judgment куратора.
Если управляющий принимал плохое решение, почти не было уровней, которые могли бы остановить его.
VaultKit меняет фокус доверия.
«Постойте…»
«Получается, мне больше не нужно верить в то, насколько куратора можно назвать гениальным?»
Мне нужно лишь доверять тому, что они не смогут выйти за границы, заранее определённые.
Эта механика постепенно переносит доверие от людей к ограничениям.
Так и управляют капиталом институции.
Никто не получает весь объём полномочий.
Власть всегда идёт вместе с constraint.
Newton просто переносит эту дисциплину на onchain.
Самое интересное, что retail не нужно превращаться в институцию, чтобы извлекать из этого выгоду.
Они всё так же отправляют деньги в vault.
Отличие лишь в том, что governance институции больше не живёт внутри внутренних процессов отдельных фондов.
Она становится частью самого VaultKit.
И именно это, как мне кажется, самое увлекательное в VaultKit.
Он приносит Institutional Discipline в retail.
Возможно, retail — это та группа пользователей, которую Newton Protocol выбирает, чтобы расширять доверие к onchain vault. $TAC $NEWT #Newt @NewtonProtocol

Когда я вижу, что OpenGradient Chat позволяет покупать Credit с помощью Credit/Debit Card, я подумал, что это всего лишь способ сделать оплату удобнее для тех, кто не использует криптовалюту.
Но чем больше я думаю, тем отчетливее понимаю: OpenGradient отказывается от преимущества, которым многие Web3-продукты до сих пор обладают.
Web3-неуязвимость.
Когда платишь криптовалютой, транзакция почти необратима.
После отправки средств большая часть ответственности тоже заканчивается вместе с транзакцией.
Credit/Debit Card работает по другой логике.
Участвуя в этой системе, OpenGradient должен следовать правилам традиционной платежной инфраструктуры, где ответственность мерчанта не заканчивается, когда оплата завершена.
И именно тогда я понял: успешная транзакция больше не означает, что сервис завершен.
Credit должен быть выдан.
Вывод (inference) должен работать.
Пользователь должен действительно получить именно тот сервис, за который заплатил.
Это Service-Level Commitment от OpenGradient.
Обязательство больше не ограничивается тем, чтобы обработать платеж.
Оно продолжается до тех пор, пока реальная ценность не будет доставлена пользователю.
И я думаю, что это Service-Level Commitment имеет довольно большое значение:
Когда @OpenGradient phải chịu trách nhiệm cho quá trình sau payment, то то, что они продают, уже не просто AI capability.
Они продают еще и доставку.
Насколько бы сильной ни была модель, это больше не имеет такого значения, если Credit выдается неправильно, inference работает нестабильно или пользовательский опыт OpenGradient Chat прерывается.
Тогда Delivery становится продуктом.
Кнопка оплаты Credit/Debit Card не просто добавляет еще один способ платежа.
Она также показывает, что OpenGradient сам устанавливает для себя стандарт, согласно которому ценность OpenGradient Chat определяется не только моделью, но и тем, насколько реально они могут доставить то, что обещали.
$TAC #OPG $OPG

На днях я ужинал с Тринь — подругой, которая работает в Web3.
Она рассказала, что команда только что выпустила токен, и первое, что сделали, — нашли место, куда его можно “встроить” в приложение: купить доступ, включить функцию, получить скидки.
Я спросил: «Пользователю нужно иметь там токен?»
Она сказала: «Не важно — главное, чтобы добавлялся demand к токену».
Эта фраза заставила меня вспомнить OpenGradient Chat.
Если присмотреться внимательнее, есть место, которое легко могло стать demand для токена, но его используют иначе.
Это — Credit.
Пользователь покупает Credit за USDC, а затем использует Credit в OpenGradient Chat. Платёжный сценарий довольно прямолинейный: стейблкоин превращается в Credit, а Credit — в usage.
Если бы хотели создать новый demand для токена OPG, проект вполне мог бы разрешить покупку Credit за токен OPG. Тогда токен был бы связан с тем местом, где пользователь реально соприкасается с продуктом.
Но OpenGradient не выбрал этот путь.
И если посмотреть со стороны пользователя, это решение гораздо логичнее.
Долгосрочному пользователю OpenGradient Chat нужны фиксированные затраты на вход. Ему нужно понимать, сколько он отдаёт и сколько Credit получает, а затем использовать это в рабочих сценариях — без необходимости считать цену токена.
Если бы токен OPG находился на шаге покупки Credit, у пользователя появилось бы ещё больше мыслей и решений: когда покупать, токен сейчас дорогой или дешёвый...
То есть проект может создать дополнительный demand для токена, но цена этого — в ухудшении user experience.
Это — User-First Token Discipline.
OpenGradient не перекладывает на пользователя волатильность, риск тайминга и ментальное трение ради расширения demand на токен.
Они хотят строить долгосрочно: хотят, чтобы стоимость для OpenGradient Chat была достаточно простой для измерения, и чтобы пользователи возвращались к использованию как к рабочей привычке.
Самое интересное: когда $OPG нужно будет добавить demand, будет ли OpenGradient по-прежнему приоритезировать user experience и сохранять User-First Token Discipline? Ответа на этот вопрос у меня пока нет.
$VELVET #OPG @OpenGradient
chat.opengradient.ai