Как запустить автономный AI-агент на смартфоне: полный гайд по Termux, llama.cpp и Git-якорям

Зачем вообще запускать AI агента на смартфоне?

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

Но есть проблема: мобильные LLM работают медленно, перегревают телефон и съедают батарею за час. А еще они забывают контекст после перезагрузки приложения. Именно эту проблему мы и решаем сегодня.

Что такое Git якоря и зачем они AI агенту?

Представьте: ваш агент три часа анализирует документ, строит планы, ведет диалог. Вы закрываете Termux - и все пропало. Контекст сброшен, агент "забыл" все предыдущие рассуждения.

Git якоря - это криптографические контрольные точки. Каждые N токенов агент записывает хэш своего состояния в Git. Не данные диалога (они могут быть огромными), а SHA-256 от сжатого контекста. Это дает:

• Восстановление диалога после сбоя
• Аудит цепочки рассуждений (доказательство, что агент не "сошел с ума")
• Возможность отката к предыдущим версиям контекста

По сути, это version control для сознания AI. Если хотите глубже разобраться в криптографическом аудите, посмотрите статью про SHA-256 хэш-цепочки в Termux.

Железо: какой телефон нужен?

Не каждый смартфон потянет. Вот минимальные требования на 2026 год:

Почему так много? Потому что 7B параметров в 4-bit квантовании - это примерно 4 ГБ памяти. Плюс контекст, плюс системные процессы. Snapdragon 8 Elite с его NPU ускоряет матричные умножения в 3-4 раза по сравнению с обычными ядрами CPU.

Если у вас старый телефон, начните с базового руководства по llama.cpp на Snapdragon 888.

Шаг 1: Установка Termux и настройка окружения

1 Качаем правильный Termux

Не из Google Play. Тот Termux давно не обновляется. Идите на F-Droid или GitHub репозиторий Termux. На 2026 год актуальная версия - 0.119.0 или новее.

# Проверяем версию после установки
termux-info

# Должно быть примерно так:
# Packages CPU architecture: aarch64
# Subscribed repositories:
# * sources.list: ...
# Updatable packages: 0/...

2 Обновляем пакеты и ставим необходимое

Первое, что делаем - обновляем пакеты. Потом ставим git, python, clang и утилиты для сборки.

pkg update -y && pkg upgrade -y
pkg install -y git python clang cmake make \
  openssl-tool libcrypt ndk-sysroot \
  termux-api termux-exec

3 Настраиваем хранилище

Termux по умолчанию работает в изолированной среде. Нам нужно получить доступ к общей памяти для загрузки моделей.

termux-setup-storage

# Создаем симлинк для удобства
ln -s /storage/emulated/0/Download/ ~/downloads

# Проверяем
ls -la ~/downloads/

Шаг 2: Сборка llama.cpp с оптимизациями для ARM

Здесь большинство совершает ошибку - качают готовые бинарники. Не делайте так. Сборка под вашу конкретную архитектуру дает до 40% прироста производительности.

4 Клонируем и собираем

cd ~
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Смотрим последний тег (на февраль 2026 это v3.8.1)
git tag | tail -5

# Переключаемся на стабильную версию
git checkout tags/v3.8.1

# Конфигурируем с оптимизациями для ARM
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release \
  -DLLAMA_METAL=OFF \
  -DLLAMA_VULKAN=OFF \
  -DLLAMA_MPI=OFF \
  -DLLAMA_ACCELERATE=ON \
  -DLLAMA_ARM_NEON=ON \
  -DLLAMA_F16C=OFF \
  -DCMAKE_C_FLAGS="-march=armv8.2-a+dotprod"

# Компилируем с использованием всех ядер
make -j$(nproc) llama-cli

5 Тестируем сборку

# Проверяем, что бинарник работает
cd ~/llama.cpp/build/bin/
./llama-cli --help

# Должны увидеть список параметров
# Особенно важно наличие:
#   --n-gpu-layers N   - для использования NPU
#   --ctx-size N       - размер контекста

Шаг 3: Выбор и загрузка модели

На 2026 год золотой стандарт - модели размером 7B-13B параметров с квантованием Q5_K_M. Они дают хороший баланс между качеством и скоростью.

*На Snapdragon 8 Elite с 20 слоями на NPU

6 Качаем модель

Используем Hugging Face, но через wget - это надежнее в Termux.

cd ~/downloads

# Пример для Qwen2.5-7B
# Ищем самую свежую GGUF версию на Hugging Face
# На 2026 год актуальный линк:
wget https://huggingface.co/Qwen/Qwen2.5-7B-Instruct-GGUF/resolve/main/qwen2.5-7b-instruct-q5_k_m.gguf

# Проверяем размер
ls -lh *.gguf

Шаг 4: Первый запуск и бенчмарк

7 Тестовый прогон

cd ~/llama.cpp/build/bin/

