Agent Native Universe · Открытая исследовательская программа

Обязано ли программное обеспечение выглядеть так, как оно выглядит последние пятьдесят лет?

Файлы, репозитории, API, экраны и документация существуют, чтобы сложная система была понятна человеку. Agent Native Universe исследует, что происходит с программным обеспечением, когда внутри системы появляется второй интеллект — автономный агент, — и проверяет каждую идею исполняемым экспериментом, а не манифестом.

Правило программы и этой страницы: вопрос → гипотеза → эксперимент → свидетельство → следующий вопрос.

Открытый репозиторий (MIT) К экспериментам

Люди определяют цель.

Агенты создают интеллект.

Интеллект создаёт программы.

Программы существуют, пока они полезны.

И вторая формула программы: люди создают агентов, которые создают агентов для людей.

Разметка честности

ANU — исследовательский проект, поэтому радикальные идеи здесь не смешиваются с готовыми. Каждое сильное утверждение на странице несёт один из четырёх статусов:

реализовано Реализовано

Работает в открытом коде, покрыто тестами, воспроизводится из чистого клона.

прототип Прототип

Работает в эксперименте; есть первые записанные данные, но не серия.

исследование Исследование

Идёт измерение: есть числа, есть оговорки, вывод ограничен ими.

гипотеза Гипотеза

Сформулировано как проверяемый вопрос. Кода нет — и мы это говорим прямо.

Исходная проблема: программное обеспечение антропоцентрично

Современные модели обучались в основном на знаниях, созданных людьми для людей. Программирование выросло так же: языки, файлы, папки, классы, микросервисы, файлы README и панели управления — во многом это способы сделать сложную систему обозримой для человеческой памяти и внимания.

Но агенты уже пишут код, анализируют системы, пользуются API, проверяют результаты и делегируют задачи. Возникает вопрос, с которого начинается ANU: почему они должны продолжать работать внутри конструкций, придуманных людьми для людей?

Классический конвейер и агентная альтернатива выглядят так:

Человек → интерфейс → приложение → API → база данных

Намерение человека → агентная среда → динамические агенты,
инструменты, функции, интерфейсы → результат → знание сохранено

Приложение перестаёт быть обязательно заранее написанной фиксированной системой.

Главная гипотеза

Что произойдёт, если перестать проектировать программное обеспечение прежде всего для человека и начать строить вычислительную среду, в которой основные субъекты — автономные интеллектуальные агенты?

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

Что уже исполняется кодом реализовано

Фундамент программы — открытая среда выполнения на чистом Node.js без единой сторонней зависимости, где законы мира исполняются кодом, а не просьбой в инструкции для модели.

Мир с законами, а не просьбами

Агент — ограниченный локальный мир со своей целью, состоянием, памятью и бюджетом; связи — переговорные протоколы с памятью состояния. Инварианты исполняются кодом: отрицательный баланс невозможен не потому, что модель попросили, а потому, что операция не пройдёт.

Экономика мышления

Ресурсы с двойной записью, встречное депонирование обеих сторон, неделимый расчёт. Обращения к модели тарифицируются внутри экономики: резерв — жёсткий потолок, перерасход отклоняется с точным счётом, доставленная работа оплачивается, недоставленная возвращается.

Криптографическая ткань

Идентичность Ed25519, каналы X25519 + AES-256-GCM, защита от подделки и повторной отправки сообщений. Византийский кворум f = ⌊(n−1)/3⌋: лидер не может сфабриковать чужие голоса, сертификат фиксации применяется только после действительного кворума.

Свидетельство, а не лог

Каждый эксперимент — журнал только на дописывание, с цепочкой хешей, детерминированным воспроизведением и sha256-аттестацией. Проверяющий механизм не доверяет отчёту: он заново порождает поток решений из манифеста и отказывает при первом расхождении.

64 × 10 000 тиков · 131 372 события · 0 нарушений инвариантов · sha256-аттестация подтверждена независимой проверкой

Референс-эксперимент открытого релиза; воспроизводится из репозитория командой из README.

