Console AI Agent "Botinok": Automation of Linux Servers

Bootinok: A Console AI Agent for Resource-Efficient Linux Server Automation

"Bootinok" (derived from the Russian word for "boot" or "shoe") is an innovative console AI agent designed for efficient automation of routine tasks on Linux servers. Geared towards specialists with limited computing resources, particularly VRAM, this tool integrates the power of Large Language Models (LLMs) directly into the terminal, eliminating the need for complex GUIs or resource-intensive background services. It serves as an indispensable assistant for administrators, DevOps engineers, and developers who require prompt diagnostics and infrastructure management via SSH.

Moving Beyond Heavy Solutions: The Bootinok Philosophy

Years of experience with Linux servers show that despite the evolution of tools from manual configuration to Kubernetes, administrative routines persist. With the advent of LLMs, the possibility emerged to delegate tasks like log analysis or configuration generation to models. However, constantly switching between the terminal and a chatbot's web interface creates significant inconvenience.

The market offers AI agents like OpenClaw, which provide comprehensive automation solutions. OpenClaw, for instance, is a powerful self-hosted agent with a four-layer architecture, focused on lifestyle automation (email, calendar, bookings) and operating as a 24/7 daemon with a messenger interface. While effective for enterprise tasks and personal assistants, such an approach proved excessive and resource-intensive for system administration on a server.

Console-based server interaction via SSH demands a different approach. A tool is needed that isn't a constantly running service, doesn't require complex architecture, and doesn't consume excessive resources. "Bootinok" was created precisely for this purpose: it's a regular application that launches as needed, performs a task, and then exits. This approach is similar to how developers use AI assistants in IDEs (e.g., Cursor), where AI actively participates in the development process but doesn't run continuously in the background. Bootinok brings this concept to the console:

# Example usage: setting up an environment on a server
ssh [email protected]
botinok "Set up Docker, Nginx, and deployment for my Flask application"
# ... interact with the agent as it performs the task ...
# After completing the work, the agent closes

Bootinok requires Ollama, which can be installed locally, on a neighboring server, or on a powerful workstation. Connection to Ollama is configured interactively via --wizard, simplifying initial setup and model availability checks. This architecture makes Bootinok ideal for:

• Administrators who need quick diagnostics and problem-solving on a server via SSH.
• DevOps engineers for configuring CI/CD pipelines or working with configurations.
• Developers who need to quickly deploy an environment on a new machine.
• Enthusiasts with limited hardware, allowing them to use a powerful Ollama instance on one computer and run the lightweight client on another.

Agent Tooling: Function Calling and Key Capabilities

Bootinok leverages a full-fledged Function Calling mechanism via the Ollama API, providing the agent access to a range of specialized tools for interacting with the system and network. This allows the LLM not just to generate text, but also to perform specific actions, analyze data, and retrieve up-to-date information.

List of core tools:

• 🌐 Network and Search:

* web_search: Search for information via DuckDuckGo using lynx.

* open_url: Extract content from web pages.

• 🛠 System Tools:

* file_system: Navigate, search, read files, and execute grep commands.

* shell_exec: Execute arbitrary bash commands (requires explicit --dangerous permission).

* journal: Analyze systemd logs via journalctl.

• 💻 Development:

* code_editor: Tools for reading, writing, and modifying code.

* github: Basic repository operations (clone, log, status, diff).

• 📚 Skills and Experience:

* skills: Load instructions and prompts from the ClawHub repository.

* experience: A database of positive and negative experiences to improve agent decision-making.

Web Search Approach: Why Lynx?

Special attention has been paid to the implementation of network tools, particularly web_search and open_url. Instead of standard Python libraries or heavy browser engines, Bootinok uses the console text browser lynx. This solution might seem unconventional, but it's driven by several key advantages for a server scenario:

Reasons for choosing lynx:

• Lightweight and Accessible: lynx is pre-installed in most Linux distributions, requires no additional dependencies, and consumes minimal resources.
• Speed: The absence of JavaScript, CSS, image, and font rendering ensures high-speed retrieval of text content.
• Clean Text: The -dump parameter allows lynx to output structured text content without HTML tags, significantly simplifying its subsequent parsing by the LLM.
• SSH Compatibility: Perfectly suited for remote work on a server where a graphical interface is unavailable.

Example web_search call via subprocess:

result = subprocess.run([
    "lynx", "-dump", "-number_links",
    "-display_charset=utf-8",
    f"-useragent={user_agent}",
    f"https://html.duckduckgo.com/html/?q={encoded_query}"
], capture_output=True, text=True, timeout=15)

lynx Limitations and Solutions:

| Problem | Example | Solution |

| :------------------------- | :----------------------------------- | :---------------------------------------------------------------------- |

| No JavaScript | SPA sites (React, Vue) may appear empty | The agent recognizes empty content and reports it |

| Captchas | DDG sometimes blocks | Fallback to another URL, retry with a timeout |

| No Authorization | Restricted pages are inaccessible | Design limitation: works only with public content |

| Loss of Visual Context | Tables, diagrams become plain text | The agent adapts to the text format |

| Content Size | Truncation to N characters | Full dump is saved to the session; agent can read it if needed |

