Как запустить 3 AI-агента с разными LLM на одном старом GPU (GTX 1080 8GB): решение проблемы нехватки памяти

Один GPU - три мозга? Легко!

У вас есть древняя GTX 1080 с 8 гигабайтами VRAM, которую вы купили ещё в 2016 году. Она верой и правдой тащила все игры, но сейчас 2026 год, и вы хотите запустить на ней трёх AI-агентов с разными локальными моделями. Один агент пишет код, второй анализирует документы, третий генерирует креативные тексты. Звучит как безумие? Именно этим я и занимаюсь последние полгода.

Я перепробовал десятки комбинаций: 8 карт RTX 3090 (сборка безумного сервера), смешивание NVIDIA и Intel Arc (результаты эксперимента), но чаще всего ко мне приходят с одной простой просьбой: «Сделай так, чтобы моя старая видеокарта не простаивала, когда я хочу запустить несколько агентов локально».

И знаете что? Это реально. Причём не ценой ужасной производительности, а вполне приемлемых 10-15 токенов в секунду на каждого агента. Давайте разберёмся, как выжать из 8 ГБ всё до последнего байта.

Почему GTX 1080 плачет, когда видит три модели

Давайте посчитаем. Каждая LLM даже в 4-битном квантовании занимает примерно 2-4 ГБ. Плюс KV cache — ещё 0.5-1 ГБ на агента при контексте 2048 токенов. Итого три модели — 7-12 ГБ только на веса плюс кэш. А у нас всего 8 ГБ. CUDA Out of Memory прилетает секунд через 10 после старта третьего агента.

Но это если запускать модели наивно — каждая со своим полным контекстом и без оффлоада. Стандартная ошибка новичка: скачать модели в FP16, запустить через Transformers и удивляться. Так делать не надо. Есть три рычага, которые мы дёрнем:

• Квантование — сжимаем веса с 16 бит до 4-5 бит. Потеря качества минимальна, а экономия памяти — в 3-4 раза.
• Offloading на CPU — часть слоёв модели уходит в оперативную память. Скорость падает, но OOM уходит.
• Уменьшение контекста — KV cache жрёт память линейно от длины контекста. Если ограничить каждому агенту 1024 токена, освобождается гигабайт.

Три модели, которые реально влезут в 8 ГБ

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

Обратите внимание: Phi-4-mini пришлось квантовать Q3_K_S, чтобы влезть. Потери качества есть, но для генерации писем или сценариев — терпимо. Суммарно три модели занимают 1.1+1.8+0.8 = 3.7 ГБ плюс KV cache ~1.5 ГБ. Итого около 5.2 ГБ. Остаётся резерв на системные нужды и другие процессы.

Пошаговая инструкция: от установки до запуска

1 Ставим Ollama и скачиваем модели с правильным квантованием

Ollama сегодня — стандарт де-факто для локального запуска LLM. Версия 1.2.0 поддерживает все современные квантизации, включая IQ4_NL для максимальной экономии. Установка:

curl -fsSL https://ollama.com/install.sh | sh
# Проверяем версию
ollama --version  # должно быть 1.2.0+

# Качаем модели с явным указанием квантизации
ollama pull qwen3:1.5b-q4_K_M
ollama pull phi-4-mini:3.8b-q3_K_S
ollama pull llama3.2:1b-q4_K_M

2 Настраиваем offloading и контекст через переменные окружения

Чтобы каждая модель не пыталась занять всю VRAM, мы ограничим количество слоёв, которое Ollama грузит на GPU. Остальные слои уйдут в CPU RAM (нужно минимум 16 ГБ оперативной памяти, лучше 32).

Создаём файл ~/.ollama/config.json:

{
  "models": [
    {
      "name": "qwen3:1.5b-q4_K_M",
      "gpu_layers": 12,
      "num_ctx": 1024
    },
    {
      "name": "phi-4-mini:3.8b-q3_K_S",
      "gpu_layers": 10,
      "num_ctx": 1024
    },
    {
      "name": "llama3.2:1b-q4_K_M",
      "gpu_layers": 8,
      "num_ctx": 1024
    }
  ]
}

3 Пишем менеджер агентов на Python

