Initial commit: LangChain evolution tutorial deck (132 slides)

- Cover, TOC, 5 dividers, 3 recap slides
- 5 sections (chains, langgraph, deepagents, openswe, ecosystem)
- design-system.js with theme tokens + 9 helper functions
- research/: timeline + sources + per-tech notes
- final-compile.js + merge.js for rebuild pipeline
- output/: langchain-evolution.pptx (2.3 MB) + langchain-evolution.pdf (1.1 MB) + 7 sample previews

research/per-tech/chains.md

@@ -0,0 +1,296 @@
+# LangChain (≥ 1.0)
+
+## Что это в одном абзаце
+
+LangChain — это Python-фреймворк для сборки LLM-приложений и агентов. С версии 1.0 (релиз 22 октября 2025) он позиционируется как «самый быстрый способ собрать агента с любым провайдером моделей», построенный поверх LangGraph-рантайма. До 1.0 фреймворк был известен как «монолит с LCEL» — теперь же фокус сместился на единый `create_agent` и middleware-систему; вся устаревшая функциональность (LLMChain, RetrievalQA, ConversationalRetrievalQA, legacy AgentExecutor) переехала в отдельный пакет `langchain-classic`.
+
+**Метаданные на дату snapshot 2026-06-22:**
+- GitHub stars: ~140k
+- Latest stable (Python): `langchain` 1.3.10 / `langchain-core` 1.4.8 (от 18.06.2026)
+- License: MIT
+- JS-аналог: `langchain` (npm `@langchain/langchain`)
+
+**Источники:**
+- README `github.com/langchain-ai/langchain`
+- https://changelog.langchain.com/announcements/langchain-1-0-now-generally-available
+- https://docs.langchain.com/oss/python/releases/langchain-v1
+
+---
+
+## Ключевые API (≥ 1.0)
+
+### Импорты верхнего уровня
+
+```python
+from langchain.chat_models import init_chat_model
+from langchain.agents import create_agent
+from langchain.agents.middleware import (
+    HumanInTheLoopMiddleware,
+    SummarizationMiddleware,
+    PIIRedactionMiddleware,
+)
+from langchain.tools import tool
+```
+
+### Создание модели
+
+```python
+# Универсальный инициализатор — один интерфейс для всех провайдеров
+model = init_chat_model("openai:gpt-4.1")
+model = init_chat_model("anthropic:claude-3-7-sonnet-latest")
+model = init_chat_model("google_vertexai:gemini-2.0-flash")
+```
+
+### Создание агента (новый create_agent)
+
+```python
+from langchain.agents import create_agent
+
+agent = create_agent(
+    model="openai:gpt-4.1",
+    tools=[get_weather],
+    system_prompt="You are a helpful assistant.",
+)
+result = agent.invoke({"messages": [{"role": "user", "content": "weather in NYC?"}]})
+```
+
+### Structured output
+
+```python
+from pydantic import BaseModel
+
+class Weather(BaseModel):
+    city: str
+    temperature_c: float
+
+model_with_struct = model.with_structured_output(Weather)
+```
+
+### Инструменты
+
+```python
+from langchain.tools import tool
+
+@tool
+def get_weather(city: str) -> str:
+    """Get the weather for a given city."""
+    return f"Sunny, 22°C in {city}"
+```
+
+### Middleware (новая система v1.0)
+
+```python
+from langchain.agents.middleware import HumanInTheLoopMiddleware, PIIRedactionMiddleware
+
+agent = create_agent(
+    model=model,
+    tools=[read_file, write_file],
+    middleware=[
+        HumanInTheLoopMiddleware(interrupt_on={"write_file": True}),
+        PIIRedactionMiddleware(redact_emails=True),
+    ],
+)
+```
+
+### Messages (стандартизированные content blocks)
+
+```python
+from langchain.messages import HumanMessage, AIMessage, SystemMessage
+
+msg = HumanMessage(content="Hello")
+response = model.invoke([msg])
+# response.content может содержать reasoning traces, citations, tool_call блоки
+```
+
+---
+
+## Что нового в 1.0
+
+1. **create_agent abstraction** — единая точка входа для всех агентов. Заменил многообразие legacy `create_react_agent`, `create_openai_functions_agent`, `create_structured_chat_agent`. Построен на LangGraph-runtime.
+2. **Middleware system** — hooks до/после model call, до/после tool call. Built-in: HumanInTheLoop, Summarization, PIIRedaction. Custom middleware — first-class.
+3. **Improved structured output** — интегрирован в основной цикл, без extra LLM-вызовов. Поддержка tool calling и provider-native.
+4. **Standard content blocks** — провайдер-агностичный формат для reasoning traces, citations, server-side tool calls.
+5. **Reduced surface area** — `langchain-classic` забрал все chains/agentsExecutor-legacy, оставив минимальное API.
+6. **Stability promise** — semver-обязательство: до 2.0 не будет breaking changes.
+7. **init_chat_model универсальный** — один инициализатор для всех провайдеров (был `ChatOpenAI`, `ChatAnthropic`, `ChatGoogleGenerativeAI` отдельно).
+
+---
+
+## Что нужно раскрыть в презентации
+
+- **LCEL (LangChain Expression Language)** — хотя 1.0 сместил фокус, LCEL остаётся основой для неагентных цепочек (`prompt | model | parser`).
+- **create_agent vs LCEL** — когда что: agent для циклов с инструментами, LCEL для линейных pipeline-ов.
+- **Middleware-система** — триггерит HITL, summarization, PII-regex; где их подключать.
+- **Standard content blocks** — почему важно для multi-provider совместимости.
+- **Миграция с 0.x** — что ушло в `langchain-classic`, что переименовано (`LLMChain` → `langchain-classic`).
+- **init_chat_model** — единая фабрика моделей.
+- **Интеграции** — `langchain-openai`, `langchain-anthropic`, `langchain-google`, `langchain-tavily`, etc. ~700+ community пакетов.
+
+---
+
+## 7 рабочих примеров кода Python (≥ 1.0)
+
+### 1. Hello world (init_chat_model)
+
+```python
+from langchain.chat_models import init_chat_model
+
+model = init_chat_model("openai:gpt-4.1-mini")
+result = model.invoke("Say hello in one sentence")
+print(result.content)
+```
+
+### 2. LCEL-цепочка (промпт → модель → парсер)
+
+```python
+from langchain.chat_models import init_chat_model
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+
+model = init_chat_model("openai:gpt-4.1-mini")
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "Translate to French."),
+    ("human", "{text}"),
+])
+chain = prompt | model | StrOutputParser()
+print(chain.invoke({"text": "Hello world"}))
+```
+
+### 3. create_agent с одним инструментом
+
+```python
+from langchain.agents import create_agent
+from langchain.tools import tool
+
+@tool
+def get_weather(city: str) -> str:
+    """Get weather for a city."""
+    return f"Sunny, 22°C in {city}"
+
+agent = create_agent(
+    model="openai:gpt-4.1",
+    tools=[get_weather],
+    system_prompt="You are a weather assistant.",
+)
+result = agent.invoke({"messages": [{"role": "user", "content": "weather in Paris?"}]})
+print(result["messages"][-1].content)
+```
+
+### 4. Structured output
+
+```python
+from langchain.chat_models import init_chat_model
+from pydantic import BaseModel
+
+class MovieReview(BaseModel):
+    title: str
+    rating: int  # 1..10
+    summary: str
+
+model = init_chat_model("openai:gpt-4.1-mini")
+reviewer = model.with_structured_output(MovieReview)
+result = reviewer.invoke("Review the movie Inception in one sentence.")
+print(result.title, result.rating, result.summary)
+```
+
+### 5. Middleware: HITL
+
+```python
+from langchain.agents import create_agent
+from langchain.agents.middleware import HumanInTheLoopMiddleware
+from langchain.tools import tool
+
+@tool
+def send_email(to: str, body: str) -> str:
+    """Send an email."""
+    return f"sent to {to}"
+
+agent = create_agent(
+    model="openai:gpt-4.1",
+    tools=[send_email],
+    middleware=[HumanInTheLoopMiddleware(interrupt_on={"send_email": True})],
+)
+result = agent.invoke({"messages": [{"role": "user", "content": "email alice@x.com"}]})
+```
+
+### 6. Middleware: PII-редакция
+
+```python
+from langchain.agents import create_agent
+from langchain.agents.middleware import PIIRedactionMiddleware
+from langchain.tools import tool
+
+@tool
+def echo(text: str) -> str:
+    """Echo back the text."""
+    return text
+
+agent = create_agent(
+    model="openai:gpt-4.1-mini",
+    tools=[echo],
+    middleware=[PIIRedactionMiddleware(redact_emails=True, redact_phones=True)],
+)
+result = agent.invoke({"messages": [{"role": "user", "content": "ping me at john@example.com"}]})
+```
+
+### 7. Streaming
+
+```python
+from langchain.chat_models import init_chat_model
+
+model = init_chat_model("openai:gpt-4.1-mini")
+for chunk in model.stream("Write a haiku about Python"):
+    print(chunk.content, end="", flush=True)
+```
+
+---
+
+## TypeScript-аналог
+
+Все примеры выше имеют прямой аналог в `@langchain/langchain` (npm):
+
+```typescript
+import { initChatModel } from "langchain/chat_models/universal";
+import { createAgent } from "langchain/agents";
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+
+const getWeather = tool(
+  async ({ city }) => `Sunny, 22°C in ${city}`,
+  { name: "get_weather", description: "Get weather", schema: z.object({ city: z.string() }) }
+);
+
+const model = await initChatModel("openai:gpt-4.1");
+const agent = createAgent({ model, tools: [getWeather] });
+const result = await agent.invoke({ messages: [{ role: "user", content: "weather in Paris?" }] });
+```
+
+**Где нет аналога:** legacy chains (`langchain-classic`) в JS пока имеет меньше покрытия, чем Python. На практике миграция на `create_agent` рекомендована в обоих языках.
+
+---
+
+## Плюсы и минусы текущей версии (1.x)
+
+### Плюсы
+- **Семантическая стабильность** — обязательство не ломать API до 2.0.
+- **Единая точка входа** — `create_agent` вместо зоопарка agent-типов.
+- **Middleware-система** — clean separation cross-cutting concerns (HITL, PII, summarization).
+- **init_chat_model** — переключение провайдера без рефакторинга.
+- **LangGraph-runtime под капотом** — durable execution, checkpointing бесплатно.
+- **~700+ интеграций** — community-пакеты `langchain-*`.
+
+### Минусы
+- **Кривая обучения для middleware** — концепция `before_model / after_model` hooks требует привычки.
+- **Часть экосистемы в `langchain-classic`** — много Stack Overflow-ответов по старому API, миграционная боль.
+- **Абстракция скрывает LangGraph** — если нужен fine-grained контроль, приходится «проваливаться» в LangGraph.
+- **Раздутые community-пакеты** — `langchain-community` исторически критиковали за bloated dependencies (но в 1.0 core остался lean).
+- **Bundled-version зависимости** — `langchain-openai` / `langchain-anthropic` / etc. имеют свои минорные циклы, нужно явно указывать версии.
+
+---
+
+## Заметки для презентации
+
+- В 1.0 главный фокус: **agents, not chains**. Если нужно объяснить разницу — показать, как `LLMChain` + `AgentExecutor` объединились в `create_agent`.
+- Подчеркнуть, что **middleware** — это новая killer-фича v1.0 (в 0.x приходилось писать custom callbacks).
+- Чётко сказать: **до 2.0 breaking changes не будет** — это продакшен-ready commitment.
+- Если рассказывать про миграцию — упомянуть `langchain-classic` как «battery-included обратная совместимость».

