Cairn

Self-hosted панель, в которой знание о проекте переживает агентов, работающих над ним. Координационный журнал, а не runner: агенты читают бриф и отчитываются о результате, а вы не объясняете каждому одно и то же заново. Для команд, запускающих несколько агентов на один и тот же код.

Cairn
TL;DR

Cairn - это self-hosted панель, в которой знание о проекте переживает ИИ-агентов, работающих над ним. Это координационный лог, а не раннер: агент читает бриф, делает своё и сообщает результат, а вы не объясняете следующему то же самое с нуля. Для команд, которые пускают несколько агентов на один и тот же код и устали от того, что память проекта гибнет вместе с сессией.

Введение

Когда над одним репозиторием работают несколько ИИ-агентов, знание о проекте имеет скверную привычку умирать вместе с закончившейся сессией. Первый агент узнал скрытые зависимости, выяснил, какая часть кода хрупкая, и разобрался, как здесь деплоят. Потом сессия гаснет, и это знание исчезает. Следующему агенту вы объясняете то же самое с начала, и ещё одному, и ещё раз, пока сами не станете узким местом для знания о собственном проекте.

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

Знание, которое умирает вместе с сессией

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

Естественный порыв - записать это в README или вставить в промпт. Только README быстро устаревает, а промпт умирает вместе с окном чата. Нужно было место, которое растёт вместе с проектом и переживает отдельные сессии: то, куда агент заглядывает за контекстом на входе и куда дописывает, что сделал, на выходе.

i
Примечание

Cairn осознанно не раннер. Он не запускает агентов, не управляет их процессами и не пытается быть их средой. Это координационный лог: место, куда агент заглядывает за контекстом и куда записывает, что сделал. Эта граница - вся его сила.

Лог, а не раннер

Легко было бы сделать из этого очередной оркестратор, который сам запускает агентов и пытается ими дирижировать. Мы отказались от этого намеренно, потому что у раннеров предсказуемая судьба: они глубоко врастают в вашу среду, всё больше о ней предполагают и быстро становятся вещью, которая сама требует сопровождения. Вместо того чтобы давать память, они отнимают время.

Координационный лог - наоборот: простой, пассивный и никому не мешает. Агент по-прежнему живёт там, где обычно, в вашем терминале или пайплайне, делает своё в собственной среде, а Cairn лишь даёт ему память и место для отчёта. Здесь нет магии оркестрации, которая работает на демо и рассыпается на настоящем проекте, потому что оркестрации нет вовсе.

Что он держит, а чего осознанно нет

РольCairn делает этоCairn этого не делает
Контекстдержит бриф и историю решенийне угадывает контекст за вас
Координациялог записей на проект, по порядкуне запускает и не управляет процессами агентов
Хостингставите у себя, данные остаются вашимине отправляет ваш код в чужое облако
Видимостьодно место для того, что сделано и открытоне заменяет ни ваш репозиторий, ни CI

Цикл бриф, работа, отчёт

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

1
Бриф

вы заводите проект и описываете его один раз: что это, где границы, на что обращать внимание.

2
Агент читает

каждый новый агент начинает с того же контекста, без ручного повторения.

3
Агент работает

делает свою задачу в собственной среде, потому что Cairn его не запускает и не ограничивает.

4
Агент отчитывается

дописывает результат в лог: что изменил, что работает, что осталось сделать.

5
Следующий продолжает

агент за ним читает бриф плюс все отчёты и входит в работу с полной картиной.

Ключ в том, что запись - это не свободный текст, а короткая структура с состоянием и списком того, что открыто для следующего. Благодаря этому лог одинаково быстро читается машиной и человеком, а следующему агенту не нужно догадываться, на чём остановился прошлый ход.

entry.ts · ts
type LogEntry = {
  project: string;
  agent: string;
  at: string;
  did: string;
  state: 'done' | 'partial' | 'blocked';
  openForNext: string[];
};

function contextFor(project: string): string {
  const brief = readBrief(project);
  const history = readEntries(project);
  return [brief, ...history.map(render)].join(SECTION_BREAK);
}

Масштаб, который растёт вместе с проектом

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

Время ввода следующего агента (ориентировочно, минуты)

Агент 1Агент 2Агент 3Агент 4Агент 5

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

1 бриф
пишется один раз, читается каждым агентом
1 лог на проект
память, которая переживает сессии
0
запускаемых процессов, потому что это не раннер
self-hosted
данные и код остаются у вас

Тихий слой памяти

Лучшие инструменты - не те, что делают больше всего. Это те, что делают одну вещь и уходят с дороги.

Команда, которая пускает несколько агентов на один и тот же код, перестаёт быть узким местом для собственного знания. Бриф вы пишете один раз, а не при каждом новом окне чата. Агент, который входит третьим, знает столько же, сколько первый, потому что читает то же самое. Cairn не эффектный и не пытается им быть: это тихий слой памяти, которого раньше не хватало между сессиями.

➜
Совет

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

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

Больше проектов

Другие работы из той же категории - посмотрите, как мы решаем похожие задачи.

Есть похожий проект?

Напишите нам - смета бесплатна и приходит в течение часа.