Преодоление автофагии в мультиагентных LLM-системах через иерархические антагонистические контуры

Современные Large Language Models в сценариях долгосрочного автономного функционирования ограничены линейным ростом KV-кэша и затуханием контекста. Попытки интеграции систем долгосрочной памяти через автоматическую генерацию синтетических данных и самообучение приводят к автофагии (Autophagy) — модель, обучаясь на результатах собственной генерации, замыкается в «эхо-камере», что вызывает экспоненциальный рост энтропии и деградацию связности памяти уже на 3–4 итерации.

Настоящая работа описывает архитектуру AURA (Advanced Unified Retrieval Architecture). Стабилизация системы достигается за счёт разделения когнитивных функций на иерархические антагонистические контуры с дискретным квантованием количества ролей (3 → 6 → 9).

1. Математический базис памяти AURA

Динамическая память ИИ-агента оперирует концепцией полураспада информации (halfLife) по областям видимости (scope) и многофакторным композитным скорингом при извлечении. Каждому кванту памяти M_i присваивается временной вес, зависящий от его системной категории.

При обработке входящего запроса функция извлечения максимизирует композитный score:

где:

• Sim(Q, M_i) — косинусное сходство эмбеддингов запроса Q и кванта памяти M_i
• Δt — время с момента фиксации или последнего вызова кванта
• τ_scope — константа затухания, определяемая слоем классификации намерений (Agentic Intent Classification). Для scope = user_profile τ → ∞; для scope = session_task τ → 0
• Imp(M_i) — статический вес фундаментальной важности информации
• α, β, γ — динамические веса, пересчитываемые классификатором под интент пользователя (сумма строго равна 1.0)

2. Динамическая формализация функции полураспада τ_scope

Константа затухания τ_scope не является статической величиной. Значение τ_scope рассчитывается динамически на основе тензора признаков, формируемого Ролью 5 (Синдикатором) и Ролью 3 (Валидатором):

где:

• τ₀ — базовый шаг дискретизации времени жизни:
  • τ_{user_profile} → ∞ (инвариантные бизнес-правила)
  • τ_{operational_workflow} = 2.6 × 10⁶ сек (~1 месяц)
  • τ_{session_task} = 3.6 × 10³ сек (1 час)
• Freq(S) — частота обращения к данному scope за последние N транзакций
• H(S) — энтропия Шеннона для пространства S: H(S) = −Σ p(m) · log₂ p(m)
• σ(x) — логистическая сигмоида, нормирующая влияние статической важности

3. Теория когнитивного квантования: Матрица Триад

Количество ролей в AURA строго дискретно и кратно трём: 3 → 6 → 9. Каждая тройка формирует ортогональный контур контроля: Теза (Генерация) → Антитеза (Критика) → Синтез (Управление).

4. Спецификация 6 ролей архитектуры AURA

Контур А: Оперирование данными (Data Layer)

• Роль 1: Исполнитель (Colleague) — горячий контур (online). Принимает запрос Q, инициирует cross-role recall, рассчитывает Score(M_i), выдаёт ответ.
• Роль 2: Эволюционер (Intern) — асинхронный фоновый контур (near-line). Генерирует пограничные запросы, выявляет логические противоречия.
• Роль 3: Валидатор (Teacher) — фильтрует галлюцинации Роли 2, размечает метаданными, присваивает Imp(M_i).

Контур Б: Оперирование алгоритмом (Code Layer)

• Роль 4: Системный Инженер (Executor) — холодный контур (offline). Монополия на модификацию кода и мета-параметров (α, β, γ, размер чанков). Работает по триггеру от Роли 5.
• Роль 5: Синдикатор (Researcher) — мета-мониторинг здоровья системы. Строит динамический граф cross-role recall.
  • Триггер 1: скользящее среднее валидности Роли 3 ниже 0.80 на 50 транзакциях
  • Триггер 2: фиксация «зацикливания памяти» — ошибка калибровки τ_scope
• Роль 6: Ментор (Mentor) — детерминированный Guardrail. Проверяет патчи от Роли 4. Отклоняет при нарушении граничных условий (α + β + γ ≠ 1.0, шаг > Δ_max = 15%).

5. Аналитический разбор сходимости контуров

Пусть E_t — объём ложной информации в памяти на шаге t. В 3-ролевой системе оператор обновления памяти замкнут на себя:

где κ — коэффициент автофагии (κ > 1 при высокой интенсивности генерации синтетики), ξ_t — шум. При κ > 1 система экспоненциально деградирует (E_t → ∞).

