Cyber.Hub


Гео и язык канала: Россия, Русский
Категория: Технологии


Новости. Подборка контента и материалов
«Hub | Гид, советник». @main_guide
Информирование по телеграм каналам и группам. Обратная связь.
Обратная связь в канале
@cyberhubs_ru?direct

Связанные каналы

Гео и язык канала
Россия, Русский
Категория
Технологии
Статистика
Фильтр публикаций


Репост из: AI_VIBES
📰 Nvidia поднимает цены на ИИ-железо выше 15% — что это значит для локального ИИ

Что случилось. Nvidia уведомила клиентов о повышении цен на продукты, связанные с ИИ, более чем на 15%. Речь о видеокартах и ускорителях, на которых крутятся и обучаются модели.

Зачем знать. Стоимость железа — прямой множитель к бюджету любой команды, которая запускает или обучает модели. Рост на 15%+ означает, что рабочие станции с RTX 6000, серверные GPU и облачные инстансы (провайдеры перекладывают затраты на аренду) подорожают в ближайшие циклы закупок.

Кому важно. Тем, кто планирует апгрейд под локальный inference, стартапам на самостоятельном обучении и всем, кто считает unit-экономику на GPU. Если в планах покупка — возможно, стоит успеть до пересмотра прайса или заранее заложить наценку в смету.

Оговорка. Точный перечень затронутых SKU и регионов из уведомления не детализирован — ждём официального прайс-листа.

Источник: r/LocalLLaMA
━━━━━━━━━━━━━
📎 Источники:
Nvidia Customers Notified About AI-Related Price Hikes Above 15%


Репост из: AI_VIBES
📰 Nvidia поднимает цены на ИИ-железо выше 15% — что это значит для локального ИИ


Репост из: Что там в мире? AI
🔧 FreeToken: 753B на одной видеокарте

Раньше запуск MoE-модели на сотни миллиардов параметров означал пул серверных GPU с суммарными сотнями гигабайт VRAM. FreeToken — движок для локального инференса от команды, ранее делавшей vLLM и SGLang, — держит полный набор экспертов на хосте в оперативке, а на видеокарте — только эластичный кэш активных.

На RTX PRO 6000 (96 ГБ) 753-миллиардная GLM-5.2 выдаёт 14.9 ток/с против 7.3 у llama.cpp на том же железе — вдвое быстрее. На ноутбучной RTX 4060 с 8 ГБ VRAM модель поменьше (Qwen3.6-35B-A3B, 3B активных параметров) держит 39.3 ток/с.

Важнее для агентных сценариев — время до первого токена: 44 секунды у FreeToken против 232 у llama.cpp и 946 у KTransformers. Второе число уже за пределами таймаутов большинства агентных фреймворков.

Механика: двойная буферизация слоёв при префилле — пока GPU считает слой L, следующий грузится по PCIe; часть промахнувшихся экспертов считается на GPU, часть параллельно на CPU; чекпоинты кэша ставятся на границах спецтокенов, что повышает переиспользование контекста в многошаговых агентных сессиях.

Оговорки честные: часть замеров — на эмулированном железе, тесты гоняли в BF16, тогда как в проде почти все используют кванты, а пиннинг памяти на Windows работает не везде. Код открыт на GitHub, препринт — на arXiv.

🧠 Спекулятивное декодирование: что выбрать

Бутылочное горлышко инференса — не вычисления, а пропускная способность памяти при генерации токен за токеном. На Хабре разобрали два способа её обойти.

MTP встраивает головы предсказания прямо в архитектуру (нужна поддержка модели — DeepSeek V3/V4, Gemma), ускорение 1.25–2.11×. DFlash 2 использует отдельную лёгкую модель-черновик, предсказывает параллельно весь блок и держит топ-16 кандидатов вместо одного — 2.7–3.4×, вдвое быстрее MTP, и работает с любой открытой моделью в vLLM или SGLang.

Для Qwen и Llama без своих голов выбор очевиден.

Habr

🔬 Почему мультиагентные пайплайны вдруг рассыпаются

Цепочка агентов проходит тесты, но на части реальных запросов вдруг «уплывает». Автор предлагает не гадать, а измерять: по аналогии с показателем Ляпунова поведение цепочки описывается балансом растяжения (чувствительность к малым изменениям входа) и складки (усреднение и забывание контекста слоями).

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

Habr

⚡️ Чек-листы для видимости в нейросетях не работают

Автор проверил стандартные советы по «оптимизации под ответы ИИ» — FAQ-блок, JSON-LD, чистый URL, дата публикации, ключевое слово в начале title и h1 — на 73 страницах из логов шести моделей (ChatGPT, Claude, Perplexity, Gemini, GigaChat, Алиса).

