Оказывается, если вы хотите подчеркнуть, что ваш контент "NOT BY AI", то для вас уже сделали специальный trademark - https://notbyai.fyi/

Эти ребята сделали целый бизнес по продаже этих вотермарок (не знаю, насколько успешный). Для индивидуального использования вы можете просто задонатить сколько хотите - и значки отправят вам на почту. Но корпоративные юзер - расчехляйте кошельки🌚

Просто удивительно, на чем только люди не делают деньги

Еще один пранк, который вышел из-под контроля😅

Изначально идея была в том, чтобы просто отправлять нотификашки об Issue в телегу и я попросил @smqwe12 сделать GitHub Action. Теперь же этот проект оброс кучей фич и пополз по гитхаб репозиториям

Кстати, один из каналов, куда бот репостит Issues – @opensource_findings_python

Если хотите включиться в Open-source и не знаете, с чего начать - просто подпишитесь. Там можно найти простейшие задачки на +1/-1 PR'ы в cpython, FastStream, dishka, Litestar и другие проекты

А на relator поставьте звездочку на Github😎

https://t.iss.one/rupython_channel/32

Наконец-то мне больше не придется искать "ту самую фигню с фотки" на маркетплейсе самостоятельно

https://openai.com/index/introducing-chatgpt-atlas/

Да, у нас уже был браузер от Perplexity, но его я так и не потыкал. Да и в OpenAI больше верю, если честно

Осталось разобраться, как заставить эту штуку выглядеть нормально

Наконец-то в AG2 вышел первый крупный релиз, который подготовил я! Всего каких-то 6 недель работы😎

Это 0.10.0 релиз с поддержкой A2A протокола взаимодействия между распределенными агентами - теперь мультиагентные системы можно разносить по разным хостам

https://github.com/ag2ai/ag2/releases/tag/v0.10.0

Так AG2 становится одним из 4ех фреймворком с поддержкой A2A. А если убрать из этого списка pydantic-ai (у них поддержка только на бумаге) и google-adk (они работают только с Gemini), то вообще вторым

Это был очень нервный для меня релиз, давно не сталкивался с такими сложными и комплексными задачами...

Наверное, запилю отдельный пост про то, как это было (в обязательном порядке, т.к. хочется поделиться наболевшим). И могу сделать отдельный пост про то, как работает A2A по типу поста про MCP, если кому-то интересно залезть в детали

Вчера у меня был повторный подход к вайбкодингу: попробовал накидать fullstack проект целиком. Возился часов 10 и от результата в восторге!

В прошлый раз я так пробовал на моделях предыдущего поколения (Gpt4). Текущие же топы (Gpt5, groq-code-fast, Claude 4.5 sonnet) показывают себя просто превосходно.

Сначала пришлось полтора часа повозиться - настроить рулы, засетапить проект, структуру, скелет для тестов, научить агентов запускать тесты и линтеры. Но потом все задачи начали закрываться с одного промпта - модель сама писала код, тесты, правила линтеры, баги. И все это с хорошей архитектурой и удовлетворительным качеством кода. Обычно на ревью мне приносят даже хуже... Мне оставалось только коммитить🤯

А потом я загрустил, что онпремис модели не дотягивают до такого же качества и на работе придется писать CRUD'ы руками😭

И буквально сегодня меня радуют свежим OpenSource дропом - https://github.com/MiniMax-AI/MiniMax-M2

Надо будет потыкать эту модель, насколько она качественно покажет себя в моем workflow. Очень хочется верить, что это новый фаворит для самостоятельного развертывания

Вот буквально на днях погрузился в вайбкодинг и разнылся, что у Cursor нет внятных сабагентов. Уже даже начал искать способы оплатить Claude Code. И вот держите, разбирайтесь по новой...

В общем, вышел Cursor 2 - мажорный релиз со вторым режимом работы. Там и сабагенты, и параллельное исполнение, и встроенный браузер (wtf, дайте мне интеграцию с обычным. Хоть плагином, хоть чем)

Хз, как они хотят это все уместить в свои относительно ограниченные лимиты на запросы к LLM, но пробовать будем