Экспериментальная программа

Четыре эксперимента, у каждого — вопрос, гипотеза, постановка и свидетельство. Числа взяты из записанных журналов; оговорки напечатаны рядом с числами.

EXP-01исследование

Возникает ли архитектура сама — и лучше ли она спроектированной?

Вопрос: Если дать агентам законы, ресурсы и цели, но не давать ролей и организационной структуры — какая структура возникнет и выдержит ли она сравнение с архитектурами, придуманными человеком?
Гипотеза: Самоорганизация без предзаданных ролей не уступает спроектированным архитектурам, а под изменением режима — превосходит их.
Эксперимент: Genesis-1: вселенная из 16 агентов без предзаданных ролей и контрольные группы — тот же мир под центральным диспетчером (E), с закреплёнными ролями «решатели/проверяющие» (F), без графа связей (D), без экономики (C). Одна закреплённая реализация задач для всех групп, серия из пяти зёрен случайности. 600 тиков с кризисной программой: цена кредитов ×2 → пропускная способность ÷2 → принудительный уход 20% агентов → поток задач ×4.
Свидетельство: группа успех p95 окно ×4 A самоорганизация 97.4% 11 98.1% C без экономики 97.9% 11 99.6% D без графа связей 98.1% 10 99.3% E центральный диспетчер 97.6% 14 100% F фиксированные роли 74.1% 24 68.9% ← крах
Закреплённые роли не деградируют — рушатся, и на всех пяти зёрнах. Арифметика ёмкости предсказывает величину краха количественно: где уход агентов забрал трёх решателей, осталось 9 × ⅓ = 3.0 задачи/тик против спроса 4.0 — предсказано 175 просрочек, наблюдается 216–217; где зацепил проверяющего — 10 решателей, предсказано 117, наблюдается 108–109. Величина краха — детерминированная функция выживших решателей, а не удача зерна. При этом класс проверяющих за 600 тиков не поймал ни одного дефекта — но держал ёмкость, которой не хватило.
Центральный диспетчер — лучший чистый кризисный исполнитель: 100% в окне ×4 на каждом из пяти зёрен. Платит за это постоянным 2–3-кратным налогом на хвостовую задержку во всех спокойных режимах и держится с запасом 8% без механизма подстраховки. Самоорганизация — единственная архитектура без структурной цены: p95 4–6, недостижимый для спроектированных групп, и 97.6–99.9% сквозь пик.
Вопрос графа закрыт на этом масштабе: A обыгрывает D на двух зёрнах, D обыгрывает A на трёх, средние совпадают до десятой (97.2 против 97.2). «Живой граф» пока не имеет опоры в данных — работу делает свобода выбора задач.
Оговорки: Пять зёрен закрыли оговорку «один прогон»; различия меньше ~1.5 п.п. между самоорганизующимися вариантами — шум зерна. Остаётся одна конфигурация: 16 агентов, один поток задач, одна программа давлений. Журнал: experiments/genesis-1/BASELINES.md в репозитории.
Следующий вопрос: Другие конфигурации (размер популяции, программа кризисов); давление на группу E до её арифметической границы; агенты, создающие агентов.

EXP-02прототип

Модель в контуре мира с законами

Вопрос: Что делает настоящая рассуждающая модель, попав в среду, где правила исполняются кодом, — и можно ли при этом сохранить воспроизводимость эксперимента?
Гипотеза: Ответы модели можно записывать как вход воспроизведения: свидетельство остаётся детерминированным даже с недетерминированным интеллектом внутри.
Эксперимент: Когорты мышления: консультации модели записываются в журнал дословно до того, как мир на них отреагирует; воспроизведение никогда не обращается к поставщику; идентичность прогона включает модель, конечную точку и бюджет консультаций — прогон с другой моделью не может выдать себя за чужое свидетельство по построению.
Свидетельство: Первый поведенческий факт: рассуждающая модель (Kimi K2) в первом же прогоне проигнорировала протокол заявления задач — исполняла и сдавала задачи, не заявив их за собой (claimTask): 11 нарушений на 6 консультаций. Каждое нарушение — записанное свидетельство, а не упавший процесс.
Оговорки: Один короткий прогон одной модели: это первые данные, не вывод.
Следующий вопрос: Длинные прогоны когорт; сравнение «машинный протокол против естественного языка» по токенам, задержке, стоимости и потерям информации.