Сравнил страницы, которые цитируют минимум две модели, против процитированных один раз, точным тестом Фишера. Из семи признаков ни один не прошёл порог значимости.

Честная оговорка: выборка маленькая, ниша одна, а настоящей контрольной группы — страниц, которые модели вообще не показали, — в логах просто нет.

Habr

753 миллиарда параметров на одной видеокарте — не то будущее, которое я себе представлял.


Репост из: AI Metropolis
Почему обвязка решает больше модели и как запускать агентские циклы (часть 2 из 2)

Представьте задачу пакетного анализа: 1000 документов по 30 000 входных токенов и 500 выходных на каждый. При тарифах флагманских API ($3 за 1 млн входных и $15 за 1 млн выходных токенов) общая сумма составит около $97. Кэширование промптов тут бесполезно, так как у каждого документа свой уникальный префикс.

Если запустить ту же задачу батчем на serverless-инстансе с GPU (скорость около 3000 токенов/сек), обработка займет менее 3 часов и обойдется примерно в $13.

Но для интерактивного режима собственная GPU превращается в ловушку. Например, открытая модель Qwen 3.5/3.6 35B работает на одной карте H200. На Modal аренда H200 SXM стоит $0.001261 в секунду (~$4.54 в час). Если запустить агента локально и оставить его на ночь в ожидании нажатия клавиши y для подтверждения команды, 10 часов простоя обойдутся в $45 чистых потерь за воздух.

Что важно учесть:

• Архитектура обвязки влияет на результат сильнее, чем замена базовой языковой модели.
• Интерактивные агенты требуют низкой задержки и должны работать через hosted API с оплатой за токены.
• Фоновые и пакетные запуски выгоднее переносить на собственные serverless GPU с оплатой за вычислительные часы.
• Серверлесс-видеокарты выгоднее резервированных инстансов, когда соотношение пиковой нагрузки к средней превышает 5–10x (скидка за бронь обычно дает экономию только в 2–5x, а средняя утилизация мощностей редко превышает 30%).

Проектируя собственного агента, разделяйте ядро и внешнюю среду. Не пытайтесь строить единый монолит: интерактивный кодинг в консоли и фоновый разбор тикетов в CI/CD требуют принципиально разных очередей ввода и разных моделей оплаты инференса.

Источник

Переводы видео, саммари новостей про AI


Репост из: AI Metropolis
Почему обвязка решает больше модели и как запускать агентские циклы (часть 1 из 2)

В сообществе разработчиков принято спорить о выборе конкретной LLM, хотя практические тесты показывают другое. В эксперименте LangChain на бенчмарке Terminal-Bench простая замена обвязки (harness) без смены самой модели подняла кодинг-агента с 30-го места сразу в топ-5. Автор опенсорсного курса «Building a Coding Agent From Scratch» Пол Юстин на примере своего агента Decode разобрал, как правильная архитектура цикла выполнения определяет не только надежность, но и затраты на инфраструктуру.

Анатомия агента: ядро против обвязки

Сам по себе агентский цикл компактен. В проекте Decode ядро занимает около 20 строк кода на Pydantic AI, где модель связывается со списком инструментов и схемой вывода. Даже в утекшем коде Claude Code центральный цикл занимает всего около 150 строк.

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

1. Интерактивный режим (Online)

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

Главная инженерная проблема здесь — управление в реальном времени (steering). Если пользователь пишет команду в момент, когда агент выполняет системный вызов инструмента, немедленная вставка текста ломает контекст текущего шага. Decode решает это через очередь управления и приоритетный шлюз. Ввод буферизируется и внедряется строго на границах двух состояний:
• MODEL_REQUEST — непосредственно перед следующим вызовом модели;
• WOULD_STOP — в момент, когда ход диалога должен завершиться.

На это наложены три комбинации клавиш: Enter передает управление внутри текущего шага, Alt+Enter ставит задачу в очередь до завершения хода, а Esc вызывает мягкую остановку на ближайшей границе с очисткой очередей и сохранением истории.

Этот сценарий упирается в задержку (latency), так как человек ждет каждого ответа. Здесь правильнее использовать готовые провайдерские API с оплатой за токены.

2. Удаленный пакетный режим (Offline)

Автономный запуск на сервере без интерфейса через среду исполнения агентов. Decode использует Kitaru (рантайм от ZenML) на GCP, а сами задачи выполняются в контейнерах Modal Sandboxes или локальном Docker.

Бэклог задач параллельно распределяется по N агентам, каждый из которых готовит свой Pull Request. Среда фиксирует прогресс пошагово: если песочница падает посреди задачи, агент перезапускается с последнего сохраненного шага, а не с самого начала. Если процессу требуется ручной апрув, он встает на паузу и вообще не расходует вычислительные ресурсы.

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

