cryptovn1

Некоторые банки решают проблему того, что модели машинного обучения не поддаются объяснению, используя два параллельных подхода — один сложный, с высокой точностью, чтобы действительно выявлять мошенничество, а другой более простой, менее точный, но понятный для объяснения. Параллельный запуск нужен лишь для того, чтобы создать объяснение. Когда сложная модель отказывает в транзакции, система спрашивает у простой модели, согласна ли она — и если да, использует эту причину, чтобы объяснить клиенту.
Суть в том, что не нужно жертвовать точностью ради возможности объяснять: роли разделяются — принятие решения и объяснение.
Если @NewtonProtocol применит этот подход к Policy Engine, то он сможет одновременно максимально повышать выявление мошенничества и давать пользователю понятное объяснение.
Самооспаривание: но этот подход работает эффективно только тогда, когда две модели в большинстве случаев согласны. Более сложный случай — когда они расходятся: сложная модель отказывает, а простая говорит, что «всё нормально». Тогда системе приходится либо выбирать причину, которая не отражает истинное решение, либо признать, что объяснить нельзя — иронично, но как раз разногласия чаще всего возникают в самых сложных ситуациях.
Реальная сложность Ньютона не в том, чтобы строить параллельную объясняющую модель, а в том, как прозрачно обрабатывать случаи разногласия — возможно, стоит публиковать долю решений, попадающих в категорию «объяснение недостаточно полное».
$NEWT следует оценивать не только по тому, построен ли механизм параллельных объяснений в теории, а по тому, честно ли проект публично раскрывает долю таких случаев.
#newt $TAC $BTC

Некоторые крупные инвестиционные фонды решают проблему «слишком много алгоритмов реагируют одинаково» очень просто: самостоятельно ограничивают размер собственных позиций в любых активах — не потому, что боятся их риска, а потому, что боятся самого действия по выходу из позиции: если оно будет достаточно большим, оно само создаст волатильность, запускающую цепную реакцию со стороны других участников.
Это другой подход к теме системного риска, которую мы обсуждали в предыдущих материалах: не нужно сложного механизма координации с согласием множества сторон, как circuit breaker. Достаточно, чтобы каждый AI Agent на Newton самостоятельно ограничивал масштаб действий пропорционально реальной ликвидности рынка в тот момент.
Если @NewtonProtocol заложит принцип относительного ограничения размера позиций по ликвидности в policy каждого AI Agent, а не будет ограничивать его только фиксированным числом, это может оказаться гораздо более простой «защитой», чем построение централизованного механизма координации.
Самокритика: но относительное ограничение работает только тогда, когда policy корректно оценивает реальную ликвидность на момент сделки, а ликвидность меняется крайне быстро — особенно в период сильнейшей волатильности, то есть ровно тогда, когда этот механизм нужен больше всего, и когда входные данные тоже наименее надежны.
Сложность Newton заключается не только в том, чтобы встроить этот принцип в policy, а в том, чтобы найти источник данных о ликвидности, достаточно надежный даже в самой хаотичной рыночной ситуации — задача, аналогичная вопросу об автономном источнике данных, упомянутому ранее в контексте RWA.
$NEWT
поэтому его следует оценивать по надежности этого источника ликвидности, а не только по тому, применяется ли в теории принцип относительного ограничения.

#newt $LAB $BTC

