DOCSEARCHbyAlgolia
Submit Docs

Arkloop Documentation

repository·main·Indexed 18 days ago

https://github.com/qqqqqf-q/arkloop

An open-source, design-focused AI Agent platform featuring multi-model routing, sandboxed code execution via Firecracker or Docker, and persistent memory. Arkloop provides a desktop application, CLI, and web-based runtime, supporting Model Context Protocol (MCP), Agent Communication Protocol (ACP), and custom personas with Lua scripting.

Tokens
183.6K
Snippets
575
Records
875
Agent score
62%

What's inside Arkloop

  2. Overview of Arkloop features

    main

    Arkloop is an AI Agent platform providing several core capabilities:

    • Multi-Model Routing: Supports OpenAI, Anthropic, and compatible APIs with priority-based automatic routing and rate limit handling.
    • Sandboxed Execution: Runs code in Firecracker microVMs or Docker containers with strict resource limits.
    • Persistent Memory: Preserves system constraints, long-term facts, and session context.
    • Prompt Injection Protection: Uses semantic-level scanning to block injection attacks.
    • Channel Integration: Supports Telegram with media handling and group context.
    • Custom Personas: Supports independent system prompts, tool sets, and Lua scripting for behavior configuration.
    • MCP / ACP: Supports Model Context Protocol and Agent Communication Protocol.
    • Skill Ecosystem: Import skills from ClawHub (compatible with OpenClaw SKILL.md format).

  3. Overview of Arkloop Settings categories

    main

    Arkloop settings are organized into focused categories accessible via the Settings sidebar. Most categories operate independently, allowing you to configure specific subsystems without affecting others.

    Available Settings Categories

    CategoryDescription
    GeneralConfigure language, timezone, startup behavior, and notifications.
    AppearanceCustomize theme, fonts, color schemes, and backgrounds.
    ProvidersManage LLM provider connections and model management.
    ChannelsSet up integrations for Telegram, Discord, Feishu, QQ, and WeChat.
    PluginsManage installed plugins and access the marketplace.
    SkillsConfigure skill packages from ClawHub or local sources.
    MCPConfigure Model Context Protocol (MCP) servers.
    NotebookManage manual notes that are injected into every conversation.
    MemoryConfigure auto-organized semantic memory.
    ChatAdjust auto-compaction settings and execution modes.
    ToolsConfigure web search and fetch provider settings.
    AdvancedHandle data import/export, network settings, usage stats, logs, and modules.

  4. Getting Started with Arkloop

    main

    Arkloop is a desktop application designed for building conversational AI agents. It provides built-in capabilities for personas, memory, and tool execution, allowing you to start building agents immediately once an API key is configured.

    To begin using Arkloop, you can follow these paths:

    • Installation: Download and install the application for macOS, Windows, or Linux.
    • Quick Start: Follow the first-launch setup wizard to configure your environment.
    • Interface Overview: Familiarize yourself with the application layout, including the sidebar, chat area, and settings.

  5. What is Arkloop

    main

    Arkloop is an open-source platform designed for conversational AI Agents. It provides a managed runtime that integrates several core capabilities:

    • Multi-model routing: Support for OpenAI, Anthropic, and compatible APIs with priority-based routing and rate limiting.
    • Tool execution: Integration with tools and extensions.
    • Sandbox code execution: Isolated environments for running code (e.g., Firecracker on Linux for production, or Docker containers for development/desktop).
    • Persistent memory: Long-term facts and constraints that persist across sessions, implemented via OpenViking semantic memory and Notebook structured notes.
    • Prompt injection protection: Security constraints like semantic-level scanning.
    • Persona-based agents: Each agent can have independent system prompts, tool allowlists, and budgets.
    • Extensibility: Support for MCP (Model Context Protocol) and Skills (compatible with OpenClaw SKILL.md format, importable from ClawHub).

  6. Overview of Arkloop Worker (Go)

    main

    The Arkloop Worker is a Go-based service that implements the core execution loop of the system. Its primary responsibilities include:

    1. Job Consumption: Consuming run.execute tasks from the Postgres jobs queue.
    2. Execution: Running the native RunEngine, which handles Provider routing, the Agent Loop, Tools, Personas, and MCP (Model Context Protocol).
    3. Event Logging: Writing execution events to the run_events table, which the API uses for SSE (Server-Sent Events) playback.

  7. Explore Arkloop Features

    main

    Arkloop provides several core capabilities for managing conversational AI, including:

    • Chat: Interactive interfaces for agent communication.
    • Agents: Built-in and customizable AI agents.
    • Memory: Persistent state and context management for conversations.
    • Tools: Execution capabilities for agents to interact with external systems.
    • Channels: Support for various communication channels.

    Detailed information on each feature can be found in the Features documentation.

  8. Manage Tool Providers and Credentials

    main

    Tool Providers allow you to manage backend providers, credentials, and base URLs for built-in Tool Groups (such as web_search or web_fetch).

    Configuration is managed at two layers:

    • scope=platform: Global defaults for the entire platform. Requires platform_admin permissions.
    • scope=org: Organization-specific overrides. Requires data.secrets permission within the organization to manage sensitive credentials.

  10. Review Arkloop third-party licenses

    main

    Arkloop uses 154 direct third-party dependencies. All dependencies use permissive licenses (MIT, Apache-2.0, BSD, ISC, MPL-2.0). There are no copyleft (GPL/AGPL/LGPL) dependencies present in the project.

    License Summary

    • MIT: 71
    • Apache-2.0: 40
    • BSD-3-Clause: 32
    • ISC: 5
    • BSD-2-Clause: 5
    • MPL-2.0: 1

  12. Design principles for Generative UI tools

    main

    When building Generative UI components (widgets/tools) for Arkloop, follow these core philosophy principles to ensure a seamless user experience:

    • Seamless Integration: Design widgets so they blend into the host UI. Avoid decorative effects like gradients, mesh backgrounds, or noise textures; use clean, flat surfaces.
    • Compactness: Show only essential information inline. Use the tool for visuals (diagrams, charts, interactive widgets) and keep explanatory text in the main chat response.
    • Separation of Concerns: Text goes in your response, visuals go in the tool. Never put paragraphs of explanation, section headings, or descriptive prose inside the HTML/SVG tool output. If a user asks to "explain X", provide the explanation in the chat text and use the tool only for the accompanying visual.
    • Streaming Optimization: Structure code so useful content appears early.
      • HTML: <style> (short) $\rightarrow$ content HTML $\rightarrow$ <script> (last).
      • SVG: <defs> (markers) $\rightarrow$ visual elements immediately.
      • Use inline style="..." for inputs/controls so they look correct mid-stream. Keep <style> blocks under ~15 lines to avoid bloat.