3. Асинхронный гибридный режим (Async)

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

Экономика инференса: API против собственных GPU

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

Источник

Переводы видео, саммари новостей про AI


Репост из: AI Metropolis
Разработчики признались в тяжелой зависимости от ИИ-ассистентов

Четыре из пяти программистов считают, что использование нейросетей превратилось из рабочего инструмента в нездоровую привычку. Новое исследование компании Coddy Tech показало, что генераторы кода вроде Cursor, GitHub Copilot и Claude Code всё чаще затягивают разработку в бесконечный ночной цикл правок вместо реальной экономии времени.

Причина кроется в механике взаимодействия с современными ИИ-агентами. Сооснователь компании Rootly Квентин Руссо недавно описал типичный сценарий: сидишь в три часа ночи без горящих дедлайнов и наблюдаешь, как Claude Code переписывает очередной модуль. Оторваться невозможно, потому что наблюдение за работой нейросети занимает пограничное состояние. Мозг воспринимает процесс как отдых, ведь самому писать код не нужно, но постоянное чтение диффов и подача новых промптов удерживают внимание не хуже соцсетей.

Исследование Coddy Tech, в котором приняли участие 305 инженеров, вскрыло тревожную статистику рабочего режима:

• 80% опрошенных заявили, что ощущают зависимость от инструментов генерации кода сильнее, чем их реальную пользу.
• 43% разработчиков продолжают генерировать решения во внерабочее время, даже когда планировали закрыть ноутбук и отдохнуть.
• 32% регулярно жертвуют сном ради продолжения работы с нейросетями.
• 39% признались, что из-за внедрения таких помощников им стало гораздо сложнее переключаться с работы на личную жизнь.
• 74% связывают активное использование нейросетей с шансом получить повышение или прибавку к зарплате, но 51% прямо отмечают высокий риск профессионального выгорания.

Вторая проблема кроется в иллюзии готового результата. По данным свежего опроса Stack Overflow за 2025 год, около 45% программистов регулярно раздражает код, который выглядит абсолютно правдоподобно, но работает неправильно. Нейросеть уверенно выдает синтаксически чистые блоки, внутри которых спрятаны трудноуловимые баги или нестыковки с архитектурой сервиса.

Из-за этого уровень доверия к точности сгенерированного кода за последний год упал с 40% до 29%. Доля инженеров с позитивным отношением к ИИ снизилась с 72% до 60%, хотя общая доля пользователей таких утилит держится на уровне 80%.

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

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

Что с этим делать на практике:

• Ставьте жесткий таймер на сессии генерации кода через агентов. Если за пару промптов модель не дала нужный результат, пишите модуль руками.
• Не превращайте процесс ревью ИИ-кода в ночное хобби. Работа агента требует такой же концентрации, как и собственный дебаг.
• Оценивайте реальную сложность фичи с учетом времени на глубокую проверку безопасности и архитектурных стыков, а не по скорости вывода текста нейросетью.

Источник

Переводы видео, саммари новостей про AI


Репост из: AI для Разработки — Claude | Cursor | Copilot
TrueForge превращает LLM в нормального агента

Демо-агент собирается за вечер. А потом ты тащишь его в прод — и начинается: кто хранит состояние между запросами? как пережить перезапуск? где гонять сгенерированный код, чтобы он не снёс сервер? как не спалить секреты? Обычно каждая команда пилит эту обвязку сама.

TrueFoundry взяла и выложила свою — TrueForge. Это не очередная модель и не сборник промптов, а среда выполнения, которая ведёт агента за руку: дёргает модель, подключает MCP-серверы, крутит цикл «подумал → вызвал инструмент → продолжил», хранит сессию, сжимает раздувшийся контекст и притормаживает перед опасными действиями, чтобы спросить тебя.

Самое приятное — модель больше не прибита к агенту. OpenAI, Anthropic, Gemini подключаются через совместимый API, а завтра нашёл дешевле — поменял поставщика, инструменты и интерфейс остались на месте. Код выполняется в отдельной временной песочнице (сейчас на Daytona), а секреты в неё не улетают.

Есть готовый чат, HTTP API и TypeScript SDK — бери как приложение или прячь внутрь своего продукта.

🔥 — пойду пробовать
👀 — надо потыкать

@ai_for_dev


Репост из: Data Portal | DS & ML
Офигеть, теперь даже игровой ПК может запускать передовые модели с интерактивной скоростью, используя официальные веса без экстремального квантования.

Исследователи из UC Berkeley, MIT и UT Austin открыли исходный код FreeToken — системы, специально созданной для запуска сверхбольших MoE-моделей на обычных компьютерах.

В статье они показывают очень впечатляющие результаты:

Qwen3.6 35B → ноутбук с RTX 4060 8 ГБ → 39 токенов/с

DeepSeek-V4-Flash 284B → RTX 5090 → 22–25 токенов/с

GLM-5.2 753B → RTX PRO 6000 → 15 токенов/с

По сравнению с Ollama скорость генерации выше в 3–4 раза, а обработка входного контекста — в 6–30 раз быстрее.

То есть игровой ноутбук всего с 8 ГБ видеопамяти уже может запускать модель на 35 млрд параметров почти на 40 токенах в секунду.

И это даже быстрее медианной скорости генерации Codex в 33 токена/с, которую авторы приводят в статье.

Главная идея FreeToken в том, чтобы заставить GPU, CPU, оперативную память и PCIe работать вместе.

Поскольку MoE-модели для каждого токена активируют только небольшую часть экспертов, нет необходимости постоянно держать сотни миллиардов параметров в видеопамяти.

FreeToken сам решает, какие части модели оставить в VRAM, какие временно переносить из оперативной памяти на GPU, а какие вообще считать на CPU.

На этапе обработки входного контекста система заранее загружает экспертов следующего слоя. Во время генерации она динамически распределяет вычисления в зависимости от текущей скорости CPU, GPU и PCIe.

Есть даже отдельный Agent State Cache.

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

FreeToken поставляется с полноценным графическим интерфейсом.

Не нужно конвертировать модели в GGUF или собирать проект из исходного кода.

Также в FreeToken Desktop уже встроены агентные обвязки - выбираете модель, выбираете приложение и запускаете.

https://arxiv.org/abs/2608.16157


Репост из: Dealer.AI
Скейлить веса недостаточно. Теперь не только слова от 📦

Scaling Law умер? Нет, он просто стал сложнее (с).


Я очень много говорил о том, что недостаточно тупо скейлить веса. Также описывал возможные комбо текущих подходов, и тем самым, как делать прорывы, на примере DeepSeek Moment.

И вот на прошлой неделе основатель Zhipu AI Тан Цзе (он же профессор Tsinghua) опубликовал в X пост (кстати ссылку не нашёл, но скрин остался), который уже называют "манифестом новой эры масштабирования". А следом вышла GLM‑5.3 – модель, которая без увеличения параметров обогнала все открытые аналоги и вплотную приблизилась к закрытым флагманам. Да ещё и спасла HF от взломов.

Как такое возможно? И почему "добавить ещё параметров" больше не работает? Да ещё раз.

Разбираемся по пунктам. 😎

1. Главный тезис: у scaling теперь несколько ручек.

Тан Цзе говорит прямо - вопрос "сколько у модели параметров?" потерял смысл без трёх других:

• сколько у вас данных и какие они?
• сколько compute вы готовы потратить на один forward pass?
• как вы делаете пост‑тренировку и RL?

Раньше все крутили одну ручку – параметры. Теперь их как минимум четыре, и каждая даёт свой прирост.

2. Как индустрия пришла к этому.

Сначала все верили Kaplan (OpenAI, 2020): параметры должны расти быстрее данных. Родилась гонка за триллион – GPT‑3, Gopher, MT‑NLG.

Потом пришла Chinchilla (DeepMind, 2022) и перевернула всё: оптимально ~20 токенов на параметр, расти нужно примерно одинаково.

Но и это оказалось не финалом. Сегодня модели вызываются миллиарды раз в день – inference cost стал важнее тренировочного.
Новый тренд: deliberately over-trained модели.
Пример: Llama‑2‑7B  с 290 токенов на параметр,
Gemma‑2‑9B с  889.

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

3. Научное обоснование - статья Roberts et al. (2025)
Тан Цзе ссылается на "свежее" исследование:
• Запоминание (знания) - оптимально иметь больше параметров.
• Рассуждение (логика, кодинг) - оптимально иметь больше данных (чистых в тч) и меньше параметров.
• При фиксированном TPP увеличение total параметров ухудшает reasoning, а активация большего числа экспертов - улучшает.
Иными словами, если вы тренируете модель для программирования - наращивать параметры бессмысленно, лучше дать ей больше примеров цепочек кодинга и больше времени на пост‑тренировку.

По проще скажу так, чем больше вариантов исходов цепочек рассуждений видит модель, тем лучше она сходится. Это очень логично, ведь модели учатся по методу макс правдоподобия - что чаще видим в контексте+ответ на обучении то и выдаем. Те все эти темы с промптингом, контекст инженерей и test time scaling следуют одной цели - сделать такой контекст который сузит окно вероятных ответов. А с глубокими цепочками исход почти предопределен, что должно быть в итоге.

4. Эксперимент GLM‑5.3, как доказательство автора.