This compromise between simplicity, speed, and functionality makes lynx an optimal choice for quick access to documentation, articles, and GitHub READMEs in a console environment.

File System: The Agent's "Eyes and Hands" on the Server

The file_system tool is central to the agent's interaction with the server's operating system. It allows Bootinok to understand the file system's state, diagnose problems, and retrieve necessary information. All file_system actions are read-only by default, ensuring a high level of security.

Key file_system actions:

• list: Displays a list of files and directories with their size and modification date. Example: list /etc/nginx.
• search: Searches for files by mask. Example: search /var/log "*.log".
• grep: Searches for text within files. Example: grep /etc "server_name" "*.conf".
• read: Reads file content with pagination support for large files. Example: read /var/log/syslog offset=0 limit=500.
• info: Retrieves file metadata. Example: info /etc/passwd.

Additionally, there's a powerful set of inspect commands that provide aggregated system information:

inspect command="fs.tree" path="/var/www" depth=3       # Directory tree
inspect command="du.top_files" path="/var/log"          # Largest files
inspect command="du.dir_total" path="/home/user"        # Folder size
inspect command="sys.meminfo"                           # Memory info from /proc/meminfo
inspect command="sys.disk_free" path="/"                # Free disk space
inspect command="proc.list"                             # List of running processes
inspect command="proc.info" pid=1234                    # Details of a specific process
inspect command="svc.status" unit="nginx"               # systemd service status
inspect command="env.os_release"                        # Operating system version

A typical diagnostic scenario using these tools might look like this:

botinok "Figure out why Nginx is returning 502"

# The agent can automatically perform the following steps:
# 1. inspect command="svc.status" unit="nginx"        # Check Nginx service status
# 2. journal action="unit_tail" unit="nginx"          # View latest Nginx logs
# 3. read /etc/nginx/sites-enabled/default            # Read Nginx configuration file
# 4. grep /var/log/nginx "error" "*.log"              # Search for errors in Nginx logs
# 5. inspect command="proc.list" | grep "php-fpm"     # Check if backend (e.g., PHP-FPM) is running

This allows the agent to autonomously select and apply the necessary tools to solve the given task, minimizing manual intervention.

Diagnostics with Journal: Deep Log Analysis

For working with system logs, Bootinok uses a specialized journal tool that interacts with systemd-journald. This is significantly more effective than a simple grep across /var/log, as journalctl provides structured access to logs with filtering capabilities by time, priority, unit, and other parameters.

Key journal actions:

• tail: Retrieves the last N lines of logs. Example: tail lines=100.
• unit_tail: Views logs for a specific systemd unit. Example: unit_tail unit="docker" lines=200.
• since: Filters logs by start time. Example: since since="2 hours ago".
• query: Combines various filters to retrieve specific logs. Example: query unit="nginx" grep="error" since="today".
• stats: Retrieves logging level statistics for a specific unit over a given period. This allows the agent to quickly assess the overall picture of errors and warnings.

Example statistics the agent can obtain:

{
  "action": "stats",
  "unit": "nginx",
  "since": "1 hour ago",
  "levels": {
    "emerg": 0, "alert": 0, "crit": 0,
    "err": 12,
    "warning": 45,
    "notice": 120,
    "info": 340,
    "debug": 0
  }
}

Such detailed information enables the agent not only to find specific errors but also to assess the overall system stability, identifying trends and potential problems before they escalate.

Architecture and Security: Key Aspects

The philosophy of Bootinok as a tool, rather than a continuously running service, underpins its architecture. This application launches on user demand, performs the assigned task using available tools, and then terminates. This approach significantly reduces system resource consumption, especially VRAM, as the LLM doesn't need to reside in memory constantly.

Key security and design aspects:

• Read-only operations by default: Most tools, such as file_system and journal, operate in read-only mode, preventing accidental or malicious changes to the system. The ability to execute shell_exec requires an explicit --dangerous flag.
• Contextual management: For handling large volumes of data (e.g., logs or web pages), pagination and content truncation with a [TRUNCATED] marker are used. The full data is saved in the session, allowing the agent to access it if needed without overloading the LLM's context window.
• Minimal dependencies: Reliance on native console utilities like lynx and journalctl minimizes the number of external dependencies and simplifies deployment.
• Ollama flexibility: Using Ollama allows users to select and run various LLM models depending on available resources and specific tasks, from smaller models for local work to larger ones on remote servers.

Bootinok demonstrates how the potential of LLMs can be effectively utilized for automating complex and routine system administration tasks, while maintaining control, security, and minimal resource consumption. It's a reliable tool for those who value efficiency and work within a console environment.

Key Takeaways

• Bootinok is a console AI agent designed for automating tasks on Linux servers via SSH, operating with limited VRAM resources.
• It functions as an on-demand tool, rather than a constantly active daemon, minimizing system resource consumption.
• It uses Ollama for LLM integration and provides a wide range of tools via Function Calling, including web search (via lynx), file system navigation, and systemd log analysis.
• It ensures security through read-only operations by default and requires explicit confirmation for potentially dangerous commands.
• It is optimized for system administrators, DevOps engineers, and developers who need efficient and lightweight automation in the terminal.

— Editorial Team