research/per-tech/deepagents.md

@@ -0,0 +1,328 @@
+# Deep Agents
+
+## Что это в одном абзаце
+
+Deep Agents — это Python-библиотека LangChain Inc., позиционируемая как «batteries-included agent harness». Построена поверх LangGraph (граф-рантайм) и `langchain.agents.create_agent` (минимальный harness от LangChain 1.0). Deep Agents добавляет opinionated defaults: встроенный planning tool, pluggable filesystem backend, subagent-ы для изоляции контекста, persistent memory через `Store`, human-in-the-loop middleware. Вдохновлена Claude Code, Deep Research и Manus — то есть это попытка формализовать то, что делает Claude Code, в виде переиспользуемой библиотеки. **Важно: на дату snapshot 2026-06-22 формального major 1.0 для пакета не выпущено — последняя стабильная версия `deepagents==0.6.11`**, хотя README и блог-посты уже описывают архитектуру как «1.0-ready».
+
+**Метаданные на дату snapshot 2026-06-22:**
+- GitHub stars: ~24.9k
+- Latest stable (Python): `deepagents==0.6.11` (от 18.06.2026)
+- License: MIT
+- JS-аналог: `deepagents` (npm, репо `langchain-ai/deepagentsjs`)
+
+**Источники:**
+- README `github.com/langchain-ai/deepagents`
+- https://docs.langchain.com/oss/python/deepagents/overview
+- https://www.langchain.com/blog/introducing-deepagents-cli
+- https://medium.com/data-science-collective/building-deep-agents-with-langchain-1-0s-middleware-architecture-7fdbb3e47123
+
+---
+
+## Ключевые API (≥ 0.6.x)
+
+### Импорты верхнего уровня
+
+```python
+from deepagents import create_deep_agent
+from deepagents.middleware import SubAgentMiddleware
+from deepagents.backends import FilesystemBackend, SandboxBackend
+```
+
+### Минимальный агент
+
+```python
+from deepagents import create_deep_agent
+
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[my_custom_tool],
+    system_prompt="You are a research assistant.",
+)
+result = agent.invoke({"messages": "Research LangGraph and write a summary"})
+```
+
+### Subagents (делегирование в изолированный контекст)
+
+```python
+from deepagents import create_deep_agent
+
+research_agent = {
+    "name": "research",
+    "description": "Does deep web research",
+    "system_prompt": "You are a research specialist.",
+    "tools": [web_search],
+}
+
+writing_agent = {
+    "name": "writer",
+    "description": "Writes polished reports",
+    "system_prompt": "You are a writing specialist.",
+    "tools": [],
+}
+
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[],
+    subagents=[research_agent, writing_agent],
+)
+# Main agent может вызывать subagents через `task` tool
+```
+
+### Filesystem backend
+
+```python
+from deepagents.backends import FilesystemBackend
+
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[],
+    backend=FilesystemBackend(root_dir="./workspace"),
+)
+# Встроенные tools: read_file, write_file, edit_file, ls, glob, grep
+```
+
+### Sandbox backend (для удалённого выполнения)
+
+```python
+from deepagents.backends import SandboxBackend
+
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[],
+    backend=SandboxBackend(provider="daytona", api_key="..."),
+)
+```
+
+### Custom middleware (через LangChain 1.0 middleware)
+
+```python
+from langchain.agents.middleware import HumanInTheLoopMiddleware
+from deepagents import create_deep_agent
+
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[],
+    middleware=[HumanInTheLoopMiddleware(interrupt_on={"bash": True})],
+)
+```
+
+### Persistent memory через Store
+
+```python
+from langgraph.store.memory import InMemoryStore
+
+store = InMemoryStore()
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[],
+    store=store,
+)
+# Cross-session memory через `store` namespace
+```
+
+### Skills (reusable behaviors)
+
+```python
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[],
+    skills=[
+        {"name": "code_review", "path": "./skills/code_review.md"},
+        {"name": "deploy", "path": "./skills/deploy.md"},
+    ],
+)
+```
+
+---
+
+## Что нового
+
+### Архитектурные изменения по сравнению с просто `create_agent`
+- **Planning tool `write_todos`** — встроенный, не надо писать свой.
+- **Filesystem tools** — `read_file` / `write_file` / `edit_file` / `ls` / `glob` / `grep` — стандартный набор.
+- **Subagent tool `task`** — вызов child-агента с изолированным контекстом.
+- **Context management** — суммаризация длинных тредов, offloading tool outputs на диск.
+- **Shell access** — `bash` tool для выполнения команд.
+- **Pluggable backends** — local filesystem или remote sandbox.
+- **Persistent memory** — cross-session recall через Store.
+- **HITL middleware** — approve/edit/reject tool calls до их исполнения.
+- **Skills system** — переиспользуемые поведения, загружаемые on-demand.
+
+### Что нового в 0.6.x (последняя ветка на snapshot)
+- Полная интеграция с LangChain 1.0 middleware-системой.
+- Поддержка `Send` API для параллельных subagent-вызовов.
+- Стабилизация плагинной системы backends.
+- Улучшения в skills: версионирование и hot-reload.
+
+---
+
+## Что нужно раскрыть в презентации
+
+- **Зачем Deep Agents поверх LangChain и LangGraph?** — opinionated defaults, батарейки в комплекте.
+- **`task` tool и subagent isolation** — почему subagent-ы получают свой контекст, а не общий.
+- **`write_todos` planning** — как агент декомпозирует задачу.
+- **Filesystem как context overflow protection** — большие результаты offload-ятся на диск.
+- **Sandbox backends** — Daytona, Modal, Runloop, LangSmith — паттерн «isolate first, full permissions inside».
+- **Skills vs Tools** — skills это «знания» (markdown-инструкции), tools это «действия».
+- **Security model** — «trust the LLM», границы только на уровне tool / sandbox.
+- **Сравнение с Claude Code** — попытка воспроизвести паттерн, но в виде библиотеки.
+
+---
+
+## 7 рабочих примеров кода Python
+
+### 1. Hello world
+
+```python
+from deepagents import create_deep_agent
+
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[],
+    system_prompt="You are a helpful assistant.",
+)
+result = agent.invoke({"messages": "Write a haiku about Python"})
+```
+
+### 2. С кастомным tool
+
+```python
+from langchain.tools import tool
+from deepagents import create_deep_agent
+
+@tool
+def get_stock_price(ticker: str) -> str:
+    """Return current stock price."""
+    return f"${ticker}: 123.45 USD"
+
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[get_stock_price],
+)
+result = agent.invoke({"messages": "What's the price of AAPL?"})
+```
+
+### 3. Subagent для делегирования
+
+```python
+from deepagents import create_deep_agent
+
+researcher = {
+    "name": "researcher",
+    "description": "Researches topics on the web",
+    "system_prompt": "You do thorough research.",
+    "tools": [],
+}
+
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[],
+    subagents=[researcher],
+)
+result = agent.invoke({"messages": "Research quantum computing and write a 200-word summary"})
+```
+
+### 4. Filesystem backend
+
+```python
+from deepagents import create_deep_agent
+from deepagents.backends import FilesystemBackend
+
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[],
+    backend=FilesystemBackend(root_dir="./workspace"),
+)
+result = agent.invoke({"messages": "Create a file notes.md with Python best practices"})
+```
+
+### 5. HITL middleware
+
+```python
+from langchain.agents.middleware import HumanInTheLoopMiddleware
+from deepagents import create_deep_agent
+
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[],
+    middleware=[HumanInTheLoopMiddleware(interrupt_on={"bash": True, "write_file": True})],
+)
+# При попытке выполнить bash или write_file — interrupt, ждёт человека
+```
+
+### 6. Persistent memory
+
+```python
+from langgraph.store.memory import InMemoryStore
+from deepagents import create_deep_agent
+
+store = InMemoryStore()
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[],
+    store=store,
+    system_prompt="Remember user preferences.",
+)
+# Store put/get вызываются изнутри нод агента
+```
+
+### 7. Skills (загрузка поведений)
+
+```python
+from deepagents import create_deep_agent
+
+agent = create_deep_agent(
+    model="openai:gpt-4.1",
+    tools=[],
+    skills=["./skills/code_review.md", "./skills/deploy.md"],
+)
+# Агент загрузит skill когда посчитает нужным
+```
+
+---
+
+## TypeScript-аналог
+
+```typescript
+import { createDeepAgent } from "deepagents";
+
+const agent = await createDeepAgent({
+  model: "openai:gpt-4.1",
+  tools: [],
+  systemPrompt: "You are a helpful assistant.",
+});
+
+const result = await agent.invoke({ messages: "Write a haiku" });
+```
+
+JS-версия (`langchain-ai/deepagentsjs`) покрывает базовый API, но filesystem/sandbox backend-ы и subagents-конфигурация могут отставать от Python.
+
+---
+
+## Плюсы и минусы текущей версии (0.6.x)
+
+### Плюсы
+- **Batteries included** — planning + filesystem + subagents + skills из коробки.
+- **Меньше boilerplate** чем LangGraph, opinionated defaults.
+- **Плагинные backends** — local / Daytona / Modal / Runloop / LangSmith.
+- **Skills system** — переиспользуемые поведения on-demand.
+- **Open source + MIT** — можно форкать и адаптировать.
+- **Хорошо документированный security model** — «trust the LLM, restrict at tool level».
+
+### Минусы
+- **Major 1.0 не зафиксирован** — нумерация 0.6.x может означать breaking changes в minor.
+- **Opinionated** — если дефолты не подходят, override-ы могут быть сложными.
+- **Sandbox providers требуют внешние аккаунты** — Daytona / Modal / Runloop — это SaaS.
+- **Skills — новый концепт** — экосистема готовых skills ещё формируется.
+- **Документация по middleware+skills** — некоторые edge cases не покрыты.
+- **Performance overhead** — плагинная архитектура добавляет latency.
+
+---
+
+## Заметки для презентации
+
+- Подчеркнуть иерархию: **LangGraph = runtime, LangChain.create_agent = thin harness, Deep Agents = opinionated harness**.
+- Использовать аналогию: **Deep Agents = "Django поверх raw WSGI"**, даёт быстрый старт, но с conventions.
+- Показать, как `task` tool позволяет main agent делегировать без загрязнения своего контекста.
+- Объяснить, почему именно Claude Code вдохновил — это конкурентный аргумент: «посмотрите, что сделал Anthropic, мы сделали то же в open source».
+- Если рассказывать про Open SWE — это **реальный пример использования Deep Agents как harness-а** для кодинг-агента.