Я почти не заметил, чтобы кто-то читал инвестиционный меморандум. Поставь галочку «я понял риски», нажми дальше — и готово. Крипто критикует традиционные финансы за многословные документы, но при этом ожидает, что пользователь сам прочитает токеномику, сам проведёт аудит контракта. Меняют меморандум на whitepaper — поведение то же самое.
Именно здесь вопрос @NewtonProtocol попадает в точку: если слой policy стоит перед execution, определяя заранее, какие транзакции разрешены, понимает ли пользователь действительно риски, которые он принимает, или просто переносит веру с «не читаю меморандум» на «тоже не читаю policy, просто оно работает быстрее и выглядит более заслуживающим доверия, потому что помечено как on-chain».
Пользователь никогда не хотел сам оценивать риски — он хотел, чтобы кто-то сделал это за него. Smart contract описывает, как именно выполняется транзакция. Policy описывает, считается ли такая транзакция безопасной.
Само-возражение: если policy станет главным «судьёй» по рискам, власть переедет от автора кода к тому, кто определяет «приемлемые риски». Но если это решает лишь маленькая группа, и никто не может это оспорить, то воспроизводится провал меморандумов — пользователь всё равно соглашается, не понимая ничего; просто на этот раз порог уже зашит в код.
@NewtonProtocol нужно доказать, что тот порог рисков можно оспорить — кто его определяет и есть ли у пользователя канал для возражений.
$NEWT в тот момент служит топливом для того, чтобы кто-то получил право определять «приемлемые риски» для всей сети, а не только оплачивать один слой автоматической верификации.
Я всё ещё жду механизма, который позволит пользователям реально оспаривать тот порог рисков, а не просто красиво работающий «слой решений», с которым никто не может спорить.
#newt $LAB $BTC

Как-то раз я услышал историю о том, что один знакомый унаследовал земельный участок от своего дедушки — земля всё ещё на месте, красная книга (правоустанавливающий документ) всё ещё на имя деда, но чтобы оформить переоформление, нужно пройти все этапы подтверждения наследства, заново провести межевание границ, уплатить налог перед регистрацией — это заняло почти два года. Само имущество не исчезает, просто никто не имеет права пользоваться им в течение всего этого времени. Самое страшное не то, что можно потерять, а то, что имущество есть, но к нему нельзя прикоснуться.
То же и с ценными бумагами: токенизация акций занимает всего несколько минут, но токенизация всего набора правовых правил, которые идут вместе с этим, — самое сложное: кто может покупать, какие ограничения по владению действуют и каковы условия передачи. Поэтому @NewtonProtocol сначала публикует policy перед execution — это особенно важно: право на совершение сделок проверяется сразу на старте, а не обрабатывается постфактум, как в длительной процедуре переоформления прав на землю, которая тянется годами.
Самооспорение: но переоформление прав на землю задерживается частично потому, что есть множество независимых сторон, которые подтверждают всё — налоговый орган, нотариальная контора, регистрационная служба по недвижимости — и никто один не решает всё целиком. Если Newton Protocol объединит все уровни подтверждений ценных бумаг в единый policy engine, скорость значительно возрастёт, но вместе с этим решение о том, «действительно это или нет», также сосредоточится в одной точке — быстрее, но и уязвимее для контроля, если достаточно получить возможность управлять одной инстанцией, а не обходить несколько независимых органов, как раньше.
Если $NEWT хочет стать фундаментом для on-chain рынка ценных бумаг, он должен доказать, что тот самый свод правил прозрачен и действительно подлежит взаимным проверкам, а не просто работает быстрее, чем традиционные бумажные процедуры.
#newt $LAB $BTC

В нашей деревне на площади есть старинные каменные весы: их поставили посреди двора (перед беседкой), и если кто-то продаёт или покупает — и у людей возникают сомнения, они приходят туда и перепроверяют вес, чтобы точно. Прелесть этих каменных весов не в том, что они дают идеальную абсолютную точность, а в том, что у них всего одна стрелка — никто не может её подстроить. Взвешиваешь — и для всех при одинаковом весе получаешь один и тот же результат.
Я вижу, что при распродажах в DeFi не хватает именно таких весов. При одинаковом падении цены залогового актива у одних кошельков распродажа происходит сразу, а у других — срок продлевают благодаря связям с командой, которая обслуживает протокол, или же благодаря использованию протокола с особыми механизмами, которые особенно благоприятствуют крупным пользователям. В теории эти весы должны быть одинаковыми для всех, но на практике они «гибкие» в зависимости от того, кто стоит перед ними.
@NewtonProtocol превращает политику ликвидации в логику, которая автоматически запускается до исполнения, как если бы во всей системе заново установили те самые правильные каменные весы на площади — все измеряются по одному стандарту, без исключений ни из-за знакомств, ни из-за того, что у кого-то больше капитала.
Самооспаривание: но каменные весы справедливы, потому что это физический предмет — после отливки никто не может что-то подправить. А on-chain политика ликвидации может корректироваться постоянно — и каждый раз, когда меняют порог, даже под лозунгом оптимизации риска, это снова означает, что «весы» перенастраивают. Проблема не в справедливости при первоначальной настройке, а в том, остаётся ли она справедливой при каждом последующем изменении, как в первый раз, или постепенно перекошена в пользу той стороны, у которой есть право менять параметры.
$NEWT поэтому нужны не просто «весы» правильные на старте, а механизм, который гарантирует, что эти весы не будут тайно перенастраиваться со временем, чтобы «справедливость» была не только обещанием в первой версии.
#newt $NEWT