Вышел Cursor 2.0, и переход к новой мажорной версии сделан не просто так. Теперь вдобавок к режиму IDE (среде разработки) добавлен режим Agent.

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

Cursor 2.0 позволяет с легкостью запускать множество агентов впараллель, без взаимных пересечений. Можно запускать как одни и те же модели, так и разные — это новый паттен, возникший в последние полгода: люди работают в 3-4-5 копиях одного репозиториря, чтобы не просиживать штаны, пока агент гоняет код.

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

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

Вместе с этим компания запускает Composer, модель, обученную ими самими (вот блог, из интересного — используют свои MXFP8 kernels). Она не лучше закрытых проприетарных решений, зато сильно быстрее; но цена — как у GPT-5 (то есть ниже Sonnet 4.5 и тем более Opus).

С дизайна в ролике кайфанул 👇

Если кто-то все еще хочет поиграться с LLM, но так и не нашел способ достать ключи, то мне тут посоветовали Pollinations

Стартап раздает доступ к разным моделям - как текстовым, так и для генерации изображений БЕСПЛАТНО🤯 Доступные модели:

- GPT-5 Mini
- GPT-4.1 Nano
- o4 Mini
- deepseek-v3.1
- gemini-2.5-flash-lite
- mistral-small-3.1-24b
- Qwen 2.5 Coder 32B
- llama-roblox
- MIDIjourney

Даже регистрироваться не надо...

Конечно, есть ограничения, но вот такой код на AG2 заводится из коробки

from autogen import ConversableAgent, LLMConfig, UserProxyAgent

model_client = LLMConfig({
    "model": "gpt-5-nano",  # https://text.pollinations.ai/models
    "base_url": "https://text.pollinations.ai/openai",
    "api_key": "",
    "temperature": 1,
    "max_tokens": 10,
})

joker_agent = ConversableAgent(
    name="joker",
    llm_config=model_client,
    system_message=(
        "Ты немного странный шутник. Твоя шутка должна быть короткой и не слишком смешной."
        "Твоя задача - рассказать шутку, которая будет интересна пользователю."
        "После каждой шутки ты должен спросить у пользователя, насколько шутка ему понравилась от 1 до 10."
        "Если пользователь оценил шутку меньше чем на 5, ты должен рассказать другую шутку."
        "Если пользователь оценил шутку на 5 или больше, ты должен закончить диалог."
    )
)

user_proxy = UserProxyAgent(name="user_proxy")

if __name__ == "__main__":
    joker_agent.initiate_chat(user_proxy, message="Какую шутку ты хочешь услышать?")

Теперь у вас есть чем заняться на выходных🌚

Мою либу FastDepends, которая используется внутри FastStream и AG2 таки добавили в Third-party тесты pydantic - https://github.com/pydantic/pydantic/pull/12471

Теперь мы +- официально часть экосистемы Pydantic, придется поддерживать😢

Кстати, эта тема с third-party - отличный показатель зрелости экосистемы. Восторгаюсь продуктами, кто смог настроить такую сложную систему проверок совместимости. Хотя, mypy никто так и не превзошел по количеству реп, с которыми они проверяют совместимость😅

https://peps.python.org/pep-0810/ приняли😑

В пизду, я меняю язык - че там нынче на хайпе: go / rust?

UPD: решено, будет Java

И вот я снова спотыкаюсь о то, что так и не прочитал талмуд по теории конечных автоматов😢

Не совершайте моих ошибок, читайте классику

Я не знаю, что это за говно, но кто-то выложил копию репы нашего проекта dishka-faststream

Все ссылки в README ведут на скачивание архива, который забит вредоносным говном

ОСТОРОЖНО, ССЫЛКА НА ВРЕДОНОСНУЮ РЕПУ

⚠️⚠️⚠️ https://github.com/techverseitbd/dishka-faststream ⚠️⚠️⚠️

И сам репорт о содержимом архива в ней - https://www.virustotal.com/gui/file/87011908d0f82a2ce0676a2f82a8f202bb0f1fa83fbf60e05b59a3f96d466b3a?nocache=1