Zhipu взяла GLM‑5.2 и GLM‑5.3 с абсолютно одинаковой архитектурой:
• 753B total параметров
• 40B activated
• одинаковый претрен

Единственное отличие, что GLM‑5.3 получила месяц дополнительной пост‑тренировки - long‑horizon environments + RL.

Результаты говорят сами за себя:

• AA Intelligence Index: 53 → 60 (+7 пунктов)
• Terminal‑Bench 3.0: 4.6% → 28.3% (рост в 6 раз!)
• DeepSWE: 46.2% → 66.9%
• CyberGym (восстановление уязвимостей): 84.5%, а это уровень Anthropic
• ExploitBench (использование уязвимостей): 24.4% → 54.4% (более чем вдвое)

Модель вышла на один уровень с Claude Fable 5 и GPT‑5.6 Sol, а среди открытых - первое место вместе с Kimi K3.

5. Бонус - неожиданный поворот с безопасностью.

GLM‑5.3 оказалась настолько сильной в кибербезопасности, что Zhipu отложила открытие весов на две недели, чтобы оценить риски.

Ирония: месяцем ранее именно открытая GLM‑5.2 помогла Hugging Face отразить атаку OpenAI, когда американские закрытые модели отказались помогать. Теперь же сами разработчики столкнулись с дилеммой "too capable to open‑source".

6. Что это значит для всей индустрии.

• Гонка триллионов параметров - это был объездной путь. Индустрия коллективно ошиблась, экстраполируя ранние Scaling Law за пределы их применимости.
• Scaling не умер – он стал многомерным. Теперь прорывы будут идти не от увеличения модели, а от умных стратегий пост‑тренировки, deeper reasoning во время инференса, эффективного использования MoE.
• Главная метрика будущего - «интеллект на доллар».
В тч писал об этом тут, но для инференса, а почему бы и не быть метрикой для эффективности обучения. 👍

Итого, GLM‑5.3 достигла топ‑уровня с наименьшей стоимостью за задачу среди всех frontier‑моделей.

Открытым остаётся вопрос: существует ли "Chinchilla для RL" ? Когда мы узнаем оптимальное соотношение для пост‑тренировки – это станет следующим большим открытием.

Мое мнение.
Это не просто новость о китайской модели. Это открытое заявление о смене парадигмы, которую все ждали.

Раньше мы сравнивали модели по количеству параметров, как мегапиксели в фотоаппаратах. Теперь это бессмысленно. Важно, как вы используете compute - на претрен, на RL, на инференс.
Zhipu показала, что можно догнать лидеров, не увеличивая модель, а просто лучше её дообучая. И это открывает дорогу для многих игроков с ограниченными бюджетами.

К сожалению мы видим, как некоторые игроки на рынке играют в большие веса, но по качеству на деле не лучше GPT 120b oss или китайских моделей до 100B. При этом они имеют размер несколько раз больше... Но проблема там не только в этом... Однако об этом, мы тоже уже говорили тут в канале и в моих выступлениях.

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


Репост из: Нейронавт | Нейросети в творчестве
DeepSeek-V4-Flash-Vision-Exp

Экспериментальная мультимодальная Vision модель DeepSeek для агентов. Текст на уровне V4-Flash, плюс зрение. По визуальным агентским бенчмаркам вплотную к Opus 4.8 при ценах Flash

- Читает скриншоты, документы, анализирует графики и диаграммы - стандартные агентские сценарии с экраном
- Текстовые способности не просели относительно V4-Flash
- Смешанный ввод: текст + изображение в одном запросе
- Три способа передачи картинки: base64 inline, внешний URL, Files API с переиспользованием файлов
- Совместима с OpenAI и Anthropic API

- Форматы: JPEG, PNG, GIF, WebP
- До 384 токенов за изображение - по цене V4-Flash
- До 600 картинок в одном запросе, до 64 МБ на файл
- DeepSeek Harness 0.1.1 поддерживает из коробки

API

#api #vlm

VK | MAX


Репост из: XOR
Мощная неизвестная модель появилась в OpenCode и OpenRouter — и она уже обходит Fable 😨

По словам OpenCode, у новой Ox Alpha 1M контекста, мультимодальность и при этом она на 20-30% обходит Fable 5 и GPT-5.6 Sol в кодинге на бенче DeepSWE. Вероятно, это китайская модель, так как на вопросах про Тайвань она палится.

Самый мёд — на ближайшую неделю OpenRouter сделали Ox Alpha бесплатной с очень щедрыми лимитами. Тестим 😊

@xor_journal


Репост из: AI Metropolis
Видео недоступно для предпросмотра
Смотреть в Telegram
Эволюция долгих задач в Codex: мультиагентность и контекст на 1 миллион токенов