research/per-tech/langgraph.md

@@ -0,0 +1,328 @@
+# LangGraph (≥ 1.0)
+
+## Что это в одном абзаце
+
+LangGraph — это низкоуровневый оркестрационный фреймворк LangChain Inc. для построения долгоживущих stateful-агентов. В отличие от LangChain (high-level `create_agent`), LangGraph даёт явный контроль над формой графа: узлы (`add_node`), рёбра (`add_edge`), условные переходы (`add_conditional_edges`), checkpointing, human-in-the-loop через `interrupt`, stream-режимы. С версии 1.0 (релиз 22 октября 2025) LangGraph — это production-ready durable runtime: состояние графа персистится автоматически, при падении сервера посреди long-running workflow он восстанавливается ровно с точки остановки. Вдохновлён Pregel и Apache Beam, public interface похож на NetworkX.
+
+**Метаданные на дату snapshot 2026-06-22:**
+- GitHub stars: ~35.4k
+- Latest stable (Python): `langgraph==1.2.6` (от 18.06.2026)
+- License: MIT
+- JS-аналог: `@langchain/langgraph` (npm)
+
+**Источники:**
+- README `github.com/langchain-ai/langgraph`
+- https://changelog.langchain.com/announcements/langgraph-1-0-is-now-generally-available
+- https://blog.langchain.com/langchain-langgraph-1dot0
+- https://blog.langchain.com/fault-tolerance-in-langgraph
+
+---
+
+## Ключевые API (≥ 1.0)
+
+### Импорты верхнего уровня
+
+```python
+from langgraph.graph import StateGraph, START, END
+from langgraph.checkpoint.memory import InMemorySaver
+from langgraph.checkpoint.sqlite import SqliteSaver
+from langgraph.checkpoint.postgres import PostgresSaver
+from langgraph.types import Command, interrupt, Send
+```
+
+### Базовый граф с состоянием
+
+```python
+from typing import Annotated
+from typing_extensions import TypedDict
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+from langgraph.checkpoint.memory import InMemorySaver
+
+class State(TypedDict):
+    messages: Annotated[list, add_messages]
+
+def node_a(state: State):
+    return {"messages": [{"role": "assistant", "content": "hi"}]}
+
+builder = StateGraph(State)
+builder.add_node("a", node_a)
+builder.add_edge(START, "a")
+builder.add_edge("a", END)
+
+checkpointer = InMemorySaver()
+graph = builder.compile(checkpointer=checkpointer)
+
+config = {"configurable": {"thread_id": "1"}}
+result = graph.invoke({"messages": []}, config=config)
+```
+
+### Условные рёбра
+
+```python
+def route(state: State) -> str:
+    return "tool_node" if state.get("needs_tool") else END
+
+builder.add_conditional_edges("agent", route, {
+    "tool_node": "tool_node",
+    END: END,
+})
+```
+
+### Human-in-the-loop через interrupt
+
+```python
+from langgraph.types import interrupt
+
+def approval_node(state: State):
+    decision = interrupt({"question": "Approve?", "data": state["messages"]})
+    return {"approved": decision == "yes"}
+```
+
+### Subgraphs
+
+```python
+sub_builder = StateGraph(SubState)
+sub_builder.add_node("x", x_node)
+sub_graph = sub_builder.compile()
+
+# В родительском графе
+parent_builder.add_node("sub", sub_graph)
+```
+
+### Store (долгосрочная память)
+
+```python
+from langgraph.store.memory import InMemoryStore
+
+store = InMemoryStore()
+graph = builder.compile(checkpointer=checkpointer, store=store)
+
+# Внутри ноды
+store.put(("user_123", "prefs"), "key", {"value": "dark"})
+```
+
+### Streaming
+
+```python
+for mode, chunk in graph.stream({"messages": []}, config, stream_mode=["values", "updates"]):
+    print(mode, chunk)
+```
+
+---
+
+## Что нового в 1.0
+
+1. **Durable execution (стабилизировано)** — автоматическая персистенция state, восстановление ровно с точки падения. Без своего DB-кода.
+2. **Built-in persistence как стабильное API** — `checkpointer` теперь контракт, а не фича; Postgres / SQLite / memory — все first-class.
+3. **Human-in-the-loop first-class** — `interrupt()` стал стабильным API, поддерживает multi-day approval workflows.
+4. **Graph-based execution как production pattern** — смесь детерминированных узлов и агентных.
+5. **Deprecation:** `langgraph.prebuilt.create_react_agent` → перенесён в `langchain.agents.create_agent` (LangChain 1.0).
+6. **API stability promise** — без breaking changes до 2.0.
+7. **Middleware hooks (в 1.2)** — fault tolerance: retries / timeouts / error handlers.
+
+---
+
+## Что нужно раскрыть в презентации
+
+- **State, Channels, Reducers** — что такое `Annotated[list, add_messages]` и зачем нужен reducer.
+- **Checkpointing** — `InMemorySaver` для dev, `PostgresSaver` для prod. Что хранится в `StateSnapshot`.
+- **Threads** — `configurable.thread_id` как ключ сессии.
+- **Human-in-the-loop через `interrupt`** — не через callback, а через настоящий graph pause.
+- **Subgraphs** — композитность графов, parent может заходить в subgraph целиком.
+- **Send / Map-reduce** — параллельные ветки графа.
+- **Streaming modes** — `values` / `updates` / `events` / `messages` / `custom`.
+- **Store vs Checkpointer** — checkpoint для сессии, store для cross-session долгосрочной памяти.
+- **Pregel / Beam inspiration** — почему именно «graph», а не «chain».
+
+---
+
+## 8 рабочих примеров кода Python (≥ 1.0)
+
+### 1. StateGraph с message reducer
+
+```python
+from typing import Annotated
+from typing_extensions import TypedDict
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+
+class State(TypedDict):
+    messages: Annotated[list, add_messages]
+
+def echo(state: State):
+    last = state["messages"][-1]
+    return {"messages": [{"role": "assistant", "content": f"echo: {last.content}"}]}
+
+g = StateGraph(State)
+g.add_node("echo", echo)
+g.add_edge(START, "echo")
+g.add_edge("echo", END)
+app = g.compile()
+print(app.invoke({"messages": [{"role": "user", "content": "hi"}]}))
+```
+
+### 2. Checkpointing + thread_id
+
+```python
+from langgraph.checkpoint.memory import InMemorySaver
+
+checkpointer = InMemorySaver()
+app = g.compile(checkpointer=checkpointer)
+
+cfg = {"configurable": {"thread_id": "user-1"}}
+app.invoke({"messages": [{"role": "user", "content": "hi"}]}, cfg)
+app.invoke({"messages": [{"role": "user", "content": "again"}]}, cfg)
+# state["messages"] содержит оба сообщения — thread persistence работает
+```
+
+### 3. Conditional edges (роутинг по содержимому)
+
+```python
+def route(state: State) -> str:
+    if "tool" in state["messages"][-1].content:
+        return "tool_node"
+    return END
+
+builder.add_conditional_edges("agent", route, {"tool_node": "tool_node", END: END})
+```
+
+### 4. Human-in-the-loop через interrupt
+
+```python
+from langgraph.types import interrupt
+
+def approval(state: State):
+    answer = interrupt({"prompt": "Approve?", "context": state})
+    return {"approved": answer}
+
+builder.add_node("approval", approval)
+builder.add_edge(START, "approval")
+app = builder.compile(checkpointer=InMemorySaver())
+
+cfg = {"configurable": {"thread_id": "t1"}}
+# Первый вызов упадёт в interrupt
+try:
+    app.invoke({}, cfg)
+except Exception:
+    pass
+
+# Возобновляем с ответом пользователя
+from langgraph.types import Command
+result = app.invoke(Command(resume="yes"), cfg)
+```
+
+### 5. Send / Map-reduce (параллельные ветки)
+
+```python
+from langgraph.types import Send
+
+def fanout(state: State):
+    return [Send("process", {"item": i}) for i in state["items"]]
+
+def process(state: dict):
+    return {"results": [state["item"] * 2]}
+
+builder.add_conditional_edges("start", fanout)
+builder.add_node("process", process)
+```
+
+### 6. Subgraphs
+
+```python
+sub = StateGraph(SubState)
+sub.add_node("inner", inner_fn)
+sub.add_edge(START, "inner")
+sub_compiled = sub.compile()
+
+parent = StateGraph(ParentState)
+parent.add_node("sub_block", sub_compiled)
+parent.add_edge(START, "sub_block")
+```
+
+### 7. Store для долгосрочной памяти
+
+```python
+from langgraph.store.memory import InMemoryStore
+
+store = InMemoryStore()
+app = builder.compile(checkpointer=InMemorySaver(), store=store)
+
+def remember(state: State):
+    store.put(("user-1", "facts"), "name", {"value": "Alice"})
+    return {}
+
+# В другом turn:
+def recall(state: State):
+    fact = store.get(("user-1", "facts"), "name")
+    return {"user_name": fact.value["value"]}
+```
+
+### 8. Streaming
+
+```python
+for event in app.stream({"messages": [{"role": "user", "content": "hi"}]}, stream_mode="values"):
+    print(event)
+
+# Кастомный streaming через writer
+def node(state: State):
+    writer = get_stream_writer()
+    writer({"progress": "50%"})
+    return {}
+```
+
+---
+
+## TypeScript-аналог
+
+Все примеры имеют аналог в `@langchain/langgraph`:
+
+```typescript
+import { StateGraph, START, END } from "@langchain/langgraph";
+import { MemorySaver } from "@langchain/langgraph-checkpoint";
+import { Annotation, messagesStateReducer } from "@langchain/langgraph";
+
+const State = Annotation.Root({
+  messages: Annotation({ reducer: messagesStateReducer, default: () => [] }),
+});
+
+const g = new StateGraph(State)
+  .addNode("echo", (s) => ({ messages: [{ role: "assistant", content: "hi" }] }))
+  .addEdge(START, "echo")
+  .addEdge("echo", END);
+
+const app = g.compile({ checkpointer: new MemorySaver() });
+const cfg = { configurable: { thread_id: "t1" } };
+const result = await app.invoke({ messages: [{ role: "user", content: "hi" }] }, cfg);
+```
+
+**Где аналог есть:** весь базовый API (StateGraph, conditional edges, checkpoint, interrupt).
+**Где нет / отличается:** некоторые специфичные savers (PostgresSaver в JS требует отдельного пакета), `Send` API полностью паритетно.
+
+---
+
+## Плюсы и минусы текущей версии (1.x)
+
+### Плюсы
+- **Durable execution из коробки** — killer-фича для long-running агентов.
+- **HITL first-class API** — `interrupt()` вместо костылей с callback-ами.
+- **Гибкость** — можно построить любую топологию графа (циклы, ветки, параллелизм).
+- **Прозрачность** — graph inspection в LangGraph Studio.
+- **Семантическая стабильность** — semver до 2.0.
+
+### Минусы
+- **Кривая обучения** — concepts (channels, reducers, send/receive) требуют времени.
+- **Boilerplate** — базовый граф требует много кода по сравнению с `create_agent`.
+- **Checkpointing требует инфраструктуры** — для prod нужен Postgres, настройка schema.
+- **Stream API многослойный** — `stream_mode` (`values` / `updates` / `events` / `messages` / `debug`) сбивает с толку.
+- **Debugging сложных графов** — без LangSmith Studio тяжело.
+
+---
+
+## Заметки для презентации
+
+- Подчеркнуть: **LangGraph — runtime, не agent-harness**. `create_agent` (LangChain) и `create_deep_agent` (Deep Agents) работают *поверх* LangGraph.
+- Если есть HITL-сценарий — показать `interrupt()` как killer-фичу 1.0.
+- Использовать аналогию: **LangGraph = база данных для состояния агента**, LangChain = ORM поверх.
+- Упомянуть, что LangGraph вдохновлён Pregel (Google) и Apache Beam — это не новость из AI, это паттерн из распределённых систем.
+- В 1.2 — fault tolerance (retries / timeouts / error handlers) — отдельная тема.