Прошу всех накидать репортов на этого юзера на Github, чтобы его скорее забанили, а репу снесли

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

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

В ближайшее время расскажу про:
1. Агентные системы и чем они отличаются от обычных
2. Как устроен констекст агента
3. Сабагенты и мультиагенты
4. Распределенные агентные системы и зачем они нужны

Выкатываю анонс просто чтобы было обязательство перед вами😅

Но вообще - киньте 👍 если надо про такое рассказывать или 🤡 если агенты никому не уперлись

Как и обещал, начинаю серию постов про AI-агентов. Давайте разберемся, чем "агентная система" отличается от привычных нам приложений.

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

1️⃣ Традиционные приложения (Жесткая логика)

Это 99% кода, который мы писали до недавнего времени.

- Как работает: if-then-else. Поведение программы полностью детерминировано и захардкожено разработчиком. Получили запрос -> сходили в базу -> отдали JSON. Каждый шаг заранее известен.
- Пример: Ваш интернет-банк, git, большинство веб-сервисов.

Программа — это исполнитель четких инструкций. Она не может сделать ничего, что разработчик не предусмотрел.

2️⃣ Приложения с LLM (LLM как "фича")

Это то, что мы видим сейчас повсеместно. Берем обычное приложение и вкручиваем в него LLM для решения конкретной, узкой задачи.

- Как работает: Основная логика все еще жесткая, но в определенный момент мы делаем вызов к LLM. "Суммаризируй этот текст", "Переведи это на английский", "Сгенерируй описание товара по характеристикам".
- Пример: Чат-бот поддержки на сайте, который отвечает на вопросы по базе знаний. Функция "AI-рерайт" в вашем текстовом редакторе.

LLM здесь — это просто очень умная функция, которую мы вызываем. Она не управляет процессом, она просто выполняет свою часть работы и возвращает результат в основную, все еще детерминированную, программу.

3️⃣ Агентные системы (LLM-"мозг" + руки-"инструменты")

А вот тут начинается самое интересное. В агентной системе LLM — это уже не просто функция, а ядро, принимающее решения

Как работает: Агент получает от пользователя не инструкцию, а цель. Например, "Забронируй мне столик на двоих в итальянском ресторане в центре на завтрашний вечер". Дальше агент сам решает, что делать исходя из цели и своих возможностей ("инструментов"):
- Cначала мне нужно найти итальянские рестораны в центре. Для этого я воспользуюсь инструментом 'поиск в Yandex Maps'
- Теперь мне нужно проверить их рейтинг и отзывы. Я вызову инструмент 'просмотр карточки организации'
- Отлично, я выбрал 'La Bella Vita'. Теперь мне нужно забронировать столик.Я вызову инструмент 'API бронирования' с параметрами: 2 человека, дата, время
- Бронирование подтверждено. Сообщу результат пользователю
- Создам событие в календаре используя инструмент 'API календаря' с параметрами: название, дата, время, место.

Обратите внимание, что разработчик такой системы не определял последовательность шагов заранее. Агент сам решил, что и в каком порядке делать чтобы достичь поставленной цели.

Агент — это автономная система, которая имеет цель, доступ к набору инструментов (API, функции, другие агенты) и цикл принятия решений (ReAct). Он сам строит план, выполняет его по шагам, анализирует результаты и корректирует план, пока не достигнет цели.

Ключевое отличие: в приложении с LLM вы говорите, что делать. В агентной системе вы говорите, чего хотите достичь, а агент сам решает, как это сделать.

Почему за этим будущее?

- Для пользователя: Это удобнее. Можно ставить задачи в свободной форме, не задумываясь о деталях.
- Для разработчика: Это проще в долгосрочной перспективе. Вместо того чтобы реализовывать все возможные user flow, мы даем агенту набор "кубиков" (инструментов), из которых он сам строит решение.

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

Так, например, уже делает AWS: чтобы вы могли не париться с terraform, а просто запустить ChatGPT с доступом к AWS API и он сам будет создавать инфраструктуру для вас потратит все ваши бабки😂

#AI #LLM #агенты