В первые дни на новой работе я открыл зарубежный банковский счет, чтобы получать фриланс-зарплату. Деньги в приложении показывались как «получены», но вывести их я смог только через три дня — требовалась «проверка источника средств». Нарушений никаких не было: обычная зарплата, но ждать пришлось так, будто меня подозревают. Тогда я понял: поступление денег на счет и возможность ими пользоваться — это разные вещи, между ними есть временной разрыв, который никто толком не объясняет.

Поэтому реальный вопрос о межстрановых платежах — не «как быстро идут деньги», а «кто решает, куда и как далеко деньгам разрешено идти, и сколько времени нужно, чтобы это разрешили». Блокчейн уже давно разобрался с частью скорости. А вот следующий этап, который продолжает висеть, — слой верификации: слой, который говорит «да» или «нет» до того, как деньги дойдут до получателя.

@NewtonProtocol делает ставку именно на этот слой — не на оптимизацию маршрута потока средств, а на оптимизацию права этого потока двигаться: policy ставится впереди execution, чтобы транзакция сразу понимала, соответствует ли она правилам, а не ждала мутной процедуры где-то «позади».

Сам себе возражаю: но эти три дня ожидания в банке, пусть и медленно, имеют одну ценность — есть реальные люди, которые отвечают, если верификация ошибочна; есть горячая линия, можно спросить, почему средства удержали. Автоматический policy layer, быстрый до мгновения, также означает, что решение «разрешено» или «запрещено» выносится без пауз, где мог бы вмешаться человек. «Быстрее» не автоматом означает «справедливее».

Сложность @NewtonProtocol — не просто сделать authorization быстрым, а не дать этой скорости «съесть» шанс повторно обратиться, если допустимую транзакцию по ошибке всё же заблокировали.

Эту часть я и дальше яснее видел на $NEWT — прежде чем поверил в то, что слой policy работает «быстро ради справедливости», а не «быстро потому что никто не успеет возразить».
#newt $NEWT

В Библии есть история о Вавилонской башне — люди строят общую башню, чтобы достичь неба, но Бог заставляет их говорить на разных языках, из-за чего строительство рушится, потому что никто не понимает друг друга. Урок не в том, что люди слишком амбициозны, а в том, что общая система стоит твердо только тогда, когда все люди одинаково понимают один общий закон.

Трансграничные финансы как раз сталкиваются с этой проблемой. У каждой страны — свои правила контроля капитала, у каждого банка — свои процедуры комплаенса. Блокчейн решает задачу скорости, но скорость — не самое сложное.

Именно тогда вопрос @NewtonProtocol становится особенно заметным: если уровень policy стоит перед execution, то деньги не только знают, как переводиться из A в B, но и сами “понимают”, разрешено ли это — на основе закона страны, где они выпущены. Это похоже на монету со своим паспортом: она заранее проверяет условия на каждом “пограничном пункте”, через который проходит.

Само-возражение: но Вавилонская башня рухнула не из-за нехватки технологий, а из-за отсутствия общего языка, с которым все согласны. Если каждая страна хочет писать policy по своим законам, работающим на одной инфраструктуре, Newton Protocol должен согласовать десятки конфликтующих законов — и контроль капитала одной юрисдикции может противоречить свободному обращению капитала другой.
Поэтому самая сложная часть — не техническая вставка policy перед execution, а механизм, позволяющий различным сторонам с разными интересами согласиться с тем, как выносится решение при столкновении законов — и кто имеет последнее слово.