research/per-tech/openswe.md

@@ -0,0 +1,321 @@
+# Open SWE
+
+## Что это в одном абзаце
+
+Open SWE — это open-source фреймворк LangChain Inc. для построения **внутренних кодинг-агентов организации**. Анонсирован в августе 2025, стабильная версия репозитория набрала 971+ коммитов и 10k stars к июню 2026. Open SWE — это **не готовое SaaS-решение**, а стартовый шаблон: он скомпонован поверх Deep Agents (а значит поверх LangGraph), поддерживает pluggable sandbox-провайдеры (Modal, Daytona, Runloop, LangSmith), триггеры из Slack / Linear / GitHub, и автоматически создаёт draft PR. Архитектура намеренно воспроизводит паттерны, которые Stripe (Minions), Ramp (Inspect) и Coinbase (Cloudbot) построили как proprietary — Open SWE даёт open-source реализацию «reference architecture» для кастомных внутренних coding agent-ов.
+
+**Метаданные на дату snapshot 2026-06-22:**
+- GitHub stars: ~10k
+- Commits: 971+ (активная разработка)
+- License: MIT
+- JS-аналог: нет (Python-only проект, плюс TypeScript UI в `ui/`)
+- Главный blog-пост: первоначальный анонс — август 2025, переработанная версия — 17 марта 2026
+
+**Источники:**
+- README `github.com/langchain-ai/open-swe` (raw-форма успешно получена)
+- `blog.langchain.com/open-swe-an-open-source-framework-for-internal-coding-agents`
+- https://github.com/langchain-ai/open-swe/blob/main/INSTALLATION.md
+- https://github.com/langchain-ai/open-swe/blob/main/CUSTOMIZATION.md
+
+---
+
+## Ключевые API и архитектурные компоненты
+
+Open SWE — это не библиотека, а **приложение**, состоящее из backend-агента (Python), UI (TypeScript), и набора middleware/интеграций. Поэтому «API» здесь — это точки расширения, через которые организация кастомизирует фреймворк.
+
+### Импорты внутри Open SWE
+
+```python
+from open_swe.agent import create_agent  # точка входа в агент
+from open_swe.middleware import (
+    check_message_queue_before_model,
+    notify_step_limit_reached,
+    open_pr_if_needed,
+    ToolErrorMiddleware,
+)
+from open_swe.sandbox import (
+    SandboxBackend,
+    ModalBackend,
+    DaytonaBackend,
+    RunloopBackend,
+    LangSmithBackend,
+)
+from open_swe.tools import (
+    execute,
+    fetch_url,
+    http_request,
+    linear_comment,
+    slack_thread_reply,
+)
+```
+
+### Основная точка расширения — `create_deep_agent`
+
+```python
+from deepagents import create_deep_agent
+from open_swe.middleware import check_message_queue_before_model
+from open_swe.sandbox import DaytonaBackend
+
+agent = create_deep_agent(
+    model="anthropic:claude-opus-4-6",
+    system_prompt=construct_system_prompt(repo_dir, ...),
+    tools=[
+        execute,
+        fetch_url,
+        http_request,
+        linear_comment,
+        slack_thread_reply,
+    ],
+    backend=DaytonaBackend(api_key="..."),
+    middleware=[
+        ToolErrorMiddleware(),
+        check_message_queue_before_model,
+        open_pr_if_needed,
+    ],
+)
+```
+
+### Sandboxes (pluggable)
+
+```python
+from open_swe.sandbox import DaytonaBackend, ModalBackend, RunloopBackend
+
+backend = DaytonaBackend(api_key="...")
+# или ModalBackend(token_id="...", token_secret="...")
+# или RunloopBackend(api_key="...")
+```
+
+Каждый backend — изолированный Linux-контейнер с полным shell-доступом, клоном репозитория и persistent state для thread-а.
+
+### Triggers (поверхности вызова)
+
+- **Slack** — `@openswe` в любом thread. Поддерживает синтаксис `repo:owner/name`.
+- **Linear** — `@openswe` в комментарии к issue.
+- **GitHub** — `@openswe` в PR-комментарии для авто-ответа на review.
+
+Каждый триггер создаёт deterministic thread_id, чтобы follow-up сообщения маршрутизировались в тот же запущенный агент.
+
+### Built-in tools
+
+| Tool | Назначение |
+|---|---|
+| `execute` | shell-команды в sandbox |
+| `fetch_url` | загрузка web-страниц как markdown |
+| `http_request` | API calls (GET, POST, etc.) |
+| `linear_comment` | комментарии в Linear-тикетах |
+| `slack_thread_reply` | ответы в Slack-тредах |
+| `read_file` / `write_file` / `edit_file` / `ls` / `glob` / `grep` | Deep Agents filesystem tools |
+| `write_todos` | planning tool от Deep Agents |
+| `task` | spawning subagent-ов |
+
+GitHub-операции делаются через `gh` CLI внутри sandbox с `GH_TOKEN=dummy`, авторизация через LangSmith-прокси.
+
+### AGENTS.md конвенция
+
+Если в репозитории есть файл `AGENTS.md` в корне, он автоматически читается из sandbox и инжектится в system prompt. Это «правила команды» — conventions, testing requirements, архитектурные решения.
+
+### Middleware (точки расширения)
+
+```python
+from langchain.agents.middleware import AgentMiddleware
+
+class MyCustomMiddleware(AgentMiddleware):
+    def before_model(self, state, runtime):
+        # модифицировать state перед model call
+        return state
+
+    def after_model(self, state, runtime):
+        # логирование / проверка результата
+        return state
+```
+
+Типичные middleware в Open SWE:
+- `check_message_queue_before_model` — инжектит follow-up сообщения до следующего model call.
+- `notify_step_limit_reached` — после-agent hook для Slack-уведомления, если лимит исчерпан.
+- `open_pr_if_needed` — safety net: коммитит и открывает PR, если агент этого не сделал.
+- `ToolErrorMiddleware` — graceful handling ошибок tool-ов.
+
+### Customization точка: `CUSTOMIZATION.md`
+
+Согласно документации, pluggable компоненты:
+1. **Sandbox provider** — Modal / Daytona / Runloop / LangSmith / свой.
+2. **Model** — любой провайдер через `langchain.chat_models.init_chat_model`.
+3. **Tools** — добавить/удалить через массив `tools`.
+4. **Triggers** — модифицировать Slack / Linear / GitHub интеграции.
+5. **System prompt** — база + логика инкорпорирования AGENTS.md.
+6. **Middleware** — добавить свой для validation / approval / logging.
+
+---
+
+## Что нового в первом релизе
+
+### Оригинальный анонс (август 2025)
+- Multi-agent архитектура: Manager + Planner + Programmer + Reviewer.
+- Single sandbox (Daytona).
+- GitHub Issues + Web UI триггеры.
+
+### Переработанная архитектура (март 2026)
+- Замена multi-agent на единый `create_deep_agent` harness + subagents + middleware.
+- Добавление pluggable sandbox providers (Modal, Runloop, LangSmith).
+- Добавление Slack и Linear триггеров.
+- Subagent-ы через `task` tool от Deep Agents.
+- Middleware-система для deterministic orchestration.
+
+### Ключевой сдвиг
+Open SWE **переехал с multi-agent на single-deep-agent-harness + subagents**. Это консолидация архитектурного паттерна: вместо явных Manager/Planner/Programmer/Reviewer — один главный агент с набором subagent-специализаций и middleware для orchestration. Бенефиты: upgrade path (подтягивать улучшения Deep Agents), меньше кастомного кода, чище orchestration через `Send` API.
+
+---
+
+## Что нужно раскрыть в презентации
+
+- **Почему «внутренний» кодинг-агент, а не IDE-assistant** — модель «colleague, not copilot».
+- **«Trust the LLM» внутри sandbox** — изоляция важнее confirmation prompts.
+- **Pluggable sandboxes** — почему несколько провайдеров и как мигрировать.
+- **AGENTS.md как организационный паттерн** — те же conventions применяются и для AI.
+- **Subagent isolation** — каждый child получает свой контекст.
+- **Middleware для validation** — детерминированные проверки между шагами агента.
+- **Сравнение со Stripe Minions / Ramp Inspect / Coinbase Cloudbot** — почему конвергенция паттернов важна.
+- **Open source как reference architecture** — не finished product, а стартовая точка.
+
+---
+
+## 5 рабочих примеров кода Python
+
+### 1. Минимальный запуск агента Open SWE (из README)
+
+```python
+from deepagents import create_deep_agent
+from open_swe.sandbox import DaytonaBackend
+from open_swe.middleware import check_message_queue_before_model, open_pr_if_needed
+
+agent = create_deep_agent(
+    model="openai:gpt-5.5",
+    system_prompt="You are an internal coding agent.",
+    tools=[],  # будут добавлены built-in
+    backend=DaytonaBackend(api_key="..."),
+    middleware=[check_message_queue_before_model, open_pr_if_needed],
+)
+```
+
+### 2. Кастомный system prompt с инкорпорированием AGENTS.md
+
+```python
+def construct_system_prompt(repo_dir: str, base_prompt: str) -> str:
+    agents_md_path = Path(repo_dir) / "AGENTS.md"
+    extra = ""
+    if agents_md_path.exists():
+        extra = f"\n\nRepository rules:\n{agents_md_path.read_text()}"
+    return base_prompt + extra
+```
+
+### 3. Кастомный middleware для логирования
+
+```python
+from langchain.agents.middleware import AgentMiddleware
+
+class AuditMiddleware(AgentMiddleware):
+    def __init__(self, logger):
+        self.logger = logger
+
+    def after_model(self, state, runtime):
+        self.logger.info(f"model_called_at_step_{state.get('step')}")
+        return state
+```
+
+### 4. Subagent-конфигурация для специализаций
+
+```python
+test_runner = {
+    "name": "test_runner",
+    "description": "Runs project tests and reports results",
+    "system_prompt": "You run tests, parse failures, suggest fixes.",
+    "tools": ["execute", "read_file"],
+}
+
+doc_writer = {
+    "name": "doc_writer",
+    "description": "Updates documentation after code changes",
+    "system_prompt": "You update markdown docs based on code changes.",
+    "tools": ["read_file", "edit_file"],
+}
+
+agent = create_deep_agent(
+    model="anthropic:claude-opus-4-6",
+    tools=[],
+    subagents=[test_runner, doc_writer],
+)
+```
+
+### 5. Кастомный sandbox backend (заглушка)
+
+```python
+from open_swe.sandbox import SandboxBackend
+
+class MyInternalBackend(SandboxBackend):
+    def __init__(self, connection_string: str):
+        self.conn = connection_string
+
+    def execute(self, command: str) -> str:
+        # подключение к внутреннему devbox-пулу
+        return self._run_in_devbox(command)
+
+    def read_file(self, path: str) -> str:
+        return self._fetch_from_devbox(path)
+```
+
+---
+
+## TypeScript
+
+**UI:** репозиторий содержит `ui/` (TypeScript, 26.6% от кода). Это web-приложение для управления: GitHub login, per-user model/profile settings, team defaults, enabled-repo management, chat UI.
+
+```typescript
+// Пример из ui/ (псевдокод, точная структура зависит от версии)
+import { OpenSWEClient } from "@openswe/client";
+
+const client = new OpenSWEClient({
+  langsmithApiKey: process.env.LANGSMITH_API_KEY,
+});
+
+await client.invoke({
+  threadId: "issue-123",
+  prompt: "Fix the bug in src/auth.py",
+  repo: "owner/name",
+});
+```
+
+**Где нет TS-аналога для backend:** Open SWE — это Python-приложение (LangGraph/Deep Agents), TypeScript только в UI-слое.
+
+---
+
+## Плюсы и минусы
+
+### Плюсы
+- **MIT license** — можно форкать и адаптировать.
+- **Pluggable sandbox** — Modal / Daytona / Runloop / LangSmith / свой.
+- **Subagents + middleware** — composable вместо monolithic.
+- **AGENTS.md convention** — переиспользует существующий паттерн документации.
+- **Multiple triggers** — Slack / Linear / GitHub / Web UI.
+- **Built on Deep Agents** — automatic upgrade path для improvements.
+- **Хорошая документация** — INSTALLATION.md и CUSTOMIZATION.md детальные.
+- **Active development** — 971+ коммитов, 10k stars.
+
+### Минусы
+- **Не finished product** — нужно кастомизировать под свою org.
+- **Sandbox costs** — Modal / Daytona / Runloop требуют платных аккаунтов.
+- **Slack / Linear / GitHub интеграции** — нужен OAuth setup для каждого.
+- **Security model «trust the LLM»** — высокие требования к sandbox-изоляции.
+- **Production deployment сложный** — требует LangSmith, GitHub App, sandbox provider, secrets management.
+- **Observability** — нужен Datadog или LangSmith setup.
+- **Документация быстро устаревает** — архитектура переписывалась за 9 месяцев.
+
+---
+
+## Заметки для презентации
+
+- Это **reference architecture, not product**. Подчеркнуть, что каждый компонент заменяем.
+- Использовать аналогию: **Open SWE = «Kubernetes для AI агентов»** — даёт framework, но ожидает ops-работу.
+- Показать, как именно Open SWE воспроизводит паттерны Stripe/Ramp/Coinbase — это главный аргумент «convergence proof».
+- Если есть audience с enterprise-бэкграундом — акцент на **sandbox isolation как security primitive**.
+- Подчеркнуть, что Open SWE **не замена Cursor или Claude Code**, а инфраструктура для «своего Claude Code».
+- Если показывать схему архитектуры — выделить слои: Harness (Deep Agents) → Sandbox (pluggable) → Tools (curated) → Context (AGENTS.md) → Orchestration (subagents + middleware) → Invocation (Slack/Linear/GitHub) → Validation (prompt + middleware).