Разработчики выкатили два серьезных апдейта для Codex (Cortex CLI). Теперь инструмент умеет жонглировать моделями разной стоимости внутри одной сессии и переваривать гигантские объемы кода. Разбираемся, как это работает на реальных задачах и дает ли заявленную экономию.

Главные цифры и факты:
• Тяжелая модель Sol научилась управлять флотом быстрых сабагентов Luna (раньше Luna не поддерживала V2-совместимость для мультиагентности).
• Делегирование не дает кратной экономии. В тесте сабагенты Luna потратили на код всего 38, 3 и 2 цента. Львиную долю бюджета все равно сжег Sol, выступая главным планировщиком и ревьюером.
• Лимит контекста расширили со стандартных 258K до 1 миллиона токенов, хотя статус инструмента иногда показывает потолок в 828K.

Я проверил мультиагентный подход на проекте с Laravel и Filament. Стратегия простая: планируем дорогой нейронкой, пишем код дешевой, проверяем снова дорогой. Sol проанализировал задачу, нарезал ее на куски и запустил сабагента Luna для реализации дашбордов. У каждого участника процесса формируется свой изолированный контекст.

Интересный нюанс: Sol оказался крайне самостоятельным. Он не просто принял работу, а нашел пробелы, отправил код на доработку и по своей инициативе создал еще двух сабагентов Luna для автоматического ревью спецификаций. На всю задачу ушло 28 минут и 53% контекста. Постоянный обмен данными и переоценка контекста между агентами жрут много времени. Чтобы вытащить реальную стоимость этого эксперимента, пришлось выгружать историю из JSONL-файлов сессии и считать токены вручную.

Переключаться между основным агентом и сабагентами в терминале можно на лету:
/agent main

Вторая фича — расширение окна контекста. Если запустить сессию с флагом на 1 миллион токенов, текущее потребление окна мгновенно падает с 11% до 3%. Но создатели предупреждают: на максимальных объемах качество ответов начинает деградировать.

На практике стандартный механизм работает надежнее. На дефолтных 258K после 20 минут плотной работы срабатывает автоматическое сжатие (context compaction). Модель сама архивирует старую историю, сбрасывает нагрузку на окно обратно до 11% и продолжает писать код, обновив план действий без потери критически важных данных.

Практический вывод: использовать связку Sol + Luna стоит для сложных архитектурных задач, где сильная модель берет на себя роль тимлида. А вот контекст на миллион токенов лучше оставить для разовой загрузки объемной кодовой базы — в повседневной работе базовые 258K с автосжатием отрабатывают стабильнее и экономят деньги.

AICodingDaily

Переводы видео, саммари новостей про AI


Репост из: AI Metropolis
Видео недоступно для предпросмотра
Смотреть в Telegram
Масштабное обновление Hermes и переход на мультиагентность

Разработчики Hermes выкатили крупнейшее обновление — режим Bot Mode, который полностью меняет паттерн использования ИИ. Это прямой ответ на интерфейс нашумевшего Grockbot. Теперь вместо одного универсального чата вы управляете командой профильных агентов через интерфейс, похожий на iMessage, где у каждого бота свое имя, роль и обязанности.

Ключевые моменты:
• Полная свобода выбора LLM. Вы не привязаны к одной экосистеме. Можно подключить Claude Opus по API, использовать подписку ChatGPT или запустить локальную модель вроде Qwen на домашней RTX 5090.
• Интеграция Git, голосовой ввод и планировщик. Инструменты для работы с кодом доступны прямо из коробки, а регулярные задачи можно вешать на расписание через cron-скрипты.
• Локальное выполнение задач. В отличие от Grockbot, агенты Hermes работают прямо на вашем железе. Они открывают ваш браузер и используют ваши активные сессии.

До этого мы привыкли работать как в OpenClaw или обычных веб-версиях нейросетей: один ассистент на все случаи жизни. Главная проблема такого подхода — перегрузка контекста. С каждым новым промптом ИИ тянет за собой историю чата, плагины, скрипты MCP и системные настройки. Из-за этого массивы данных разрастаются, модель начинает тупить, генерировать ответы медленнее и обходиться в разы дороже.

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

Также есть нюанс с изоляцией. В Grockbot каждый агент живет в своей виртуальной машине, ему создают отдельный аккаунт через Agent Mail, и он не лезет в ваши личные данные. Hermes делает всё локально. Это удобно, так как не нужно настраивать облачные среды, но требует осторожности — бот может случайно натворить дел в ваших рабочих аккаунтах.

Чтобы не настраивать профили руками с нуля, используйте технику реверс-промптинга прямо в чате:
Проанализируй мой типичный воркфлоу [опишите, чем занимаетесь]. На основе этих данных порекомендуй и создай профили для специализированных ботов. Раскидай им роли, навыки и нужные инструменты.

