Вам не нужен OpenClaw

• Что такое агент - разберём базовую формулу Agent = LLM + Harness и что в реальности скрывается за словом Harness.
  
• Разберем, что такое контекст и как им управлять
  
• Пройдём ключевые механизмы: инструменты (tools), MCP, память, сабагенты, Skills.
  
• Отдельно разберём практические кейсы: интеграцию с мессенджером, фоновые cron-задачи, внешние интеграции и динамическую загрузку скиллов.
  
• Упомянем безопасность

Agent = LLM + Harness

• управление контекстом
  
• инструменты
  
• память
  
• скиллы
  
• мультиагентная логика
  
• интеграции с внешними системами

User -- {"role": "user", "content": "Привет!"} --> LLM
User <-- {"role": "assistant", "content": "Господи, ну что опять!?"} -- LLM

// первый запрос
User -- [{"role": "user", "content": "Привет!"}] --> LLM
User <-- {"role": "assistant", "content": "Господи, ну что опять!?"} -- LLM
// второй запрос
User -- [
    // история
    {"role": "user", "content": "Привет!"},
    {"role": "assistant", "content": "Господи, ну что опять!?"},
    // новое сообщение
    {"role": "user", "content": "Да так, заскучал"}
] --> LLM

{"role": "system", "content": "..."}
// Так что первый запрос выглядит вот так
User -- [
    {"role": "system", "content": "..."},
    {"role": "user", "content": "Привет!"}
] --> LLM

from autogen.beta import Agent, config
agent = Agent("agent", config=config.OpenAIConfig("gpt-4"))
# Делаем первый запрос
turn = await agent.ask("Hi!")
print(await turn.content())
# "Hi, how can I help you?"
while True:
    # Делаем следующий запрос на базе предыдущего
    turn = await turn.ask("Continue")
    print(await turn.content())
    # "What should I continue?"

500t
                  | user   |  <- новый запрос включает всю историю
           300t   | agent  |
         | user   | user   |
  100t   | agent  | agent  |
| user   | user   | user   |
| system | system | system |

50t
                  | user   |  <- платим в основном за новые токены
           50t    |        |
         | user   |        |
  100t   |        |        |
| user   | 250ct  | 450ct  |  <- ct = cached tokens
| system | cached | cached |  <- старая часть контекста кэшируется

• отбрасываем старые сообщения
  
• отбрасываем только определённые типы сообщений
  
• сжимаем весь диалог в одно <summary> с помощью той же LLM

from autogen.beta import Agent, config
compaction_agent = Agent("compacter", config=config.OpenAIConfig("gpt-5"))
agent = Agent("my-lovely-agent", config=config.OpenAIConfig("gpt-5"))
turn = await agent.ask("Hi!")
while True:
    history = turn.stream.history
    messages = await history.get_messages()
    if len(messages) > 10:
        summary = await compaction_agent.ask(
            "Summary chat history to single message",
            f"History: {messages}"
        )
        # перезаписываем всю историю единственным сообщением
        await history.set([summary.body])
    turn = await turn.ask("Continue")
    print(turn.body)

{
   "name": "get_weekday",
   "description": "Call this tool each time you want to know current weekday",
   "arguments": { "type": "object", "properties": {} }
}

• name — уникальный идентификатор, по которому модель будет вызывать инструмент
  
• description — наша попытка объяснить модели, зачем он нужен и когда его дёргать
  
• arguments — JSONSchema с описанием аргументов; мы просто надеемся, что модель вернёт правильный JSON

User -- [{"role": "user", "content": "Чем займёмся сегодня?"}] --> LLM
LLM -- {
    "role": "assistant",
    "tool_calls": [{
        "call_id": "...",
        "name": "get_weekday",
        "arguments": "{}"
    }]
} --> Agentic Framework
LLM <-- {
    "role": "tool",
    "content": "Friday"
} -- Agentic Framework
User <-- {
    "role": "assistant",
    "content": "Friday! It's time to drink beer!"
} -- LLM

| assistant         |
|  tool result      |  <- результат инструмента
|  tool call        |  <- команда на вызов инструмента
| user              |
| tools definitions |  <- описания доступных инструментов
| system            |

from autogen.beta import Agent, config
agent = Agent("my-lovely-agent", config=config.OpenAIConfig("gpt-5"))
@agent.tool
def get_weekday() -> str:
    return "Friday"  # всегда пятница, всегда пьём пиво

• Память
  
• Сабагенты
  
• Походы агента в интернет
  
• Интеграции со внешними системами (Google Docs, Notion, Maps и т.д.)
  
• Взаимодействие с операционной системой
  
• AI-IDE (чтение, редактирование файлов, запуск команд)

• информацию о пользователе
  
• свою личность (манеру общения)
  
• общие правила из опыта
  
• историю диалогов

class Memory:
    def write_conversation_memory(name: str, summary: str) -> None: ...
    def list_conversations() -> list[tuple[UUID, str, datetime]]: ...
    def read_conversation(conversation_id: UUID) -> str: ...

memory/
├── PERSONALITY.md     # личность агента
├── USER.md            # профиль пользователя
├── 04_16_2026/        # история диалогов
│   ├── Write_Blogpost.md
│   └── Make_Presentation.md
└── 04_17_2026/
    └── Find_NN_Restaurants.md

• самодописывать свой системный промпт (через PERSONALITY.md)
  
• обновлять информацию о пользователе (USER.md)
  
• писать историю диалогов, искать по ним и доставать факты