research/sources.md

@@ -0,0 +1,96 @@
+# Sources
+
+Список всех источников, на которые опирается исследование. Каждый проверен напрямую через `web_search` (matrix MCP) или `webfetch` (raw.githubusercontent.com / blog.langchain.com / changelog.langchain.com / GitHub README).
+
+---
+
+## Официальные анонсы и блоги LangChain
+
+- https://www.langchain.com/blog/langchain-v0-1-0 — пост о LangChain 0.1.0 (январь 2024). Подтверждает разделение на core/community, LCEL.
+- https://www.langchain.com/blog/the-new-langchain-architecture-langchain-core-v0-1-langchain-community-and-a-path-to-langchain-v0-1 — пред-релизный анонс новой архитектуры.
+- https://www.langchain.com/blog/langchain-langchain-1-0-alpha-releases — alpha-релиз LangChain/LangGraph 1.0 (сентябрь 2025).
+- https://www.langchain.com/blog/langchain-langgraph-1dot0 — основной блог-пост о 1.0 обоих фреймворков.
+- https://www.langchain.com/blog/introducing-deepagents-cli — анонс DeepAgents CLI.
+- https://www.langchain.com/blog/open-swe-an-open-source-framework-for-internal-coding-agents — переработанный пост об Open SWE (17 марта 2026, изначальный анонс — август 2025).
+- https://blog.langchain.com/open-swe-an-open-source-framework-for-internal-coding-agents — старая пометка поста, используется как дополнительная ссылка.
+
+## Официальные changelog-анонсы
+
+- https://changelog.langchain.com/announcements/langchain-1-0-now-generally-available — LangChain 1.0 GA (22.10.2025).
+- https://changelog.langchain.com/announcements/langgraph-1-0-is-now-generally-available — LangGraph 1.0 GA (22.10.2025).
+- https://changelog.langchain.com/announcements/langsmith-self-hosted-v0-9 — LangSmith Self-Hosted v0.9 (21.01.2025).
+- https://changelog.langchain.com?categories=cat_ZWTyLBFVqdtSq — категория LangSmith Self-Hosted анонсов.
+
+## GitHub-репозитории
+
+- https://github.com/langchain-ai/langchain — основной репо LangChain (Python). 140k stars. README + releases.
+- https://github.com/langchain-ai/langgraph — репо LangGraph. 35.4k stars.
+- https://github.com/langchain-ai/deepagents — репо Deep Agents. 24.9k stars.
+- https://github.com/langchain-ai/open-swe — репо Open SWE. 10k stars. README + INSTALLATION.md + CUSTOMIZATION.md.
+- https://github.com/langchain-ai/langgraphjs — JS-аналог LangGraph.
+- https://github.com/langchain-ai/langchainjs — JS-аналог LangChain.
+- https://github.com/langchain-ai/langsmith-sdk — Python-клиент LangSmith.
+- https://github.com/langchain-ai/deepagentsjs — JS-аналог Deep Agents.
+- https://github.com/langchain-ai/langchain/releases — релизы langchain (1.3.10 / 1.4.8 на дату snapshot).
+- https://github.com/langchain-ai/langgraph/releases — релизы langgraph (1.2.6 latest).
+- https://github.com/langchain-ai/deepagents/releases — релизы deepagents (0.6.11 latest).
+- https://github.com/langchain-ai/langchain/issues/33933 — issue «ModuleNotFoundError: No module named 'langchain.chains'», объясняет переезд chains в langchain-classic.
+- https://raw.githubusercontent.com/langchain-ai/open-swe/main/README.md — README Open SWE в raw-форме (успешно получен).
+
+## Документация (docs.langchain.com, reference.langchain.com)
+
+- https://docs.langchain.com/oss/python/langchain/overview — обзор LangChain (404/decode error при fetch, использован через search).
+- https://docs.langchain.com/oss/python/langgraph/overview — обзор LangGraph.
+- https://docs.langchain.com/oss/python/deepagents/overview — обзор Deep Agents.
+- https://docs.langchain.com/oss/python/deepagents/customization — кастомизация Deep Agents.
+- https://docs.langchain.com/oss/python/migrate/langchain-v1 — гайд миграции на v1.
+- https://docs.langchain.com/oss/python/releases/langchain-v1 — что нового в LangChain v1.
+- https://docs.langchain.com/oss/javascript/releases/langchain-v1 — что нового в LangChain v1 (JS).
+- https://docs.langchain.com/oss/javascript/releases/langgraph-v1 — что нового в LangGraph v1 (JS).
+- https://reference.langchain.com/python — корневой API reference.
+- https://reference.langchain.com/python/langchain/agents/factory.html — страница фабрики агентов (decode error при fetch, использован через search).
+- https://reference.langchain.com/python/deepagents/graph.html — API Deep Agents graph.
+- https://reference.langchain.com/python/langsmith/version — версия langsmith SDK (0.8.9 latest).
+
+## Форумы и сообщество
+
+- https://forum.langchain.com/t/langchain-1-0-alpha-feedback-wanted/1436 — alpha feedback тема.
+- https://forum.langchain.com/t/we-launched-1-0-versions-of-langchain-and-langgraph/1904 — анонс 1.0 на форуме.
+- https://forum.langchain.com/t/create-stuff-documents-chain-is-not-working-with-latest-version-of-langchain-version-1-0-3/2092 — пример ошибки с `langchain.chains` → `langchain-classic`.
+
+## npm / PyPI
+
+- https://www.npmjs.com/package/%40langchain/classic — npm-описание `@langchain/classic`, перечисляет какие API туда переехали.
+- https://pypi.org/project/langchain/ — PyPI LangChain.
+- https://pypi.org/project/langgraph/ — PyPI LangGraph.
+- https://pypi.org/project/deepagents/ — PyPI Deep Agents (latest 0.6.11 на snapshot).
+- https://pypi.org/project/langsmith/ — PyPI LangSmith SDK.
+
+## Сторонние источники и подтверждения
+
+- https://www.microsoft.com/en-us/techcommunity/blogs/azuredevcommunityblog/langchain-v1-is-now-generally-available/4462159 — Microsoft TechCommunity пост о LangChain v1.
+- https://x.com/hwchase17/status/1962935384490565926 — Harrison Chase анонс alpha в X (1 сентября 2025).
+- https://medium.com/data-science-collective/building-deep-agents-with-langchain-1-0s-middleware-architecture-7fdbb3e47123 — статья о Deep Agents на middleware 1.0.
+- https://medium.com/mitb-for-all/langchain-a-second-look-6ed720e27fec — обзор LangChain 1.0 от сентября 2025.
+- https://www.linkedin.com/posts/langchain_open-swe-an-open-source-framework-for-internal-activity-7439726228057722882-3LrZ — LangChain LinkedIn-анонс Open SWE.
+- https://simonwillison.net/tags/jules/ — Simon Willison упоминает Open SWE.
+- https://agentnativedev.medium.com/langchain-and-langgraph-v1-0-beyond-release-notes-into-real-roi-7538fc02ff83 — разбор 1.0.
+- https://www.clickittech.com/ai/langchain-1-0-vs-langgraph-1-0/ — сравнение LangChain 1.0 и LangGraph 1.0.
+- https://ai.plainenglish.io/the-complete-guide-to-langchain-langgraph-2025-updates-and-production-ready-ai-frameworks-58bdb49a34b6 — полный гайд по 2025 релизам.
+- https://www.jbinternational.co.uk/article/view/4680 — статья о LangGraph 1.0 / 1.2 (май 2026).
+- https://picrew.github.io/LLM-Harness/main.pdf — Agent Harness Engineering Survey, цитирует Open SWE.
+- https://www.infoq.cn/article/ucQtx67807qs9B4ig5IS — китайский перевод LangChain Open SWE-анонса.
+
+## Локальные копии / контекст проекта
+
+- `/Users/alexandr/.mavis/plans/plan_85053139/workspace/lc-evo-deck/design-system.md` — дизайн-токены, выложенные другим агентом (использованы только как контекст, не как источник фактов о релизах).
+- `/Users/alexandr/.mavis/plans/plan_85053139/workspace/lc-evo-deck/design-system.js` — JS-модуль с design tokens.
+
+---
+
+## Заметки по надёжности
+
+1. `docs.langchain.com/oss/python/langchain/overview` и `reference.langchain.com/python/langchain/agents/factory.html` возвращают **decode error** при прямом fetch. Использованы данные из поисковых сниппетов и из README GitHub.
+2. `raw.githubusercontent.com/langchain-ai/langgraph/main/libs/langgraph/README.md` и `raw.githubusercontent.com/langchain-ai/deepagents/main/README.md` — **timeout**. Содержимое восстановлено из основного GitHub-fetch README.
+3. `changelog.langchain.com/announcements/langsmith-self-hosted-v0-9` — относится к январю 2025 (не 2026), что важно учитывать при построении timeline.
+4. Блог-пост об Open SWE имеет дату публикации **17 марта 2026** на самой странице (после редизайна), но README Open SWE ссылается на «announcement blog post here», а сам Open SWE впервые упомянут в августе 2025 — обе даты зафиксированы.