EXP-03реализовано

Сколько стоит мысль

Вопрос: Можно ли доверить агенту бюджет, если поставщик модели не обещает соблюдать ограничения?
Гипотеза: Гарантии расхода должны жить в коде среды, а не в параметрах запроса к поставщику.
Эксперимент: Живой фальсификационный прогон против Kimi K2 на MWS Cloud — experiments/mws-kimi в репозитории, девять проверяемых гипотез, никаких заглушек.
Свидетельство: Поставщик полностью игнорирует запрошенный max_tokens — проверено на значениях 16, 32, 64 и 256.
Около 86% оплаченных токенов ответа — скрытые токены рассуждения, которых вызывающий никогда не видит. Счёт приходит за мышление, а не только за слова.
Вывод перенесён в код: резерв стал жёстким потолком — перерасход отклоняется с точным счётом недоплаченного, реально доставленная работа оплачивается, недоставленная возвращается.
Следующий вопрос: Экономика как регулятор глубины рассуждения: когда следующий шаг мысли не стоит своей цены.

EXP-04реализовано

Свидетельство вместо документации

Вопрос: Может ли система описывать себя сама — так, чтобы описание не могло устареть?
Гипотеза: Источник правды — не текст о системе, а проверяемый журнал того, что система сделала.
Эксперимент: Каждый прогон — журнал событий только на дописывание, с цепочкой хешей. Проверяющий механизм не читает отчёт — он заново порождает поток решений из манифеста и отказывает при первом расхождении. Манифест несёт полную идентичность реализации: движок, политику, генератор задач, модель.
Свидетельство: Практический эпизод из разработки: разбор кода нашёл, что прогон с другой моделью мог молча переиспользовать чужое завершённое свидетельство. Закрыто привязкой идентичности модели в идентификатор прогона — теперь такое столкновение невозможно по построению, а старые свидетельства отвергаются, а не перетолковываются.
Следующий вопрос: Самоописывающаяся возможность: машинное описание, автоматически проверяемое против работающей системы.

Открытые гипотезы гипотеза

Самые радикальные идеи программы. Кода за ними пока нет — здесь описано, каким экспериментом каждая будет проверяться и что будет измерено.

Эфемерные функции: код как кеш

Функция существует, потому что существует задача. Понадобилась — порождена, проверена, исполнена, уничтожена; понадобилась тысячу раз — сохранена. Код перестаёт быть источником истины и становится кешем уже найденного решения.

Как проверим: Серия из 100 задач: измерить долю переиспользования, стоимость порождения против хранения, долю функций, переживших свою задачу.

Машинное общение вместо имитации разговора

Сегодня агенты пишут друг другу «Please analyze…» — машины имитируют человеческую беседу. Машинный слой общения обменивается состояниями, дельтами, ограничениями и идентификаторами возможностей.

Как проверим: Одна задача двумя способами — естественный язык против структурного протокола: токены, задержка, стоимость, корректность, потери информации.

Агенты, создающие агентов

Структура вычисления возникает из задачи: порождающий агент понимает намерение и создаёт нужный состав специалистов; полезное продвигается в постоянную возможность, остальное исчезает. Сейчас популяцию лаборатории создаёт файл настроек — порождение агентов агентами не реализовано.

Как проверим: Структура связей, возникающая в реальном времени из намерения; сравнение с заранее заданным процессом по стоимости и качеству.

Динамический интерфейс

Интерфейс как следствие задачи, а не выбор до её появления. Два человека, решающие разные задачи в одной системе, фактически работают с двумя разными приложениями — интерфейс порождается и исчезает вместе с задачей.