User -- "Мы на прошлой неделе выбирали, куда пойти. Что решили?" --> LLM
LLM -- list_memories(date="04_15_2026") --> Framework
LLM <-- [] -- Framework
LLM -- list_memories(date="04_16_2026") --> Framework
LLM <-- ["Write_Blogpost", "Make_Presentation"] -- Framework
LLM -- list_memories(date="04_17_2026") --> Framework
LLM <-- ["Find_Restaurants"] -- Framework
LLM -- read_file(path="04_17_2026/Find_Restaurants.md") --> Framework
User <-- "Это было 17-го! Ты решил сходить в Ель, столик на 21:00" -- LLM

| assistant         |
|  tool result      |  <- промежуточный результат #3
|  tool call        |  <- вызов #3
|  tool result      |  <- промежуточный результат #2
|  tool call        |  <- вызов #2
|  tool result      |  <- промежуточный результат #1
|  tool call        |  <- вызов #1
| user              |
| tools definitions |
| system            |

from autogen.beta import Agent, config, tools
memory_agent = Agent(
    "memory-agent",
    config=config.OpenAIConfig("gpt-5"),
    tools=[tools.FilesystemToolkit("./memory")]
)
agent = Agent(
    "ag-claw",
    config=config.OpenAIConfig("gpt-5"),
    tools=[
        memory_agent.as_tool(description="Find information in memories")
    ]
)

| assistant         |                   |
|  subagent result  | assistant         |  <- в главный контекст попадает только итог
|                   |   tool result     |
|                   |   tool call       |
|                   |   tool result     |
|                   |   tool call       |
|                   |   tool result     |
|                   |   tool call       |  <- весь шум остается внутри сабагента
|  subagent call    | user              |
| user              |                   |
| subagent tools    | memory tools      |
| claw prompt       | subagent prompt   |  <- два изолированных контекста

| assistant         |                   |
| user              |                   |
| subagent result   | assistant         |  <- результат приходит асинхронно
|                   |   tool result     |
|  assistant        |   tool call       |
|  user             |   tool result     |
|                   |   tool call       |
|  subagent called  |   tool call       |  <- сабагент работает в фоне
|  subagent call    | user              |
| user              |                   |

• Сабагент сам приносит результат по готовности
  
• Сабагент отдаёт TaskId, основной агент спрашивает о готовности по этому ID

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

• rtk — учит агента использовать rtk как прокси для shell-команд: вместо сырого вывода git log или cargo build агент получает отфильтрованный результат и тратит в разы меньше токенов
  
• caveman — учит агента писать примитивный, но предсказуемый код без оверинжиниринга
  
• React best practices — гайдлайны по React от Vercel, которые агент загружает перед работой с фронтендом

Skill = Context + Scripts

.agents/skills/
└── Pytest_Skill/
    ├── SKILL.md
    └── scripts/
        ├── run_pytest.sh
        └── list_tests.py

• SKILL.md — текстовая инструкция, которую загрузим в контекст, когда агент захочет работать с pytest
  
• scripts/ — исполняемые скрипты, правила использования которых описаны в SKILL.md

class SkillsToolkit:
    def list_skills() -> list[SkillMetadata]: ...
    def load_skill(skill_id: str) -> str: ...
    def run_skill_script(skill_id: str, script: str) -> str: ...

[{
    "name": "Pytest_Skill",
    "description": "Use this skill to test your python code",
    ... //  всякие бесполезные поля
}]

| assistant         |
|  script result    |
|  run script       |  <- исполнение скрипта из скилла
|  skill content    |
|  load skill       |  <- загрузка скилла в контекст
| user              |
| tools definitions |
| skills metadata   |  <- список доступных скиллов
| system            |

• метаинформация в контексте
  
• пара инструментов
  
• директория на файловой системе

class SkillSearchToolkit:
    async def search_skills(query: str, limit: int = 10) -> str: ...
    async def install_skill(skill_id: str) -> str: ...
    def remove_skill(name: str) -> None: ...

• aci.dev/tools — 600+ готовых инструментов, open source
  
• composio.dev/toolkits — 1000+ тулкитов с OAuth из коробки
  
• arcade.dev — MCP runtime, фокус на безопасной авторизации агентов
  
• mcp.so — каталог MCP-серверов (community)

from autogen.beta import Agent, config, MemoryStream
agent = Agent("tg-agent", config=config.OpenAIConfig("gpt-5"))
dp = Dispatcher()
chat_state: dict[int, MemoryStream] = {}
@dp.message(F.text)
async def on_text(message: Message) -> None:
    # получаем старый контекст или создаем новый
    if not (stream := chat_state.get(message.chat.id)):
        stream = chat_state[message.chat.id] = MemoryStream()
    # дергаем агента с этим контекстом
    reply = await agent.ask(
        message.text,
        stream=stream,
        variables={"user_id": message.chat.id},
    )
    # отвечаем в TG чат
    await message.answer(reply.content)
asyncio.run(dp.start_polling(bot))

class SchedulerToolkit:
    def schedule_task(task_prompt: str, cron: str) -> UUID: ...
    def remove_task(task_id: UUID) -> None: ...
    def list_tasks() -> list[UUID]: ...

import asyncio
from autogen.beta import Agent, config
cron = Scheduler()
agent = Agent(
    "tg-agent",
    config=config.OpenAIConfig("gpt-5"),
    tools=[SchedulerToolkit(cron)]
)
async def main():
    asyncio.create_task(cron.run())
    await agent.ask("Мониторь билеты каждый час")

• Мой Telegram-канал — здесь я рассказываю об агентах, OpenSource, разработке и продуктивности
  
• github.com/ag2ai/ag2 — фреймворк, на котором написаны все примеры выше
  
• aci.dev/tools | composio.dev/toolkits | arcade.dev — каталоги готовых интеграций
  
• mcp.so — каталог MCP-серверов
  
• github.com/openclaw/openclaw — если всё-таки хотите посмотреть оригинал