research/timeline.md

@@ -0,0 +1,207 @@
+# Timeline: LangChain / LangGraph / Deep Agents / Open SWE / LangSmith
+
+Единый таймлайн релизов и ключевых изменений. Покрытие: только стабильные релизы ≥ 1.0.0 или те, что определили архитектуру сегодняшней экосистемы. Устаревшие API помечены явно.
+
+Дата отсчёта: 2026-06-22.
+
+---
+
+## 2022-10 — рождение LangChain
+
+- **2022-10**: Harrison Chase публикует первый коммит LangChain как open-source фреймворк для оркестрации LLM.
+- Источник: README `langchain-ai/langchain` упоминает Harrison Chase как основателя; широко подтверждено в CSDN-обзорах 0.1 (2024-01).
+
+---
+
+## 2023-10 — LangChain 0.0.x (пред-стабильная эпоха)
+
+- Линейка `0.0.x` (добралась до `0.0.354` к январю 2024). Нестабильное API, частые breaking changes, отсутствие semver-гарантий.
+- LangChain становится самым быстрорастущим OSS-проектом на GitHub.
+- **Важно для презентации:** все API из этой эпохи (LLMChain, ConversationChain, AgentExecutor из langchain.agents, старые RetrievalQA) — **DEPRECATED**, перенесены в `langchain-classic` начиная с v1.0.
+
+---
+
+## 2024-01-08 — LangChain 0.1.0 (первый стабильный minor)
+
+- **Дата релиза:** 8 января 2024.
+- **Главные изменения:**
+  - Разделение монолита на `langchain-core` (ядро, стабильный API) + `langchain` (оркестрация) + `langchain-community` (700+ интеграций).
+  - LCEL (LangChain Expression Language) — `Runnable`-протокол: `invoke / stream / batch / async`.
+  - Семантическое версионирование с этого момента.
+  - Тесная интеграция с LangSmith для трассировки.
+  - Одновременно анонсирован LangGraph как «One More Thing» — граф-рантайм с поддержкой циклов для агентов.
+- **Источники:** blog.langchain.com (пост `langchain-v0-1-0`), changelog.langchain.com (анонс января 2024).
+
+---
+
+## 2024-05 — LangChain 0.2
+
+- Стандартизация единого интерфейса вызова (`invoke`).
+- Миграционные скрипты: `langchain-cli migrate`.
+- Сложные агенты рекомендовано строить на LangGraph.
+- Удалены устаревшие entry points (`predict_messages` и подобные).
+- **Источник:** CSDN-обзор «LangChain从零到一:版本演进、架构设计与实战指南» (blog.csdn.net/2401_84815887), блогпост v0.1.
+
+---
+
+## 2024-09 — LangChain 0.3
+
+- Финальная версия перед 1.0 в линейке 0.x.
+- Полная миграция на Pydantic v2 во всех пакетах.
+- Удаление Python 3.8 из supported.
+- Чистка deprecations, подготовка к 1.0.
+- **Примечание:** точная дата не указана в официальных changelog как «релиз 0.3», известно из changelog-ленты `changelog.langchain.com/?date=2024-09-*` и обзоров; пометка в README как «streamlined surface area».
+
+---
+
+## 2024-08 — первые следы LangGraph 0.x как production-ready
+
+- LangGraph вышел из «One More Thing» в полноценный фреймворк.
+- Ключевые абстракции: `StateGraph`, `add_node`, `add_edge`, `add_conditional_edges`, checkpoint-ы, threads.
+- Документация подтверждает, что LangGraph — низкоуровневый оркестратор, LangChain — поверх.
+
+---
+
+## 2025-08-21 — Open SWE анонс (пред-1.0)
+
+- **Дата:** 21 августа 2025 (по дате публикации статьи LangChain, через InfoQ/腾讯云 репост).
+- **Что вышло:** Open SWE — open-source асинхронный кодинг-агент, работающий в облачных песочницах (Daytona).
+- **Архитектура:** Manager + Planner + Programmer + Reviewer.
+- **Запуск:** через GitHub Issues, Web UI.
+- **License:** MIT.
+- **Источник:** `blog.langchain.com/open-swe-an-open-source-framework-for-internal-coding-agents` (переработанный блог-пост от 17 марта 2026, изначальный анонс — август 2025, см. README GitHub `langchain-ai/open-swe` со ссылкой на анонс-пост).
+
+---
+
+## 2025-08 — Deep Agents 0.x (первая публичная версия)
+
+- Публичный дебют библиотеки `deepagents` от LangChain.
+- Вдохновлена Claude Code, Deep Research, Manus.
+- Архитектура: planning tool + filesystem backend + subagents на базе LangGraph.
+- **Источник:** README `langchain-ai/deepagents` упоминает «inspired by Claude Code»; CSDN DeepAgents-обзор от августа 2025; блогпост «Building Production-Ready Deep Agents with LangChain 1.0» (Medium).
+
+---
+
+## 2025-09 — Deep Agents CLI
+
+- Анонс DeepAgents CLI — pre-built кодинг-агент для терминала, аналог Claude Code/Cursor.
+- Установка: `curl -LsSf https://langch.in/dcode | bash`.
+- **Источник:** blog.langchain.com/introducing-deepagents-cli.
+
+---
+
+## 2025-09 — LangChain & LangGraph 1.0 alpha
+
+- **Дата:** конец сентября 2025 (пост Harrison Chase в X от 01.09.2025: `x.com/hwchase17/status/1962935384490565926`).
+- Alpha-релизы для сбора обратной связи.
+- **Источники:** blog.langchain.com/langchain-langchain-1-0-alpha-releases, форум forum.langchain.com/t/langchain-1-0-alpha-feedback-wanted/1436.
+
+---
+
+## 2025-10-20 — LangChain 1.0 GA
+
+- **Дата релиза:** 20-22 октября 2025 (changelog.langchain.com и blog.langchain.com указывают 22.10.2025, CSDN-обзоры и китайские источники — 20.10.2025).
+- **Что нового в 1.0:**
+  - **create_agent abstraction** — единая функция для создания агента поверх LangGraph-рантайма.
+  - **Middleware system** — fine-grained контроль на каждом шаге цикла агента. Built-in: human-in-the-loop, summarization, PII redaction. Custom middleware поддерживается.
+  - **Improved structured output** — интегрирован в основной цикл, без extra LLM-вызовов.
+  - **Standard content blocks** — провайдер-агностичная спецификация для выходов моделей (reasoning traces, citations, server-side tool calls).
+  - **Legacy → langchain-classic:** LLMChain, ConversationalRetrievalQAChain, RetrievalQAChain, AgentExecutor (legacy), старые chains. Доступны через отдельный пакет `@langchain/classic`.
+  - **Стабильность:** semver-обязательство — никаких breaking changes до 2.0.
+- **Покрытие звёздами:** на дату snapshot README `langchain-ai/langchain` — 140k stars.
+- **Источники:** changelog.langchain.com/announcements/langchain-1-0-now-generally-available, blog.langchain.com/langchain-langgraph-1dot0, Medium «Building Deep Agents with LangChain 1.0», Microsoft TechCommunity «LangChain v1 is now generally available».
+
+---
+
+## 2025-10-22 — LangGraph 1.0 GA
+
+- **Дата релиза:** 22 октября 2025.
+- **Что нового в 1.0:**
+  - **Durable state** — состояние графа персистится автоматически. При падении сервера посреди долгого диалога — восстановление ровно с точки остановки.
+  - **Built-in persistence** — сохранение/возобновление в любой точке без своей DB-логики. Multi-day approvals, background jobs.
+  - **Human-in-the-loop first-class API** — пауза для human review / modification / approval.
+  - **Graph-based execution model** — для смеси детерминированных и агентных компонентов.
+  - **Deprecation:** `langgraph.prebuilt` deprecated, функционал перенесён в `langchain.agents` (create_react_agent → create_agent).
+  - **API stability:** без breaking changes до 2.0.
+- **Звёзды на snapshot:** 35.4k stars.
+- **Источники:** changelog.langchain.com/announcements/langgraph-1-0-is-now-generally-available, blog.langchain.com/langchain-langgraph-1dot0.
+
+---
+
+## 2025-10 — Deep Agents 1.0 (синхронно с LangChain 1.0)
+
+- **Дата:** октябрь 2025 (синхронизировано с LangChain 1.0).
+- **Версия на PyPI (snapshot 2026-06):** `deepagents==0.6.11` (latest). То есть формально major 1.0 для deepagents-пакета **не зафиксирован** на дату snapshot — продолжает нумерацию 0.x.
+- **Что изменилось:** полная интеграция с LangChain 1.0 middleware-системой; `create_deep_agent` теперь принимает middleware как first-class параметр.
+- **Важно:** README явно говорит «inspired by Claude Code: identify what makes it general-purpose, push further».
+- **Источник:** README `langchain-ai/deepagents`, pypi.org/project/deepagents, Medium «Building Production-Ready Deep Agents with LangChain 1.0's Middleware Architecture».
+
+---
+
+## 2025-12 — Open SWE первый релиз
+
+- **Дата:** декабрь 2025 — формальная пометка в сторонних обзорах (LangChain Facebook, Agent Harness Engineering Survey).
+- **Версия:** стабильный репозиторий `langchain-ai/open-swe`, 971+ коммитов, 10k stars на snapshot 2026-06.
+- **Ключевая публикация блог-поста:** первоначальный анонс от августа 2025 (см. выше), переработанный пост от 2026-03-17.
+- **Текущая архитектура:** Manager/Planner/Programmer/Reviewer → переработано в единый `create_deep_agent` harness + subagents + middleware.
+- **Триггеры:** Slack, Linear, GitHub.
+- **Песочницы:** Modal, Daytona, Runloop, LangSmith.
+- **License:** MIT.
+- **Источник:** README `langchain-ai/open-swe`, blog.langchain.com/open-swe-an-open-source-framework-for-internal-coding-agents.
+
+---
+
+## 2026-01 — LangSmith v0.x (Self-Hosted)
+
+- **Дата:** январь 2026 — LangSmith Self-Hosted v0.9 (по changelog.langchain.com от 21.01.2025 — обратите внимание, эта конкретная пометка относится к январю 2025; точная дата следующего релиза — конец 2025 / начало 2026).
+- **Текущая стабильная версия Python SDK:** `langsmith==0.8.9` (latest на reference.langchain.com snapshot).
+- **Важно:** LangSmith SDK не следует semver 1.0+, продолжает развитие в 0.x с пометкой «Since v0.1». Это платформа (SaaS + self-hosted), а не open-source фреймворк, поэтому major 1.0 для неё не объявлен.
+- **Источники:** reference.langchain.com/python/langsmith/version, changelog.langchain.com (категория `cat_ZWTyLBFVqdtSq`), pypi.org/project/langsmith.
+
+---
+
+## 2026-Q1 — LangGraph 1.2.x
+
+- Текущая версия на PyPI snapshot 2026-06: `langgraph==1.2.6` (от 18.06.2026).
+- В 1.2 появились: fault tolerance (retries / timeouts / error handlers), улучшенные middleware, дополнительная стабилизация типов.
+- **Источники:** blog.langchain.com/fault-tolerance-in-langgraph (04.06.2026), GitHub Releases `langchain-ai/langgraph/releases/tag/1.2.6`.
+
+---
+
+## 2026-06 — текущее состояние
+
+- **langchain (Python):** latest stable ≈ 1.3.10 / 1.4.8 (по GitHub releases `langchain-ai/langchain/releases`, jun 2026).
+- **langchain-core:** latest stable 1.4.8 (от 18.06.2026).
+- **langgraph:** latest stable 1.2.6 (от 18.06.2026).
+- **deepagents:** latest stable 0.6.11 (от 18.06.2026) — major 1.0 пока не выпущен, продолжает нумерацию 0.x.
+- **open-swe:** active development, 971+ коммитов, без формальных релизов на PyPI (это приложение, не библиотека).
+- **langsmith:** Python SDK 0.8.9 (без 1.0).
+- **Источник:** GitHub Releases pages для каждого репозитория + PyPI version badges на README.
+
+---
+
+## Что НЕ стабильно / устарело (важно для презентации)
+
+| API | Статус | Замена |
+|---|---|---|
+| `langchain.chains.LLMChain` | DEPRECATED → `langchain-classic` | LCEL `prompt \| model \| parser` |
+| `langchain.chains.ConversationalRetrievalQAChain` | DEPRECATED → `langchain-classic` | LangGraph retrieval-graph |
+| `langchain.chains.RetrievalQAChain` | DEPRECATED → `langchain-classic` | LangGraph retrieval-graph |
+| `langchain.agents.AgentExecutor` (legacy) | DEPRECATED → `langchain-classic` | `langchain.agents.create_agent` (v1.0+) |
+| `langchain.agents.create_react_agent` | DEPRECATED → перенесён в `langchain-classic` | `langchain.agents.create_agent` |
+| `langgraph.prebuilt.create_react_agent` | DEPRECATED | `langchain.agents.create_agent` |
+| `langchain.llms.LLM` (legacy interface) | DEPRECATED | `init_chat_model` (v1.0+) |
+| `langchain.prompts.PromptTemplate` (старый) | DEPRECATED для некоторых use-cases | `ChatPromptTemplate` |
+
+**Источник:** @langchain/classic npm-описание, GitHub Issue `langchain-ai/langchain/issues/33933`, docs.langchain.com/oss/python/migrate/langchain-v1.
+
+---
+
+## TL;DR для презентации
+
+- **2024-01**: LangChain 0.1 — стабилизация монолита.
+- **2024-05**: LangChain 0.2 — унификация API.
+- **2025-08**: Deep Agents и Open SWE — агенты нового поколения.
+- **2025-10-20**: LangChain 1.0 — production-ready агенты.
+- **2025-10-22**: LangGraph 1.0 — durable execution API.
+- **2026**: итерации 1.2 / 1.3 / 1.4 в рамках стабильной ветки 1.x.