Проще всего запускать каждого агента в отдельном процессе через ollama run, но это создаёт избыточную нагрузку. Лучше использовать Python с asyncio и библиотекой ollama-python (версия 0.4.2, поддерживает асинхронные запросы).

import asyncio
import ollama

async def agent(role, model):
    client = ollama.AsyncClient()
    system_prompt = f"Ты — {role}. Отвечай кратко и по делу."
    while True:
        user_input = await get_next_task_from_queue(role)
        response = await client.chat(
            model=model,
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_input}
            ],
            options={"num_ctx": 1024, "gpu_layers": 12}  # переопределяем если нужно
        )
        print(f"[{role}]: {response['message']['content']}")

async def main():
    agents = [
        agent("кодер", "qwen3:1.5b-q4_K_M"),
        agent("аналитик", "phi-4-mini:3.8b-q3_K_S"),
        agent("генератор", "llama3.2:1b-q4_K_M"),
    ]
    await asyncio.gather(*agents)

asyncio.run(main())

Важный момент: не забывайте контролировать очередь задач. Если все три агента одновременно получат длинный запрос — память заполнится KV cache. Используйте семофоры или ограничьте максимальное количество одновременных генераций (например, 2 на агента).

4 Мониторим память и подкручиваем

Запустите в соседнем терминале watch -n 1 nvidia-smi. Если видите, что VRAM заполняется под 8 ГБ и появляются ошибки — уменьшайте gpu_layers или контекст. Иногда проще выключить один из агентов, перенастроить модель с более глубоким квантованием (например, Q2_K) и включить снова.

Для тех, кто хочет пойти дальше: можете объединить эту технику с подходом из статьи «Две карты, одна скорость» — если у вас есть вторая видеокарта, даже GTX 1060, можно распределить агентов между ними.

Грабли, на которые я наступил (и вы наступите)

• Не та версия CUDA. GTX 1080 не поддерживает CUDA 12.6+, нужна 12.4 или 11.8. Убедитесь, что драйверы подходящие. На Ubuntu 24.04 ставьте драйверы 550 версии — они стабильнее.
• Ограничение CPU RAM. Если у вас 8 ГБ оперативной памяти, offloading почти ничего не даст — CPU RAM тоже закончится. Минимум 16 ГБ.
• Ollama не применяет конфиг. Иногда config.json игнорируется. Проверьте через ollama ps, сколько GPU-слоёв реально используется для каждой модели. Если не совпадает — пропишите параметры в моделях через ollama create.
• Утечка памяти в llama.cpp. В некоторых сборках есть баг с растущим KV cache при длительном использовании. Периодически перезапускайте Ollama или используйте флаг --num-ctx 1024 явно.
• Конфликт портов. Каждый агент через Ollama использует свой экземпляр сервера. Если запускаете три экземпляра Ollama на разных портах — не забудьте настроить переменные OLLAMA_HOST.

А что, если хочется больше?

Если трёх агентов мало — посмотрите в сторону подхода, описанного в статье «Развертывание роя из тысяч локальных AI-агентов». Там используется дедупликация запросов и shared контекст, что позволяет запускать десятки мелких агентов даже на 8 ГБ. Конечно, не все сразу — но последовательная обработка с переключением моделей даёт прирост.

Ещё один трюк: используйте MoE-модели, у которых активируется только часть экспертов. Я тестировал их на тройном GTX 1070 — для GTX 1080 8GB подойдут модели вроде Qwen1.5-MoE-A2.7B, которые при 2.7B параметров потребляют всего 2 ГБ.

Прогноз: GTX 1080 умрёт не сегодня

В 2026 году выходит NVIDIA RTX 5060 с 12 ГБ, но цены на вторичке кусаются. Если у вас уже есть GTX 1080 — выбрасывать её рано. С правильным квантованием и offloading она способна обслуживать трёх агентов в реальном времени. Следующий шаг: объединение с CPU GPU через OpenCL (читайте статью оптимизация AI-станции на Threadripper).

Мой неочевидный совет: не пытайтесь держать все три модели в VRAM одновременно. Используйте ollama unload и загружайте нужную модель по требованию. Если агенты работают по очереди (а в реальном сценарии так и бывает — пользователь даёт задачу то одному, то другому), вы экономите 2-3 ГБ постоянно.