# Запускаем с оптимальными параметрами для телефона
./llama-cli -m ~/downloads/qwen2.5-7b-instruct-q5_k_m.gguf \
  --n-gpu-layers 20 \
  --ctx-size 4096 \
  --threads 6 \
  --batch-size 512 \
  --temp 0.7 \
  --repeat-penalty 1.1 \
  -p "Translate 'Hello world' to French:" \
  -n 50

Что делают эти флаги:

• --n-gpu-layers 20 - 20 слоев на NPU (если есть). Начинайте с 10 и увеличивайте, пока не упретесь в память
• --ctx-size 4096 - размер контекста. 4096 - оптимально для телефона, 8192 уже требует много памяти
• --threads 6 - количество потоков CPU. Обычно (ядер * 2) - 2
• --batch-size 512 - уменьшаем, если телефон перегревается

Шаг 5: Создаем систему Git якорей

Вот где начинается магия. Мы создаем скрипт, который каждые 1000 токенов сохраняет хэш состояния агента в Git.

8 Структура проекта

cd ~
mkdir -p ai-agent/{contexts,checkpoints,scripts}
cd ai-agent

git init

echo "contexts/" > .gitignore
echo "checkpoints/*.bin" >> .gitignore
echo "*.gguf" >> .gitignore

9 Скрипт якорения

Создаем Python скрипт, который будет работать как прослойка между вами и llama.cpp:

#!/data/data/com.termux/files/usr/bin/python3
# ~/ai-agent/scripts/anchor_agent.py

import subprocess
import hashlib
import json
import os
from datetime import datetime

class GitAnchoredAgent:
    def __init__(self, model_path, context_file="current_context.json"):
        self.model_path = model_path
        self.context_file = context_file
        self.token_counter = 0
        self.anchor_interval = 1000  # Якорь каждые 1000 токенов
        
        # Загружаем или создаем контекст
        if os.path.exists(context_file):
            with open(context_file, 'r') as f:
                self.context = json.load(f)
        else:
            self.context = {
                "conversation": [],
                "metadata": {"created": datetime.now().isoformat()},
                "anchors": []
            }
    
    def create_anchor(self, reason="periodic"):
        """Создает криптографический якорь текущего состояния"""
        # Создаем снимок контекста (без истории, только текущее состояние)
        snapshot = {
            "last_message": self.context["conversation"][-1] if self.context["conversation"] else None,
            "token_count": self.token_counter,
            "timestamp": datetime.now().isoformat(),
            "reason": reason
        }
        
        # Хэшируем
        snapshot_str = json.dumps(snapshot, sort_keys=True)
        anchor_hash = hashlib.sha256(snapshot_str.encode()).hexdigest()[:16]
        
        # Сохраняем в контекст
        self.context["anchors"].append({
            "hash": anchor_hash,
            "snapshot": snapshot,
            "full_hash": hashlib.sha256(snapshot_str.encode()).hexdigest()
        })
        
        # Коммитим в Git
        with open("anchors.log", "a") as f:
            f.write(f"{datetime.now().isoformat()} | {anchor_hash} | {reason}\n")
        
        subprocess.run(["git", "add", "anchors.log"])
        subprocess.run(["git", "commit", "-m", f"Anchor: {anchor_hash} ({reason})"])
        
        return anchor_hash
    
    def query(self, prompt):
        """Отправляет запрос модели с якорением"""
        # Добавляем в историю
        self.context["conversation"].append({
            "role": "user",
            "content": prompt,
            "timestamp": datetime.now().isoformat()
        })
        
        # Готовим промпт для llama.cpp
        full_prompt = self._format_prompt()
        
        # Запускаем модель
        result = self._run_llama(full_prompt)
        
        # Сохраняем ответ
        self.context["conversation"].append({
            "role": "assistant",
            "content": result,
            "timestamp": datetime.now().isoformat()
        })
        
        # Обновляем счетчик токенов (грубая оценка)
        self.token_counter += len(prompt.split()) + len(result.split())
        
        # Создаем якорь если нужно
        if self.token_counter >= self.anchor_interval:
            anchor = self.create_anchor()
            print(f"[Anchor created: {anchor}]")
            self.token_counter = 0
        
        # Сохраняем контекст
        self._save_context()
        
        return result
    
    def _format_prompt(self):
        """Форматирует историю для модели"""
        # Берем только последние 10 сообщений чтобы не перегружать
        recent = self.context["conversation"][-10:] if len(self.context["conversation"]) > 10 else self.context["conversation"]
        
        formatted = []
        for msg in recent:
            if msg["role"] == "user":
                formatted.append(f"User: {msg['content']}")
            else:
                formatted.append(f"Assistant: {msg['content']}")
        
        return "\n".join(formatted) + "\nAssistant:"
    
    def _run_llama(self, prompt):
        """Вызывает llama.cpp"""
        cmd = [
            "~/llama.cpp/build/bin/llama-cli",
            "-m", self.model_path,
            "--n-gpu-layers", "20",
            "--ctx-size", "4096",
            "--temp", "0.7",
            "-p", prompt,
            "-n", "512"  # Максимальная длина ответа
        ]
        
        result = subprocess.run(cmd, capture_output=True, text=True)
        return result.stdout.strip()
    
    def _save_context(self):
        """Сохраняет контекст в файл"""
        with open(self.context_file, 'w') as f:
            json.dump(self.context, f, indent=2)