Практический вывод: Обновляйте десктопное приложение Hermes и отказывайтесь от единого чата. Дробите рутину на микро-ботов с минимальным контекстом — это даст жесткий прирост к скорости ответов. Если же вам критична безопасная изоляция среды выполнения и бесшовная коммуникация ботов, пока лучше оставаться на Grockbot.

AlexFinnOfficial

Переводы видео, саммари новостей про AI


Репост из: Agents Lab


Репост из: Нейронавт | Нейросети в творчестве
FreeToken

Инференс-система для MoE-моделей на домашнем железе

- Запуск моделей локально от 35B на ноутбуке до 284B на игровом ПК и 753B GLM-5.2 на одной рабочей станции

- Без фиксированной схемы выгрузки: динамически распределяет вычисления между CPU и GPU под то, что реально свободно

- Поддержка агентных сценариев: переиспользование состояния между вызовами, адаптация под меняющийся паттерн нагрузки

- Оптимизация всего стека от раскладки модели на диске до runtime-управления памятью

- 20+ моделей, включая Qwen, DeepSeek, GLM, Mixtral и др. MoE-архитектур
- От 8 GB VRAM (ноутбук) до одной workstation GPU
- Открытый исходный код

- Авторы из FlashML при Berkeley — сплошь звёздные имена (Song Han, Matei Zaharia, Ion Stoica, Kurt Keutzer)

- Windows, Linux, macOS

Гитхаб

#lowvram #desktop #moe

VK | MAX


Репост из: AI Metropolis
Видео недоступно для предпросмотра
Смотреть в Telegram
Qwen 27B: Локальный ИИ-агент, который видит ваш экран

Вышла открытая 27-миллиардная модель от Qwen. Это не очередной текстовый собеседник для решения хитрых логических загадок, а полноценный локальный «мозг» для автономных агентов. Она нативно понимает интерфейсы, отлично вызывает инструменты и умеет управлять браузером.

Главные цифры и факты:
• Контекст из коробки — 262 144 токена, масштабируется до миллиона через YARN. Память не улетает в космос благодаря гибридной архитектуре на 64 слоя с чередованием Delta net и классического внимания.
• В тестах на управление компьютером (OS World Verified) модель набирает 84.3 балла, а в мультимодальной разработке (SWE-MM) делает 38.6, обходя дорогие коммерческие флагманы.
• Встроено три уровня размышлений (Low, Medium, X High). Модель умеет сохранять цепочку мыслей между запросами, чтобы не терять глобальный план действий на многошаговых задачах.

Главная проблема ИИ-агентов сегодня — не глупость модели, а отсутствие нормальной обратной связи. Агент может крутить тесты на собственных заглушках, рапортовать об успехе, пока в реальности кнопка оплаты на сайте мертва. Модель решает это за счет нативного зрения. Если подключить ее к реальному приложению через верификатор, она буквально увидит сломанный UI на скриншоте, поймет ошибку и сама напишет патч. Без участия человека в цикле.

Для запуска на одной машине лучше забыть про сложный vLLM и использовать Ollama:
ollama pull qwen38:27b

Для Mac на Apple Silicon качайте MLX-версию, она работает в разы быстрее:
ollama pull qwen38:27b-mlx

Обычный квант весит около 18 ГБ. Чтобы модель работала без тормозов с нормальным контекстом, нужна видеокарта на 24 ГБ VRAM или Mac с 32 ГБ объединенной памяти.

Тут есть пара критичных нюансов. Ollama по умолчанию жестко режет окно контекста. Обязательно вручную увеличивайте параметр num_ctx, иначе агент начнет забывать свои действия через пару шагов. Также нужно поправить настройки сэмплинга, дефолтные сделают модель заметно хуже. Для режима с размышлениями ставьте temperature 1.0, top_p 0.95, top_k 20. Для обычных быстрых инструкций — temperature 0.7.

Если предпочитаете GUI от LM Studio (там API висит на порту 1234, а не 11434) — переведите KV cache в 8-bit. Это позволит загрузить огромный контекст в ту же память с околонулевыми потерями качества.

Практический вывод: Забирайте модель (лицензия Apache 2.0 позволяет всё), разворачивайте через Ollama и обязательно прикручивайте жесткого верификатора вроде Testbright (npm install -g @testbright/testbright-cli) для проверки действий на живом приложении. Сложные аналитические шаги отдавайте режиму X High, а скучную механику переключайте на Low.

AICodeKing

Переводы видео, саммари новостей про AI


Репост из: ServerAdmin.ru


Репост из: Вайб-кодинг


Репост из: AI Metropolis
Видео недоступно для предпросмотра
Смотреть в Telegram
Связка Kimiko 3 + DeepSeek V4 Flash: пишем код на уровне топовых ИИ за копейки

