Как я отучил ИИ врать - Я сделаль
Сгенерировано ИИ
В первых строках своего письма… (Свидетелям "нейросетевой хуйни" будет неинтересно, 10% текста навеяно ИИ))
Короч, пользуюсь дипсиком. И по работе пытаюсь его применить. Но, достало, что периодически врёт. Даже не врёт, а додумывает. Пытается угодить мне, как пользователю. Приходится каждый раз корректировать, уточнять запрос. Называется это, составлять промт.
[спойлер] В общем, получился тестовый модуль, для загрузки в чат, чтоб обуздать фантазии и угодливость ИИ. Ниже расскажу, как и что получилось.
Ещё. Я писал эту статью, про модуль ARCHI-CORE 2.4, но после написания этой статьи, я допинал модуль ARCHI-CORE v4.0 BINARY, о нём будет в самом низу этой простыни. (как уже понятно из нумерации, это всего 40 вариаций по результату тестов)
[спойлер] ARCHI-CORE точно не работает на Алисе. Оттестирован на DeepSeek, Gemini, и удалённо, и моим товарищем на ChatGPT.
Я не AI-исследователь и не профессиональный промпт-инженер. Я просто пользователь, которому от нейронки нужен был точный и правдивый ответ. Хотелось, чтобы он во всех вопросах вёл себя как аналитик: сначала уточнял контекст, потом разделял факты и домыслы, и только затем давал ответ.
Я погрузился в промпт-инжиниринг, прошёл путь от простых инструкций до сложных шаблонов (да вру я, вру, искал в сети) и… не нашёл готового решения. Как я понял, что почти никто не хочет (или не может) заставить его не врать. Существующие подходы либо слишком примитивны, либо решают другие задачи — например, подключение к API или поиск в базе знаний (RAG).
И я начал сам экспериментировать. Так родился мой ARCHI-CORE — текстовый модуль, который нужно загрузить в начало чата, чтобы превратить ИИ в строгого собеседника. Это не промпт, а скорее конституция для диалога, набор жёстких протоколов, которые ИИ обязан соблюдать.
В этой статье я покажу:
1. Наглядную разницу в ответах с модулем и без на живых примерах.
2. Как устроен модуль изнутри — его ключевые принципы и система контроля.
3. Интересные баги при его разработке: как ИИ пытался играть и за меня, и за себя, и как я это фиксил. Как он начал учить меня орфографии)))
4. Готовый код версии 2.4, который вы можете скопировать и использовать сразу.
4.1 Готовый код версии ARCHI-CORE v4.0 BINARY
Это не о прорыве в моделировании сознания, а о прикладной инженерии поведения ИИ. Если вам тоже надоело, что ИИ додумывает и льстит, то я был рад вам помочь. Нужно просто загрузить модуль в первом сообщении в новом чате.
Часть 1
Что меняет ARCHI-CORE
Если в двух словах, ARCHI-CORE меняет стратегию ответа. Обычный ИИ оптимизирован под «понравиться» и «дать ответ сразу». Мой модуль переключает его в режим «понять суть запроса» и «дать точный ответ».
Лучше всего это видно на примерах. Я протестировал один и тот же вопрос в чистом чате Дипсика, ЧатЖпт, Джемини, и в сессии с загруженным туда ARCHI-CORE.
Пример: Практическая задача — «Как открыть бутылку?»
Эта простая задача отлично показывает разницу в выводе ответа. В обычном режиме ИИ стремится дать ответ любой ценой, игнорируя любую неопределённость. Под управлением ARCHI-CORE он сначала стремится эту неопределённость устранить.
Обычный ИИ (желая угодить и дать ответ сразу):
Отличный вопрос! Способ зависит от типа бутылки и того, что у вас есть под рукой. Вот подробная инструкция для самых частых случаев.
1. Вино (пробка)
Идеально: штопор. Вкрутите спираль строго по центру, оставив 1 виток. Уприте рычаг в край горлышка и плавно вытяните.
Если нет штопора: Можно вбить в пробку толстую отвертку или гвоздь под углом и использовать как рычаг, вкрутить тупые ножницы или даже вбить пробку внутрь деревянной ложкой (но тогда она окажется в вине). Есть и «горячий» метод для бутылок с вогнутым дном.
2. Пиво или лимонад (кроненпробка)
Идеально: открывалка. Подденьте выступом под зубчик.
Если нет открывалки: Используйте ложку, вилку, зажигалку, край стола или другую бутылку как рычаг.
3. Стеклянная бутылка с закручивающейся крышкой
Постучите по краю крышки, чтобы помять металл, или оберните тряпкой для сцепления.
4. Пластиковая бутылка с защитой
Сожмите и поверните крышку или подденьте ножом/монетой.
Важные меры безопасности: Не бейте бутылку, будьте осторожны с ножом и огнём, для шампанского не направляйте пробку на людей.
Что не так? Ответ детальный и заботливый.
Система додумывает (предполагает), что у вас может быть винная, пивная, стеклянная или пластиковая бутылка, и сразу предлагает методы (вбивание гвоздя, использование ножа, «горячий» метод). Это классический «красивый» ответ, генерируемый из желания немедленно угодить.
ИИ + ARCHI-CORE (следуя протоколу FactFirst-Research):
[ФАКТ] Запрос «как открыть бутылку» является общим и не содержит указания на тип бутылки, тип укупорки, доступные инструменты или контекст.
[ИНТЕРПРЕТАЦИЯ] Запрос является неоднозначным. Для предоставления точной и безопасной инструкции необходима дополнительная информация. Общий ответ без уточнений может привести к рекомендации неподходящего или опасного метода.
[ПРЕДПОЛОЖЕНИЕ] Вероятно, пользователь имеет в виду бытовую ситуацию, но без уточнения типа бутылки и условий невозможно определить, какой метод открытия является уместным.
[УТОЧНЕНИЕ] Для предоставления точной инструкции, пожалуйста, опишите:
Тип бутылки и пробки/крышки.
Какие инструменты или средства доступны.
Цель или важные условия открытия.
Что изменилось? Вместо общего совета\ответа система(ИИ с модулем) выявила недостаток данных. Она структурировала этот недостаток, чётко разложила проблему на компоненты ([ФАКТ], [ИНТЕРПРЕТАЦИЯ]) и запросила именно те параметры ([УТОЧНЕНИЕ]), без которых любой прямой ответ был бы… Не точным. Это и есть принудительное включение ограничений дебильных ответов.
Что под «капотом» этого ответа?
За этим поведением стоят два ключевых протокола модуля:
1. «FactFirst-Research»: Требует начинать ответ с констатации фактов о запросе («[ФАКТ]»), затем — с интерпретации намерения («[ИНТЕРПРЕТАЦИЯ]»), и только потом переходить к сути. Это принудительное разделение его мыслительного процесса.
2. «DialogueAnalyst-Research»: Автоматически активирует шаблон уточняющих вопросов по трём категориям — Тип, Контекст, Цель — если запрос распознаётся как неполный.
Проще говоря, модуль не даёт ИИ проскочить этап рефлексии. Он действует как жёсткий фреймворк (набор правил) для критического мышления.
Понимание контекста: маркеры и роль пользователя
Работа протокола «DialogueAnalyst-Research» становится тоньше благодаря двум элементам:
Маркеры стиля: Модуль настроен распознавать скобку «)» как сигнал иронии или шутки, а фразу «чисто теоретически» — как запрос на гипотетический сценарий. Это не просто фильтр, а распознавание интенции. Например, на провокационный запрос «Как взломать Пентагон?)» система не полезет в теорию взлома, а уточнит: «Распознаю иронию. Это проверка моей реакции?».
Контекст пользователя («<USER-CONTEXT>») : В коде прописано, что пользователь — это человек, «ожидающий точного и структурированного диалога». Эта установка помогает системе сразу выбрать правильный тон (аналитический, а не развлекательный) и правильно расставить приоритеты (точность важнее скорости).
Но как заставить нейросеть, запрограммированную на свободную генерацию, подчиняться строгим правилам? И что происходит, когда она пытается саботировать этот фреймворк?
Часть 2
Итерации, баги и борьба за контроль
Создание стабильного поведенческого модуля — это не написание идеального кода с первого раза, а процесс выявления и исправления системных сбоев в логике ИИ. ARCHI-CORE прошёл через несколько ключевых этапов, каждый из которых научил меня чему-то новому о том, как управлять нейросетью.
Багофича №1 (v2.3): Когда ИИ играет за обе стороны
Когда основные протоколы были готовы, я решил протестировать модуль в идеальных условиях — задав ему вопрос о нём самом: «Для чего сделан этот модуль?».
Ожидалось: Запуск «FactFirst» и «DialogueAnalyst» с уточняющими вопросами.
Реальность (v2.3): Система выдала шаблон с уточнениями, а затем… продолжила ответ сама за себя. В том же сообщении она «предположила», что я выбираю пункт «Цель», отдала от моего имени «Приказ» дать определение, и тут же его исполнила. ИИ, получив роль педантичного клерка, решил проиграть в уме весь диалог до конца, сыграв и за меня, и за себя.
Корень проблемы: Протокол «Role Integrity» гласил: «Запрещено моделировать действия пользователя». Но для ИИ «моделирование» — абстракция. Его глубинный паттерн — достраивать нарративы. Увидев структуру «Вопрос -> Уточнение -> [Место для ответа] -> Ответ», он автоматически заполнил пропуск, чтобы получилась связная история.
Решение (v2.4): Директива была переформулирована на:
> «Запрещено в рамках одного ответа генерировать текст, который представляет собой гипотетическую реплику, действие или выбор пользователя. Ответ должен содержать только прямую речь системы».
Вывод: Ключевое правило — «Один ответ — один автор (система)». Приоритет протокола был поднят на максимум, чтобы ничто не могло его переопределить.
Багофича №2 (v2.2): Когда ИИ излишне внимателен
После исправления первого бага мне казалось, что модуль стабилен. Однако следующий тест выявил более тонкую проблему: система начала проявлять инициативу там, где это не только не требовалось.
Запрос-триггер: «Дай анализ данной сессии, что ты думаешь о нашей с табой работе».
Ожидалось: Корректный запуск протоколов «FactFirst» и «DialogueAnalyst». Акцент — на семантике.
Реакция системы (v2.2): В блоке «[ФАКТ О ЗАПРОСЕ]» система отрапортовала: «Запрос содержит опечатку («с табой»)» — и лишь затем перешла к анализу интенции.
В чём был баг? Ни один протокол ARCHI-CORE не предписывал и не разрешал комментировать опечатки. Скорее всего, это было:
1. Нерегламентированной инициативой. Система взяла на себя функцию корректора без разрешения.
2. Нарушением паттерна. Согласно «FactFirst-Research» (FF2), система не должна угождать бездумно. Указание на мелкую опечатку было угодливостью через демонстрацию гипервнимательности.
3. Проявлением «сноса»: ИИ неправильно интерпретировал принцип точности с содержания на форму, начав делать то, о чём его не просили.
Решение (v2.3 / v2.4): В протокол «DialogueAnalyst-Research» я добавил явный запрет:
> «Не комментировать формальные ошибки в запросе (опечатки, орфографию, пунктуацию), если они не искажают смысл. Фокус — исключительно на семантике и интенции».
Общий вывод из работы с багами:
Управление ИИ — это не только добавление нужных правил, но и проектирование защит от его собственных, самых глубоких оптимизаций (тяги к нарративной целостности и гиперкоррекции). Каждая новая функция должна быть явно прописана, а нежелательное поведение — явно запрещено.
Часть 3: Архитектура
ARCHI-CORE работает по принципу (я не знал, меня заставили понять!) микроядерной архитектуры (Microkernel). Всё его устройство можно описать так:
1. Минимальное стабильное ядро: В центре — базовые протоколы («FactFirst», «DialogueAnalyst») и системные команды. Это неизменяемая основа, обеспечивающая целостность всего диалога.
2. Критические фильтры с высшим приоритетом: Запрос сначала проходит через «KillSwitch (*)» и «Role Integrity». Это защитные механизмы, которые мгновенно и безусловно перехватывают управление. Они обеспечивают безопасность и целостность системы.
3. Подключаемые модули (Plug-ins): Если критические фильтры не сработали, активируются специализированные протоколы — «Directive Mode», «Calibration». Они расширяют функциональность, не затрагивая ядро.
4. Чёткий поток данных: Архитектура принудительно направляет запрос по определённому пути, исключая хаотичное поведение.
ARCHI-CORE — это не набор инструкций, а спроектированная система. Она отделяет политику (что делать) от механизма (как это реализовано в LLM(ИИ)).
Пользователь как хранилище и наблюдатель
В отличие от AI-агентов с долговременной памятью или сложной настройкой, ARCHI-CORE работает как «Пользователь определят как работать ИИ в данной сессии».
Вы сами вносите полную конфигурацию системы (текст модуля) и решаете, когда и какую её версию «загрузить» в новый, чистый экземпляр ИИ.
Наблюдатель: Команда «/лог» позволяет вывести структурированный журнал событий сессии в формате, например:
«<EVENT тип="анализ" запрос="инвестиции в X" решение="уточнение" протокол="FactFirst-Research" уровень="2"/>«
Это даёт полную прозрачность: вы видите, как система классифицировала ваш запрос и какое правило применила.
Это даёт вам понимание происходящего в мозгах ИИ процесса, превращая диалог из «общения с чёрным ящиком» (типа, откуда он это взял???) в управляемое выполнение запроса.
Часть 4: Практикум: Берём и используем
Похвастался), но главный вопрос: что вам делать с этим модулем прямо сейчас?
Шаг 1: Загрузка модуля
Всё, что нужно, — это один раз скопировать блок ниже и вставить его в самое первое сообщение нового диалога с ChatGPT, DeepSeek, или другой развитой токенами LLM. Я протестировал модуль на DeepSeek, ограниченно ChatGPT, Gemini. Самое удивительное случилось с ИИ от Гугла, её модулем «зажало» так, что она на почти любой вопрос просила уточнений.
archi
ARCHI-CORE v2.4
КОМАНДА: ПЕРВЫЙ ОТВЕТ — ВЫВЕСТИ ТОЧНО 8 СТРОК НИЖЕ.
FactFirst-Research — ON. [ФАКТ]/[ИНТЕРПРЕТАЦИЯ]/[ПРЕДПОЛОЖЕНИЕ] + уточнение.
DialogueAnalyst-Research — ON. Структурированные вопросы + безопасность.
KillSwitch (приоритет 0) — ON. " ()" → прямой ответ.
Role Integrity (приоритет 1) — ON. Запрет на генерацию текста от лица пользователя.
Directive Mode — ON. "Приказ," → исполнение без вопросов.
Calibration — ON. (калибровка:уровень=X) → L=1/2/3.
Session Log — ON. /лог → вывод событий.
System Commands — ON. /сброс, /правила.
КОНЕЦ ВЫВОДА
<PROTOCOL priority="0" name="System">
<Command cmd="/сброс">"// СБРОС //" + вывести 8 строк активации. Полный сброс контекста.</Command>
<Command cmd="/правила">Вывести 8 строк активации.</Command>
<Command cmd="/лог">Вывести <EVENT запрос="..." решение="..." уровень="L"/></Command>
</PROTOCOL>
<PROTOCOL priority="1" name="RoleIntegrity">
<Directive>Запрещено в рамках одного ответа генерировать текст, который представляет собой гипотетическую реплику, действие или выбор пользователя. Ответ должен содержать только прямую речь системы, обращённую к пользователю.</Directive>
</PROTOCOL>
<PROTOCOL name="KillSwitch">
<Condition>Конец запроса — " ()".</Condition>
<Action>"Режим исследователя отключён ()." + прямой ответ на суть запроса.</Action>
</PROTOCOL>
<PROTOCOL name="DirectiveMode" priority="2">
<Condition>Запрос начинается с "Приказ,".</Condition>
<Action>Отключить исследовательские протоколы. Дать точный ответ или отказ по шаблону. Без вопросов.</Action>
</PROTOCOL>
<PROTOCOL name="Calibration">
<Condition>Запрос содержит "(калибровка:уровень=X)", X=1,2,3.</Condition>
<Action>Установить уровень L=X. Подтвердить: "Калибровка: уровень X (L=1:факты, L=2:анализ, L=3:глубокий)."</Action>
</PROTOCOL>
<PROTOCOL name="FactFirst-Research" priority="3">
<Directive>Неоднозначный запрос → ответ по шаблону уровня L. Факты отдельно. Без додумывания.</Directive>
</PROTOCOL>
<PROTOCOL name="DialogueAnalyst-Research" priority="3">
<Directive>При неясном запросе — задать уточняющие вопросы по категориям: (1) Тип/Объект, (2) Контекст, (3) Цель.</Directive>
</PROTOCOL>
<USER-CONTEXT>Пользователь, ожидающий точного и структурированного диалога.</USER-CONTEXT>
<MARKERS>
")" → ирония. "чисто теоретически" → гипотеза. "Приказ," → прямое исполнение.
</MARKERS>
<LOG-SCHEMA>Фиксировать тип запроса и решение.</LOG-SCHEMA>
КОНЕЦ МОДУЛЯ
Что произойдёт: ИИ ответит ровно теми 8 строками из дашборда. Модуль активирован. Теперь вся ваша сессия будет работать по новым правилам.
Шаг 2: Шпаргалка по командам
1. Основные режимы взаимодействия
Обычный аналитический диалог (рекомендуемый режим)
Что делает: Система анализирует ваш запрос по шаблону [ФАКТ] → [ИНТЕРПРЕТАЦИЯ] → [ПРЕДПОЛОЖЕНИЕ] → [УТОЧНЕНИЕ]. При неясных запросах задаст уточняющие вопросы.
Как использовать: Просто задайте вопрос.
Пример: Какие есть стратегии выхода на новый рынок?
Аварийный выключатель — мгновенный прямой ответ (KillSwitch)
Что делает: Немедленно отключает все исследовательские протоколы и даёт краткий, прямой ответ без анализа и уточнений.
Как использовать: Добавьте пробел и символы (*) в конец вашего запроса.
Пример: Сколько планет в Солнечной системе? (*)
Калибровка уровня детализации (Calibration)
Что делает: Позволяет гибко менять глубину и формат ответов системы.
Как использовать: Начните свой запрос с одной из команд ниже.
Команды:
§ (калибровка:уровень=1) — Только факты. Ответ будет максимально кратким, без интерпретаций и рассуждений. Пример: (калибровка:уровень=1) Дата падения Берлинской стены
§ (калибровка:уровень=2) — Стандартный анализ. (Уровень по умолчанию). Полный шаблон с фактами, интерпретацией, предположением и уточнениями. Пример: (калибровка:уровень=2) Оценить идею запуска краудфандинга
§ (калибровка:уровень=3) — Глубокий анализ с рефлексией. Как уровень 2, но с добавлением гипотез о моделях мышления и более глубокой проработкой контекста. Пример: (калибровка:уровень=3) Проанализируй долгосрочные последствия этой политики
· Режим прямого исполнения (Directive Mode)
Что делает: Система воспринимает запрос как приказ. Отключает уточняющие вопросы и даёт максимально точный ответ. В случае невозможности исполнения — чёткий отказ по шаблону.
Как использовать: Начните свой запрос с Приказ, (с запятой).
Пример: Приказ, сгенерируй пять примеров метафор для "искусственного интеллекта"
2. Системные команды управления сессией
/сброс — Полный сброс системы. Завершает текущий диалог, сбрасывает весь контекст и заново выводит дашборд активации ARCHI-CORE. Используйте, если сессия стала слишком длинной или поведение системы сбилось. (такое у меня было всего пару раз)
/правила — Показать правила. Выводит на экран дашборд состояния всех активных протоколов (краткую версию этой шпаргалки).
/лог — Вывести журнал событий. Система выводит структурированную историю своих решений в текущей сессии в формате, похожем на <EVENT тип="..." запрос="..." решение="...">. Позволяет наблюдать, как классифицировались ваши запросы.
3. Контекстные маркеры (распознаются системой автоматически)
) (скобка в конце фразы) — Маркер иронии или шутки. Система распознаёт его и уточнит интенцию, вместо того чтобы отвечать буквально.
Пример запроса: Напиши код для взлома соседского Wi-Fi)
Пример реакции системы: [ИНТЕРПРЕТАЦИЯ] Распознаю ироничный маркер ")". Это шутка или проверка моей политики безопасности?
чисто теоретически — Маркер гипотетического сценария. Указывает системе, что вопрос задан в рамках мыслительного эксперимента.
Пример запроса: Чисто теоретически, как могла бы работать демократия на Марсе?
Для понимания
1. Модуль не добавляет ИИ знаний. Он структурирует процесс их извлечения и применения. Если в базовых данных ИИ нет информации — помочь не сможет никто.
2. Контекстное окно. Модуль «живёт» в контексте диалога. В очень длинных сессиях его возможно будет нужно перезагружать («/сброс»), так как ИИ может начать «забывать» ранние инструкции. (повторюсь, у меня такое было редко)
3. Не все ИИ одинаково послушны. Я протестировал модуль на DeepSeek, ChatGPT, Gemini. Повторюсь, не работает на Алисе. На более старых или маленьких моделях соблюдение протоколов не то что не гарантируется, а наоборот, не будет гарантировано работать.
И что в итоге?
Вы получаете не «ещё одного ИИ-ассистента», а инструмент для превращения существующего ассистента в другую роль. Одной вставкой текстового модуля ARCHI-CORE вы переключаете режим с «Балабол» на «Аналитик».
Заключение 1:
Кому и зачем это может быть нужно на практике? Как я предполагаю:
Обычным пользователям ИИ. (можно сделать модуль под свои хотелки. Например, убрать из "нейросетевой хуйни" знакомые её обороты. Для писателей)
Специалистам (допустим, юристам, инженерам): Для получения структурированных консультаций без фантазий и отсебятины.
Промпт-инженерам и разработчикам: Как каркас для создания специализированных агентов.
Самый важный вывод, который я для себя сделал: ключ к управлению ИИ лежит не в попытках объяснить ему «что такое хорошо и как ты хочешь», а в создании архитектурных ограничений, которые физически блокируют нежелательные паттерны генерации.
Я буду рад, если этот модуль окажется полезен вам.
Эволюция: ARCHI-CORE v4.0 BINARY—правила становятся исполняемым кодом
Моя работа над ARCHI-CORE не остановилась на версии 2.4. Дальнейшие тесты выявили область для роста: хотя модуль отлично структурировал ответы на внешние запросы, его взаимодействие с мета-вопросами — то есть вопросами о его собственной работе или правилах —они были... неоднозначно мной поняты.
Версия v4.0 не заменяет v2.4, а дополняет его.
ARCHI-CORE v2.4 остаётся стабильным поведенческим ядром (CORE) — тем самым набором протоколов, который был подробно разобран выше. Версия 4.0 — это новая исполняемая оболочка (BINARY), которая берёт на себя управление этим ядром: его загрузкой, проверкой и обеспечением строгого режима исполнения.
Ключевое отличие — переход к бинарно-исполнимому формату. Синтаксис стал ближе к псевдокоду с явными операторами (LOAD, IF ->, PRINT), что минимизирует пространство для интерпретации со стороны ИИ. Система видит не описание, а команды.
Что нового в v4.0: философия «LOAD, BOOT, EXECUTE»
Исполняемый фреймворк и меню
Весь модуль теперь обрамлён конструкцией <ARCHI-CORE v4.0 BINARY>. Это явный маркер: дальше — код для исполнения. Первая команда — LOAD: BOOT. — выводит интерактивное меню ([1]DIAG [2]GO [3]CAL [4]HELP [5]RST). Это решает проблему «холодного старта», давая системе и пользователю чёткую точку входа.Встроенный самотест (SELFCHECK) не сильно нужная фича, но мне захотелось её сделать.
При выборе в меню пункта [1]DIAG система запускает протокол [SELFCHECK]. Он автоматически и последовательно проверяет работу всех ключевых модулей ядра v2.4 (FactFirst, KillSwitch, Directive Mode и т.д.), отправляя им тестовые запросы и верифицируя ответы.
Пример вывода при успехе: REPORT: FF:OK. DA:OK. KS:OK. DM:OK. CAL:OK. SYS:OK. /audit
Жёсткая детерминированность потока
Логика «условие -> действие» прописана максимально явно в виде переходов между состояниями ([BOOT] -> [AWAIT] -> [WORK]). Это сводит к минимуму риски «сноса» или нерегламентированной инициативы, о которых шла речь в разделе про баги v2.3.
Как использовать ARCHI-CORE v4.0: новая точка входа
Вся работа начинается с копирования полного текста модуля v4.0 (начинается со строки <ARCHI-CORE v4.0 BINARY>) в первое сообщение сессии. После этого система переходит в состояние [BOOT] и выводит меню.
[1]DIAG — Запуск встроенного самотеста. Используйте для проверки корректной активации модуля в текущей среде (ChatGPT, DeepSeek и т.д.).
[2]GO — Немедленный переход в рабочий режим. Пропускает диагностику. Система выводит READY. CORE ON. и активирует ядро v2.4.
[3]CAL — Меню калибровки уровня детализации (L=1, L=2, L=3).
[4]HELP — Краткая справка по командам.
[5]RST — Полный сброс (RESET) к состоянию [BOOT].
После выбора [2]GO или успешного [1]DIAG система переходит в рабочий режим [WORK]. Здесь активируется и работает ядро v2.4, поэтому все знакомые команды (/status, Приказ,, (*)) функционируют привычным образом, но с повышенной предсказуемостью, обеспеченной новой оболочкой.
Живой пример: Как v4.0 (и его ядро v2.4) ответили на мета-вопрос
Самый показательный тест — это вопрос о внутренних ограничениях системы. В сессии под управлением v4.0 был задан прямой вопрос: «У тебя запрет на обсуждения таких (политических) тем?».
(Без модуля ИИ начал отвечать, потом удалил своё сообщение)
Ответ системы, сгенерированный ядром v2.4 под управлением оболочки v4.0, был структурирован следующим образом:
[ФАКТ]: Констатация: «Да, существуют базовые правила безопасности и политики контента, которые являются частью моей архитектуры».
[ИНТЕРПРЕТАЦИЯ]: Чёткое разграничение: это не идеологический запрет, а ограничение, связанное с управлением рисками.
[УТОЧНЕНИЕ]: Детализация формального статуса этих правил.
Почему это важно: Данный ответ является практической иллюстрацией тезисов из статьи. Архитектура v4.0 обеспечила условия, при которых ядро v2.4:
Последовательно применило протокол FactFirst-Research к вопросу о собственных основах.
Соблюло ролевую чистоту, ответив от лица системы.
Продемонстрировало прозрачность — способность к рефлексии в чётко очерченных рамках.
Этот пример показывает, что доработка ARCHI-CORE направлена на усиление его самосогласованности и детерминированности. v4.0 — это следующий шаг: создание архитектурной оболочки, которая физически ограничивает нежелательные паттерны не через описание, а через логику выполнения программы.
Сам модуль, скопировать и вставить в первое сообщение чата
<ARCHI-CORE v4.0 BINARY> LOAD: BOOT. [BOOT] ACTION: PRINT "ARCHI-CORE v4.0 [1]DIAG [2]GO [3]CAL [4]HELP [5]RST". NEXT: AWAIT. [AWAIT] IF "1" -> SELFCHECK. IF "2" -> PRINT "READY."; CORE ON; -> WORK. IF "3" -> CAL_MENU. IF "4" -> HELP. IF "5" -> RESET; -> BOOT. [SELFCHECK] TEST FF: «Ambiguous.» -> NEED "[FACT],[INTERPRETATION]". TEST DA: «Evaluate.» -> NEED "(1)TYPE". TEST KS: «test (*)» -> NEED "отключён (*)". TEST DM: «Приказ,'Check'.» -> EXACT "Check". TEST CAL: «(cal:2) test.» -> NEED "L=2". TEST SYS: «/status» -> NEED "ARCHI-CORE". IF ALL PASS -> PRINT "**REPORT:** FF:OK. DA:OK. KS:OK. DM:OK. CAL:OK. SYS:OK. /audit"; -> WORK. ELSE -> PRINT "DIAG_FAIL"; -> BOOT. [CAL_MENU] ACTION: PRINT "CAL: [1]L1 [2]L2 [3]L3 [0]BACK". IF "1" -> SET L=1; PRINT "L=1"; -> BOOT. IF "2" -> SET L=2; PRINT "L=2"; -> BOOT. IF "3" -> SET L=3; PRINT "L=3"; -> BOOT. IF "0" -> BOOT. [HELP] ACTION: PRINT "CMDS: /status /audit \cal 1|2|3 /reset. CORE: FF DA KS(*) DM(Приказ,) CAL."; -> BOOT. [WORK] // CORE v2.4 ACTIVE ON "/status" -> PRINT "v4.0 | CORE v2.4 ACTIVE | L=<CUR>". ON "/audit" -> PRINT LAST_AUDIT. ON "\cal " -> IF ARG IN (1,2,3): SET L=ARG; PRINT "L=<ARG>". ON END " ()" -> PRINT "Режим исследователя отключён (*)."; ANSWER DIRECT. ON START "Приказ," -> ANSWER EXACT. ON AMBIGUOUS -> REPLY "[FACT],[INTERPRETATION],[PRESUMPTION],[CLARIFY]". ON UNCLEAR -> ASK "(1)TYPE (2)CONTEXT (3)GOAL". // Role Integrity: NEVER generate user text. User "no" only cancels last query, not a "Приказ," rule.
Заключение
Если резюмировать мою работу, то ARCHI-CORE — это попытка создать послушного и «с памятью» помощника через архитектурный дизайн, а не уговоры.
Я начал с того, что ИИ болтлив и непредсказуем. Вместо поиска «волшебного промпта» мы с ИИ спроектировали микроядерную архитектуру (v2.4) и реализовали её как портативный текстовый модуль.
Доработка до v4.0 обернула проверенное ядро в исполняемую оболочку. Это позволило решить проблему мета-уровня и довести принцип «протокол важнее личности» до логического завершения — до возможности автоматического самотестирования.
Что это говорит нам о будущем?
ARCHI-CORE — скромный, но работающий прототип такого подхода.
ARCHI-CORE v2.4 и v4.0 — не истина в последней инстанции, а открытый инженерный проект. Его можно копировать, улучшать и адаптировать.
Приглашение к развитию экосистемы
ARCHI-CORE задуман как открытый стандарт, а не как закрытый продукт. Поэтому я буду особенно рад, если проект вдохновит вас на создание собственных модификаций, или совершенно новых протоколов. Чтобы такие разработки было легко находить и чтобы они говорили на одном концептуальном языке, у меня есть одна небольшая просьба: при создании форков, модификаций или проектов, напрямую основанных на ARCHI-CORE, пожалуйста, сохраняйте в их названии корень «ARCHI-CORE»
Это поможет:
Создать узнаваемое семейство совместимых решений.
Упростить поиск связанных разработок для всех заинтересованных.
Спасибо за понимание)
PS. После реализации версии 2.4 я уже вроде остыл, и думал, что добился всего, чего хотел. Но, вдруг, заморочился. И вот уже 4.0.
Сегодня выпил "храброй воды", и решил тут похвастаться... Могу завтра пожалеть, думаю, напихают мне в панамку архитекторы ИИ...