if __name__ == "__main__":
    # Пример использования
    agent = GitAnchoredAgent("~/downloads/qwen2.5-7b-instruct-q5_k_m.gguf")
    
    print("Git-Anchored AI Agent ready. Type 'quit' to exit.")
    print(f"Current anchors: {len(agent.context['anchors'])}")
    
    while True:
        user_input = input("\nYou: ")
        if user_input.lower() == 'quit':
            # Создаем финальный якорь перед выходом
            agent.create_anchor("session_end")
            break
        
        response = agent.query(user_input)
        print(f"\nAssistant: {response}")

10 Делаем скрипт исполняемым и тестируем

cd ~/ai-agent
chmod +x scripts/anchor_agent.py

# Первый запуск - настройка Git
git config --global user.email "ai@phone.local"
git config --global user.name "AI Agent"

# Запускаем агента
python scripts/anchor_agent.py

# Тестируем
# You: What is quantum computing?
# ... ждем ответа ...
# You: Explain like I'm five
# [Anchor created: a3f8c2e1]  ← вот он, якорь!

Шаг 6: Восстановление после сбоя

Вот ради чего все это затевалось. Допустим, Termux упал или телефон разрядился. Восстанавливаем:

cd ~/ai-agent

# Смотрим историю якорей
git log --oneline anchors.log

# Восстанавливаем последний якорь
git checkout HEAD -- anchors.log

# Запускаем агента - он загрузит последний контекст
python scripts/anchor_agent.py

# Агент говорит:
# Current anchors: 15  ← все на месте!
# И продолжает с того места, где остановился

Проблемы и решения (из моего горького опыта)

Телефон перегревается и тормозит

Уменьшаем --n-gpu-layers до 10-15. Ставим телефон на холодную поверхность (стеклянный стол, кафель). В серьезных случаях - покупаем активный кулер для смартфона за 1500 рублей. Да, это выглядит смешно, но работает.

Модель "забывает" контекст через 10-20 сообщений

Увеличиваем --ctx-size до 8192, но будьте готовы к падению скорости. Или улучшайте скрипт якорения - пусть он сохраняет не хэши, а сжатые эмбеддинги ключевых моментов. Это сложнее, но эффективнее.

Termux падает при загрузке модели

В 90% случаев - нехватка оперативной памяти. Закройте все приложения, отключите live wallpaper, запустите Termux один. Если не помогает - берите модель поменьше. 3B параметров в 2026 году умнее, чем 7B в 2024.

Git якоря занимают много места

Они не должны. Один якорь - это 64 байта SHA-256 + метаданные. 1000 якорей = ~100 КБ. Если занимают гигабайты - вы где-то ошиблись и сохраняете полные чекпоинты вместо хэшей.

Куда развивать систему дальше?

Базовый агент работает. Теперь можно добавить:

1. Мультиагентность - несколько специализированных агентов в одном Termux. Один анализирует текст, второй ищет в локальной базе знаний, третий пишет код. Как в AI-Doomsday-Toolbox, но на одном устройстве.
2. Интеграцию с Android API через termux-api. Агент может читать ваши уведомления, отправлять SMS, управлять другими приложениями. Осторожно с этим.
3. Автоматическое обучение на ваших данных - агент читает ваши документы, чаты, заметки и адаптируется под ваш стиль.
4. P2P сеть с другими телефона - несколько телефонов образуют распределенную сеть AI агентов. Один считает, другие ждут своей очереди.

Финальный совет: начинайте с простого

Не пытайтесь сразу сделать супер-агента с памятью на 100к токенов и десятью экспертами. Начните с llama.cpp на готовой модели. Погоняйте неделю. Поймите, как она тормозит, где перегревается, какие промпты работают.

Потом добавьте Git якоря. Еще неделя на отладку.

Потом - интеграцию с файловой системой. И так далее.

Через месяц у вас будет система, которая:

• Работает полностью оффлайн
• Помнит все ваши диалоги (и доказывает их целостность)
• Не шпионит за вами
• Стоит 0 рублей в месяц

И да, она будет медленнее ChatGPT. В 5-10 раз. Но она ваша. Настоящая, а не арендованная.

Когда все облака отключат API для вашего региона (а это вопрос времени), ваш агент будет продолжать работать. Когда интернет пропадет на неделю - вы сможете общаться с ИИ. Когда все начнут паниковать - у вас в кармане будет digital survival kit.

Это того стоит.