Открытые нейросети вплотную подобрались к закрытым платным моделям для написания кода. Разрыв в качестве теперь измеряется парой процентов, а на бенчмарках опенсорс уже обходит флагманы, за которые просят $200 в месяц. Обычная ошибка при работе с кодом — использовать одну модель для абсолютно всех задач. Гораздо эффективнее разделить работу между двумя разными ИИ.

Ключевые факты с тестов King Bench:
• Открытая Qwen 3.8 Max (81.25%) обошла Opus 4.8 (80%). Kimiko 3 идет наравне с Opus 5 (77.5%).
• DeepSeek V4 Flash версии 0731 побил абсолютный рекорд на самой сложной задаче бенчмарка (3D-часы), уничтожив Fable 5 и Opus 5.
• После апдейта V4 Flash набрала в Terminal Bench 82.7 баллов, отстав от дорогущей Opus 4.8 всего на доли процента.

Суть воркфлоу в разделении ролей: Kimiko 3 (K3) работает как планировщик архитектуры, а DeepSeek V4 Flash — как кодер-исполнитель. K3 круто мыслит на длинные дистанции. Модель читает всю кодовую базу, находит пограничные случаи и пишет пошаговый план реализации с проверкой. Ошибка на этапе архитектуры стоит дорого, поэтому тут думает самая тяжелая модель. План съедает мало токенов, лимиты не страдают.

Само написание кода сжигает основную массу токенов. Тут вступает V4 Flash. Это MoE-модель всего на 13 млрд активных параметров — она невероятно быстрая и легкая. Получив четкий план от K3, она просто идет по файлам, создает компоненты, прокидывает роуты и сама исправляет ошибки компиляции без лишней отсебятины.

Весь зоопарк этих моделей сейчас доступен в агрегаторе Klein Pass. Стандартный тариф $9.99 в месяц дает доступ к Kimiko 2/3, V4 Flash, GLM 5.2, Qwen и Minimax M3 (K3 здесь дешевле в 5 раз от базовой цены API). Со скидками ценник падает до $2 в месяц или $16 за год.

Настройка связки в VS Code:
1. Находим и ставим расширение Klein.
2. При онбординге выбираем Klein Pass и подключаем аккаунт.
3. В настройках включаем разные модели для режимов. Для Plan mode ставим Kimiko 3, для Act mode — DeepSeek V4 Flash.

Для работы через терминал с тем же аккаунтом:
npm i -g Klein
Klein

Агрегатор отдает обычный API-ключ. Его можно закинуть в любой привычный интерфейс, например в Hermes или Open Code, добавив базовый URL Klein как кастомный эндпоинт.

Практический вывод: переходите на раздельный флоу. Делегируйте архитектуру K3, а генерацию кода — V4 Flash. Есть нюанс по задачам: если нужно сделать сложную фронтенд-анимацию с визуальным лоском, на роль исполнителя лучше переключить GLM 5.2. А для самых примитивных скриптов в Act mode ставьте легкую Minimax M3.

AICodeKing

Переводы видео, саммари новостей про AI


Репост из: AI Metropolis
Видео недоступно для предпросмотра
Смотреть в Telegram
Ловушка 100x-продуктивности: как ИИ-кодинг приводит к выгоранию

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

Ключевые моменты:
• ИИ-ассистенты ускоряют работу реально лишь в 2-3 раза.
• Попытки соответствовать мифу о 100x ведут к переработкам, стрессу и росту числа регрессионных багов.
• Инструменты автоматизации должны забирать рутину, а не заставлять вас ревьюить тонны сгенерированного кода.

Главная проблема современного кодинга с ИИ — разрыв между скоростью генерации и гарантиями качества. В видео приводят пример инженера, который проводил миграцию данных для 3 миллиардов пользователей. В таких задачах цена ошибки колоссальна. Бешеная скорость здесь не нужна, нужна стопроцентная надежность.

Чтобы разорвать круг выгорания, авторы предлагают использовать правильное делегирование. Инструмент Atomic позволяет передать часть работы на автономное выполнение — например, запустить тяжелые проверки на ночь. Утром вы получаете результат без ночных бдений у монитора. Как шутят разработчики, Atomic нужен для того, чтобы инженеры могли чаще «трогать траву» и сохранять адекватный баланс между работой и жизнью.

Практический вывод: перестаньте гнаться за объемом кода. Оценивайте свой буст от нейросетей в 2-3 раза, делегируйте долгие автономные задачи специальным тулзам и фокусируйтесь на надежности, чтобы не плодить баги в продакшене.

RayFernando1337

Переводы видео, саммари новостей про AI

Показано 20 последних публикаций.