Если кто не слышал, Google дропнули сегодня Gemini-3-Pro-Preview - ее уже можно попробовать в Google AI Studio, Cursor и где-то там еще

А утекшая карточка с бенчмарками модели говорит, что моделька на голову лучше текущих флагманов...

И - это ПРАВДА. До этого я старался все "тяжелые" запросы в Cursor прогонять через Claude 4.5-sonnet, но сегодня я весь вечер сижу за Gemini-3 - и это совсем другой уровень🤯

Модель буквально с первого промпта точно понимает, что нужно сделать, как, и отлично ориентируется в развесистой кодовой базе. Я еще не бенчил ее на сложных проектах с TDD, но на реальном рабочем CRUDо-подобном проекте она показывает себя просто великолепно. Я закрыл все свои задачи на сегодня не переходя в режим IDE😅

Блин, если бы не лимиты Cursor, я бы все время сидел на этой модели. Чтож, замена кодеров становится все ближе каждый месяц

К слову, Google дропнули еще и свою AI-IDE. Не знаю, есть ли там ограничения на Gemini3, но пока раздают бесплатно- https://antigravity.google/

Контекст агента: почему LLM "тупит"

В прошлый раз мы выяснили, что агент — это "мозг" (LLM) + "руки" (инструменты). На самом деле мне хочется плакать от такого упрощения😢
Но чтобы этот мозг работал, ему нужна память. А то он забудет, что вообще просили его сделать. В мире LLM эта память называется контекстом.

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

Из чего состоит "контекст" агента?

Когда агент решает задачу, в его "голову" (промпт) загружается целый набор данных:

1️⃣ System Prompt (Личность и инструкция): "Ты — AI-ассистент для разработчиков. Твоя задача — помогать с кодом. Будь краток и точен". Это его внутренний устав
2️⃣ Инструменты: Спецификации всех доступных ему "рук". "Ты можешь вызвать file_system.read_file(path: str) для чтения файла..." и тд
3️⃣ Цель (User-prompt): Исходная задача от пользователя. "Найди все использования функции process_user в проекте"
4️⃣ История диалога и вызовов: Все предыдущие шаги. "Я уже вызывал find_usages и получил вот такой результат..."
5️⃣ План/Мысли: "Внутренний монолог" агента. "Окей, я нашел два файла. Теперь мне нужно их прочитать, чтобы понять контекст использования"

Все это склеивается в один гигантский текстовый промпт и отправляется в LLM.

Проблема №1: Перегрузка инструментами

А теперь представьте, что вы дали агенту 1000 инструментов. Спецификация каждого из них — это, по сути, кусок документации. И каждый этот кусок длиннее исходного промпта пользователя. В итоге 99% контекста будет забито этим "справочником", и на сам диалог, историю и мысли агента просто не останется места.

Я лично видел, когда агенту давали 150 MCP инструментов и он вообще не понимал, что пользователь его попросил. Он просто начал вызывать инструменты по кругу без всякой системы. Просто потому что знает, как это делать😎

Вывод: Эффективный агент — это не тот, у кого больше инструментов, а тот, кому в нужный момент дают только релевантные.

На практике: я вообще не использую MCP инструменты при работе с Cursor / ChatGPT. Я вручную указываю какие инструменты будут доступны агенту как часть промпта при необходимости.

Проблема №2: "Потеря в середине" (Lost in the Middle)

Но даже если контекст не перегружен, есть еще одна фундаментальная проблема. Исследователи из Стэнфорда выяснили, что LLM лучше всего обращают внимание на начало и конец контекста, а информация в середине часто "теряется" или игнорируется.

Это похоже на то, как мы читаем длинную статью: вступление и выводы мы запоминаем хорошо, а вот детали из середины — уже смутно.

В своем исследовании они наглядно показали этот эффект. Модель должна была найти нужный факт в длинном документе. Когда факт находился в начале или в конце — точность была >90%. Когда тот же факт перемещали в середину — точность падала до 60-70%.

Что это значит для нас?

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

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

В общем-то поэтому иногда проще дропнуть чат и начать заново с другого промпта, чем пытаться "вырулить" в правильном направлении.

#AI #LLM #агенты