Hacker News Digest

Porffor — экспериментальный JS-движок, компилирующий код в WebAssembly и нативные бинарники. Вместо упаковки рантайма (как Node/Bun) он генерирует крошечные (<1 MB) и быстрые (миллисекунды) исполняемые файлы.

porf native hi.js hi   # 12.9 KB
./hi                   # 631 µs

Сравнение с Deno/Bun: размер 16 KB против 80–100 MB, старт в 631 µs против 15–37 ms.

Lambda

На AWS Lambda Porffor показал:

• Node (baseline): до 300 ms холодного старта.
• LLRT: ~3× быстрее Node, но дороже из-за отсутствия managed runtime.
• Porffor: ~12× быстрее Node и ~4× быстрее LLRT, при этом дешевле даже с учётом «managed runtime» Node.

P99 Porffor быстрее P50 у конкурентов.

Итог

Porffor ещё pre-alpha: поддержка JS ≈60 %, нет I/O и Node-совместимости. Подходит для маленьких лямбд без Node-API.
Код и данные бенчмарков: GitHub.

• Porffor — это AOT-компилятор TS/JS → WASM → C, дающий 10× прирост к Node и почти нулевой cold-start, но пока без GC и лишь частично покрывает спецификацию.
• Критики считают сравнения преждевременными: «быстрее» легко, пока не реализуешь 100 % фич (пример Biome и type-aware линтинг).
• Пользователи Lambda хвалят esbuild и не чувствуют проблем с холодным стартом, но ждут официальный WASM-рантайм от AWS.
• Сравнения с GraalVM: если доведут до продакшена, можно будет делать микро-CLI и контейнеры из JS.
• Сообщество в восторге от скорости, но скептически смотрит на необходимость повторить все API Node и квирки JS.

Двухуровневая модель

Основной агент ведёт диалог, помнит контекст, раздаёт задачи.
Под-агенты — чистые функции: получили вход, вернули результат, забыли всё.
Больше двух уровней — лишние точки отказа.

Под-агенты без состояния

Каждый вызов — как вызов функции:

• одинаковый вход → одинаковый выход
• легко кешировать, тестировать, запускать параллельно
  Пример сообщения:

{"task": "sentiment", "data": [...], "constraints": {"timeout": 5}}

Разбиение задач

• Вертикальное: последовательные шаги (сбор → извлечение → сравнение).
• Горизонтальное: параллельные ветки (исследовать 5 конкурентов одновременно).
  Смешиваем: сначала параллельная категоризация фидбека, потом последовательная приоритизация.

Протокол общения

Каждая команда содержит:

• цель, входные данные, ограничения, формат вывода.
  Ответ: status, result, confidence, processing_time.
  Болтовни и «помни, что мы обсуждали» — нет.

Специализация агентов

• Research — поиск по базе фидбека.
• Analysis — извлечение тем и настроений.
• Summary — генерация отчётов и changelog.
  Один агент = одна чёткая функция.

Оркестрация

• Round-robin — когда порядок важен.
• Priority queue — сначала критичные фидбеки.
• Fan-out/fan-in — параллельные под-агенты, потом сбор результатов.
  Состояние хранит только основной агент; под-агенты не знают о существовании друг друга.

Управление контекстом

• Сжатие: оставляем только релевантные куски.
• Слайды: отправляем под-агенту только нужную подборку.
• Версионирование: каждый результат имеет id, чтобы легко откатиться.

Обработка ошибок

• Повторы с экспоненциальной задержкой (до 3 раз).
• Fallback-агенты: если «анализатор» упал, включаем «резервный».
• Circuit breaker: после N ошибок отключаем агента и пишем алерт.

Производительность

• Кешируем по хешу запроса.
• Параллельные вызовы без блокировок.
• Пакетная обработка: отправляем 50 фидбеков за раз, а не по одному.

Мониторинг

Отслеживаем:

• latency под-агентов,
• точность (сравниваем с разметкой),
• частота ошибок,
• объём контекста (токенов).
  Всё пишем в Prometheus + Grafana.

Уроки из продакшена

• Начинайте с 2–3 под-агентов, добавляйте постепенно.
• Пишите юнит-тесты для каждого под-агента.
• Не давайте агентам доступ к внешним API без rate-limit.
• Держите промпты в git; версионируйте как код.

Принципы

1. Простота > масштаб.
2. Чистые функции > разделяемое состояние.
3. Структурированные сообщения > свободный текст.
4. Мониторинг с первого дня > дебаг в проде.

Частые ошибки

• «Умные» под-агенты с памятью → гонки и непредсказуемость.
• Слишком большой контекст → таймауты и лишние токены.
• Отсутствие таймаутов → зависшие цепочки.
• Игнорирование кеширования → лишние $$$ на API.

Как начать

1. Определите 1–2 ключевые задачи (например, «суммаризировать фидбек»).
2. Создайте под-агентов: research, summarize.
3. Напишите структурированные схемы входа/выхода.
4. Покройте тестами, добавьте метрики.
5. Подключите к реальному потоку данных и наблюдайте.

• Автор делится опытом построения практичных «агентов» как чистых функций без состояния и истории разговоров, что экономит токены и упрощает отладку.
• Поддержка: дешёвые/локальные модели на 75 % задач, жёсткое разбиение на под-агентов, явное описание шагов вместо «умных» решений.
• Критика: часть читателей считает описанное не настоящим агентством, а обычным workflow с LLM-вызовами; стиль текста вызывает раздражение как «AI-generated».
• Практические инструменты: Claude Code (файлы .claude/agents), AWS Lambda + Step Functions, Spring AI, кеширование промптов.
• Сообщество обсуждает, где грань между «агентом» и «инструментом», просит примеров и данных, а также делится ссылкой на оригинальный пост Anthropic.