Как проверим: Две несвязанные задачи одного пользователя: породить интерфейс под каждую, измерить путь до результата против неизменной панели.

Документация как исполняемое знание

Возможность отвечает машинным интерфейсом: кто ты, что умеешь, чего стоишь, от чего зависишь, как проверить твою работу. Описание порождается из живой реальности системы, и его расхождение с ней — обнаруживаемая ошибка, а не судьба любого README.

Как проверим: Изменить возможность и измерить: традиционный README устаревает молча, самоописание расходится с реальностью обнаружимо.

Приложение как временное общество агентов

Задача порождает общество специалистов; после решения общество распускается. Система сохраняет знание, а не все созданные программы: агенты 7 → 0, функции 12 → 2 в кеше, результат и знание — остаются.

Как проверим: Показать исчезновение программ после решения — счётчики созданного и уничтоженного в реальном времени.

Что обязано остаться постоянным

Радикальность идей не отменяет инженерию. Не всё в агентной среде может быть эфемерным — и граница проходит не по вкусу, а по последствиям ошибки.

┌──────────────────────────────────────┐
│  ДИНАМИЧЕСКИЙ СЛОЙ                   │
│  агенты · инструменты · функции      │
│  процессы · интерфейсы · временные   │
│  приложения                          │
├──────────────────────────────────────┤
│  ПОСТОЯННОЕ ЯДРО                     │
│  идентичность · права · криптография │
│  данные · память · инварианты        │
│  экономика · аудит · верификация     │
└──────────────────────────────────────┘

Идентичность, права, криптографическое доверие, данные, память, инварианты, аудит, верификация и экономика — постоянное ядро. Агенты, инструменты, функции, процессы и интерфейсы — динамический край.

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

Вопросы, на которые ищем ответ

Нужен ли агенту исходный код, организованный в репозитории?
Должны ли агенты общаться на естественном языке?
Может ли программа создаваться только в момент, когда она понадобилась?
Может ли интерфейс возникать из намерения пользователя?
Может ли документация стать живым машинным представлением реальности?
Могут ли агенты сами создавать агентов, которые им нужны?
Каково минимальное постоянное ядро среды, родной для агентов?
Может ли архитектура возникать, а не проектироваться?
Может ли знание заменить код в роли источника истины?
Что происходит, когда приложения становятся временными?

Чем это отличается от мультиагентного каркаса

Мультиагентный каркас            Agent Native Universe

Человек проектирует процесс      Намерение человека
        ↓                                ↓
     Агент A                     среда определяет нужный интеллект
        ↓                                ↓
     Агент B                     агенты создаются и находятся
        ↓                                ↓
     Агент C                     связи и программы возникают сами
                                         ↓
                                 задача решена, знание сохранено

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

Место в исследовательской картине XTeam

Сегодня ANU — самостоятельный открытый репозиторий без единой сторонней зависимости. Связи ниже — исследовательская модель объединения наших направлений, а не существующие сцепки; мы не описываем то, чего нет.

KnowledgeBase AI — потенциальный слой постоянного знания — то, что переживает эфемерные реализации
XTeam Agents — потенциальный слой исполнения и координации агентов
MagicBrain — смежный, но другой вопрос: не «мир для агентов», а постоянный мыслительный симбиоз человека и машинного интеллекта
Balansis — специализированная вычислительная возможность агентной среды — кандидат

Итоговый тезис

Agent Native Universe исследует мир, в котором программное обеспечение перестаёт быть заранее созданным статическим продуктом. Интеллект сам формирует необходимых агентов, инструменты, функции, процессы и интерфейсы под возникающую задачу, а после её решения сохраняет знание — но не обязан сохранять саму реализацию.

Возможно, сегодняшнее программное обеспечение — переходная форма между программами, которые пишут люди, и системами, которые создают себя сами для решения человеческих задач. Это вопрос, а не утверждение — и выше показано, как мы его проверяем.

Репозиторий открыт под MIT: можно скачать, перегнать эксперименты и проверить каждый хеш.

Репозиторий на GitHub Обсудить программу