$NEWT поэтому это не просто операционные издержки. Если этот уровень policy действительно станет местом, куда государства “вкладывают” денежные правила, то его ценность будет в том, кто контролирует общий язык — и будет ли у маленькой страны голос наравне с большой.

#newt $NEWT

У меня есть одно наблюдение о том, как люди на самом деле взаимодействуют с правилами в цифровых продуктах: никто не читает. Открыл приложение, пролистал вниз, нажал «I agree» — готово. Web3 критикует Web2 за горы Terms & Conditions, но при этом ожидает, что пользователь прочитает смарт‑контракт в тысячу строк. Превратить PDF в Solidity — поведение остаётся тем же.

И вот где вопрос касается @NewtonProtocol : будущее в том, что люди читают policy вместо смарт‑контрактов? Фишка не в том, что «policy легче читать, чем код». Дело в том, что пользователю никогда не хотелось читать механизм — ему нужно знать свои права. Смарт‑контракт описывает, как работает машина; policy описывает, что человеку позволено делать. Ньютон попытался перевернуть интерфейс доверия: заставить машину говорить человеческим языком, а не заставлять человека учить язык машины.

Самоопровержение: если policy становится главным слоем интерфейса, то власть смещается от разработчика к тому, кто формулирует правила. Но если эта policy тоже становится многословной или централизованной в руках небольшой группы, она повторяет ровно то же провальное место Terms & Conditions — пользователь по‑прежнему кликает «agree» и не понимает ничего. Разница только в том, что на этот раз непрозрачность — это уже проявление действий самого государства. Если закон нельзя оспорить, значит это уже не закон — это под видом закона замаскированная власть, замаскированная под удобство.

@NewtonProtocol нужно доказать, что слой policy — не только читаемый, но и оспариваемый: кто пишет правила, кто имеет право возражать — а не просто гладкий UX на демо.

Тогда $NEWT — это уже не обычный gas token, а топливо для новой гонки: не тот, кто лучше пишет код, а тот, кто яснее и лучше формулирует «что разрешено» и даёт возможность это оспорить.

Я жду увидеть механизм, при котором пользователь действительно читает policy и может ей возражать — не просто «гладкий слой», но невидимый.

#newt $NEWT

У меня есть одно наблюдение о том, как на самом деле масштабируются финансовые системы.

Не за счёт более быстрой обработки. А за счёт того, что решают, ЧТО НЕ ДОЛЖНО случиться — прежде чем это случится.

Ошибочную транзакцию можно rollbackнуть. Транзакция не должна существовать и при этом всё же settlement произойти — отмывание денег, обход санкций — если нет кнопки undo. Поэтому все серьёзные финансовые системы имеют защитный слой перед, а не слой уборки после.

Вот где @NewtonProtocol ставит вопрос иначе. Вместо того чтобы рассматривать compliance как ручную проверку, следующую за транзакцией, он превращает compliance в слой политики, который работает на вычислениях, стоит между намерением и исполнением. Вопрос, который раньше звучал как «Это уже валидно?» переводится в «Ему разрешено существовать?» — и отвечает машина до того, как деньги будут переведены. Trust меряется не числом подписавших, а тем, что политика прошла проверку. $NEWT платит за каждую оценку политики — почти как тарифицируемая стоимость права действовать в условиях.

Самооппонирование: сильный compliance layer — это ровно то, что задано набором правил, загруженных в него. Если policy написана одной стороной непрозрачно, или никто не может её оспорить, когда она ошибается, то вы не устраняете произвол — вы лишь кодируете его и делаете спорить с ним сложнее. Алгоритм-гейткипер может быть опаснее человека-гейткипера, потому что он невидим и по умолчанию считается объективным.