В 6-ролевой архитектуре вводятся Роль 4 и Роль 6, изменяющие оператор RAG в зависимости от производной ошибки dE/dt:

где γ_t — компенсирующий фактор, η — скорость адаптации (жёстко ограничена Ролью 6: η < Δ_max). Поскольку Роль 6 через статический анализатор гарантирует, что γ_t не выйдет в область нестабильности, система сходится к устойчивому аттрактору, где dE/dt ≤ 0.

6. Дискуссия: Почему AURA — это не Fine-Tuning

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

Попытки реализовать непрерывное самообучение через дообучение весов базовой модели несостоятельны по трём причинам:

1. Катастрофическое забывание: модель теряет базовые навыки при частых градиентных сдвигах
2. Вычислительный паралич: постоянный расчёт градиентов для 70B+ моделей экономически невозможен
3. Vendor lock-in: изменения в весах модели превращаются в мёртвый груз при смене поколения LLM

Архитектура отчуждаемой памяти

AURA полностью исключает языковую модель из процесса изменения внутренних весов. LLM рассматривается как stateless процессор (CPU), принимающий на вход очищенный и взвешенный контекст. Вся эволюция бизнес-логики, накопление опыта и очистка от шума происходят во внешней структуре — слое обвязки, независимом от модели.

При выходе на рынок более производительных моделей вычислительное ядро заменяется без остановки системы. Накопленная годами внешняя память AURA остаётся нетронутой.

7. Программный каркас контура оптимизации (Python)

import asyncio, json, logging
from typing import Dict, List
from dataclasses import dataclass, asdict

logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
logger = logging.getLogger("AURA_Engine")

@dataclass
class TransactionLog:
    query: str; response: str
    validation_score: float
    scope: str

class AURAEnvironment:
    def __init__(self):
        self.hyperparams = {"alpha":0.5, "beta":0.3, "gamma":0.2, "chunk_size":512}
        self.archive: List[TransactionLog] = []
        self.lock = False

    def metric_trend(self) -> float:
        return (sum(tx.validation_score for tx in self.archive) / len(self.archive)
                if self.archive else 1.0)

class RuntimeOrchestrator:
    def __init__(self, env: AURAEnvironment):
        self.env = env
        self.THRESHOLD = 0.80

    async def role5_monitor(self):
        while True:
            await asyncio.sleep(1)
            if self.env.lock: continue
            trend = self.env.metric_trend()
            if trend < self.THRESHOLD and len(self.env.archive) >= 3:
                logger.warning(f"[5] ALERT: падение до {trend:.2f}. Зову Роль 4.")
                self.env.lock = True
                await self._cold_circuit()

    async def _cold_circuit(self):
        faulty = [asdict(t) for t in self.env.archive if t.validation_score < self.THRESHOLD]
        state = json.dumps(self.env.hyperparams)
        patch = await self._role4_code(state, faulty)
        if self._role6_guard(patch):
            self.env.hyperparams.update(patch["params"])
            logger.info("[6] Патч принят.")
            self.env.archive.clear()
        else:
            logger.error("[6] CRITICAL: патч отклонён.")
        self.env.lock = False

    async def _role4_code(self, config: str, logs: List[Dict]) -> Dict:
        logger.info("[4] Генерация патча...")
        await asyncio.sleep(0.5)
        return {"params": {"alpha":0.3, "beta":0.5, "gamma":0.2, "chunk_size":256},
                "sum_check": 1.0}

    def _role6_guard(self, patch: Dict) -> bool:
        p = patch["params"]
        s = p["alpha"] + p["beta"] + p["gamma"]
        # граничные условия: сумма весов = 1.0, шаг изменения параметра <= 15%
        max_step = max(abs(p[k] - self.env.hyperparams[k]) / max(self.env.hyperparams[k], 1e-9)
                       for k in p if k in self.env.hyperparams)
        return abs(s - 1.0) < 1e-5 and p["chunk_size"] >= 128 and max_step <= 0.15

async def run():
    env = AURAEnvironment()
    o = RuntimeOrchestrator(env)
    asyncio.create_task(o.role5_monitor())
    env.archive = [TransactionLog("Q1","R1",0.95,"p"),
                   TransactionLog("Q2","R2",0.72,"s"),
                   TransactionLog("Q3","R3",0.65,"s")]
    await asyncio.sleep(2)
    print(f"гиперпараметры: {env.hyperparams}")

if __name__ == "__main__":
    asyncio.run(run())

Вывод

Полный код и спецификация: github.com/alexenti-code/AURA-Retrieval

← Все исследования AURA