@NewtonProtocol нужно доказать, что тот policy layer одновременно и аудируемый, и оспариваемый — кто пишет законы, кто имеет право возражать — а не просто быстрый движок.

Автоматизировать «разрешено» легко. Сохранить возможность спорить с самим «разрешено» — вот в чём сложность.

Я жду увидеть реальное governance вокруг policy layer — не только бенчмарки скорости.
#newt $NEWT

У меня есть наблюдение о том, как ИИ действительно заслуживает доверия в use case, где настоящие деньги лежат на столе.

Не потому, что модель сильнее. Не потому, что ответы звучат более гладко. А из-за очень конкретной вещи: когда этот output можно проверить — независимо — ещё до того, как его используют.

Один-единственный output от ИИ может быть шумом. Он звучит уверенно — и возможно, это просто беглая галлюцинация. Он оказывается верным пару раз — это ещё ничего не говорит о надёжности. Проблема не в том, что ИИ ошибается, а в том, что у вас нет способа отделить доверительный output от того, который просто «кажется убедительным».

Вот где @OpenGradient появляется вторая позиция. Вместо того чтобы держать execution и verification в одном месте — то есть чтобы машина сама себя хвалила — она разделяет два слоя. Узел inference выдаёт результат; другая сторона берёт proof того прогона и повторно проверяет, какую модель она использовала, какие данные, совпадает ли всё, а затем только делает commit в on-chain. $OPG закрывает всю эту итерацию. Output больше не является заявлением, это то, что прошло независименную проверку.

Сам себе возражение: такая архитектура действительно заслуживает доверия только тогда, когда сам слой verify заслуживает доверия. Если слой верификации слабый — или хуже того, это второй black box — то он не убирает проблему, а лишь переносит её в другое место. Фраза «кто проверяет проверяющего» не исчезает, она просто делает шаг дальше.

@OpenGradient нужно доказать целостность самого слоя verify прежде всего — и только потом всё остальное можно строить на этом фундаменте.

Инфраструктура должна быть устойчивой, а narrative — потом.

Я жду увидеть данные о надёжности этого слоя verify — не только в виде feature на бумаге.

#opg $OPG

Я попробовал сделать небольшую вещь на прошлой неделе: каждый раз, когда ИИ отвечает, я задаю себе вопрос: «если это окажется неверным, что я потеряю?»

Если спросить десятки раз, получается довольно ясная классификационная таблица. В большинстве случаев ответы, даже если они ошибочные, не страшны — подсказки по блюдам, переформулировка письма, краткое резюме статьи. Но есть и другая маленькая группа, совершенно иная: переводы денег по его словам, подписание договора, опираясь на его анализ, чтобы он сам принял решение по торговому ордеру. Если тут ошибиться, это уже не исправишь фразой «ладно, пропусти».

Проблема в том, что один и тот же ИИ отвечает обеим группам, одинаково уверенным тоном. Он не снижает темп и тон там, где риск высокий. Ответственность должен нести человек — понимать, где можно верить без оглядки, а где нужно остановиться и перепроверять. Но людям лень, а гладкий голос ИИ усыпляет доверие.

@OpenGradient , для меня примечателен тем, что он правильно выстроил именно ту маленькую группу с высоким риском. Там, где неверный ответ означает реальные потери денег, он не заставляет вас верить «на слово». Он отделяет того, кто производит результат, от того, кто проверяет: одна сторона выдает вывод, а другая затем снова изучает доказательства по прогонам, прежде чем этот вывод «устоит» на цепочке. $OPG и запускает этот механизм пристального просмотра. Вам не нужно верить голосу — у вас есть чем сверить.

Он не делает ИИ менее ошибочным. Он лишь гарантирует следующее: там, где ошибаться дорого, у вас есть путь понять, кто ошибся и где именно. А в мелочах — не надо, и никто зря этим не занимается.

Мне кажется, именно так и следует использовать verify: не проверять всё подряд, а проверять именно то, что действительно заслуживает проверки. $OPG делает ставку на немногие решения, где цена одной ошибочно доверенной уверенности слишком велика, чтобы отдавать её на произвол.
#opg $OPG