OpenClaw Gateway

OpenClaw is the AI agent gateway that provides a unified interface for managing, scheduling, and orchestrating AI agent tasks within Arcturus-Prime. It lives in the vault at projects/openclaw/ and is accessible through native admin pages at /admin/openclaw. OpenClaw was originally embedded via iframe but has been migrated to native Astro pages for tighter integration with the Arcturus-Prime admin shell.

Architecture Overview

OpenClaw sits between the Arcturus-Prime admin panel and the underlying AI agents (primarily Argonaut). It provides three core functions:

Skills management — a registry of discrete capabilities that agents can execute
Cron scheduling — automated task execution on configurable schedules
Configuration — centralized settings for agent behavior, routing, and resource limits

The gateway receives requests from the admin UI, validates permissions, routes them to the appropriate agent, and reports results back. It maintains its own state for skill definitions, cron schedules, and execution history.

Relationship to Argonaut

OpenClaw and Argonaut are complementary systems. Argonaut is the agent itself, with its own identity, memory, and tools. OpenClaw is the gateway that manages how and when Argonaut (and potentially other agents) are invoked. Think of Argonaut as the worker and OpenClaw as the dispatcher.

In practice:

OpenClaw manages the skill catalog and decides which agent handles which skill
Argonaut executes the actual work using its tool system and RAG knowledge
OpenClaw tracks execution history and handles retry logic
Argonaut maintains conversational memory and personal context

Native Admin Pages

OpenClaw is integrated into the Arcturus-Prime admin panel through three native routes. The migration from iframe to native pages was driven by the need for consistent authentication, shared component access (CommandPalette, NotificationSystem), and proper deep-linking support.

/admin/openclaw — Gateway Dashboard

The main OpenClaw page provides an overview of the gateway’s current state:

Activity Feed — a chronological list of recent skill executions showing:

Skill name and trigger source (manual, cron, webhook, agent)
Start time, duration, and status (success, failure, running, queued)
Agent that handled the execution
Abbreviated output with expand-to-full option

System Health — real-time metrics for the gateway:

Active executions count
Queue depth (pending tasks waiting for an agent)
Average execution time over the last hour
Success rate (percentage of executions that completed without error)
Connected agents and their status

Quick Actions — buttons for common operations:

Trigger a skill manually
Create a new skill
Pause all cron jobs
Flush the execution queue
View execution logs

/admin/openclaw/skills — Skills Management

The skills page provides full CRUD management for the skill registry.

What is a Skill?

A skill is a discrete, named capability that an agent can execute. Each skill definition includes:

interface Skill {
  id: string;                    // Unique identifier (slug format)
  name: string;                  // Human-readable name
  description: string;           // What the skill does
  agent: string;                 // Which agent handles this skill
  trigger: SkillTrigger;         // How the skill can be invoked
  parameters: ParameterSchema;   // Input parameters and validation
  timeout: number;               // Maximum execution time in seconds
  retryPolicy: RetryPolicy;      // Retry configuration on failure
  enabled: boolean;              // Whether the skill is active
  tags: string[];                // Categorization tags
  createdAt: string;             // ISO 8601 timestamp
  updatedAt: string;             // ISO 8601 timestamp
}

Skill Triggers

Skills can be triggered through multiple channels:

Manual — invoked directly from the admin UI by clicking the “Run” button
Cron — executed on a schedule (managed through the cron page)
Webhook — triggered by an HTTP POST to /api/openclaw/skills/:id/trigger
Agent — invoked by another agent during a multi-agent workflow
Event — triggered by system events (content published, build completed, probe failed)

Skill List View

The skills page displays all registered skills in a filterable, sortable table:

Column	Description
Name	Skill name with status indicator (enabled/disabled)
Agent	Which agent handles the skill
Trigger	Available trigger types
Last Run	When the skill last executed and its result
Avg Duration	Average execution time across recent runs
Success Rate	Percentage of successful executions

Skill Editor

Clicking a skill opens the editor with tabs for:

Configuration — edit name, description, agent assignment, timeout, and retry policy
Parameters — define input parameters with types, defaults, and validation rules
Test — run the skill with test parameters and see the result immediately
History — execution log for this specific skill with filtering and search
Logs — detailed execution logs including agent tool calls and intermediate outputs

Built-in Skills

Arcturus-Prime ships with several pre-configured skills:

daily-briefing — compiles calendar, email, and task summaries into a morning briefing
content-review — scans the review queue and generates editorial recommendations
site-health-check — runs probe suites against all Arcturus-Prime services and reports status
rag-reindex — triggers a full or incremental rebuild of the RAG embedding index
blog-draft — generates a blog post draft from a topic and outline using the voice profile
security-scan — runs the full security scan suite and reports findings
backup-verify — checks that recent backups on Meridian-Host (192.168.20.50) completed successfully
certificate-check — verifies SSL certificate validity for Arcturus-Prime.com, gitea.Arcturus-Prime.com, and cloud.Arcturus-Prime.com

/admin/openclaw/cron — Cron Job Scheduling

The cron page manages scheduled execution of skills. It provides a calendar-style view of upcoming executions and a list of all configured cron jobs.

Cron Job Definition

Each cron job links a skill to a schedule:

interface CronJob {
  id: string;                    // Unique identifier
  skillId: string;               // Which skill to execute
  schedule: string;              // Cron expression (e.g., "0 7 * * *")
  parameters: Record<string, any>;  // Fixed parameters for this schedule
  enabled: boolean;              // Whether the job is active
  lastRun: string | null;        // ISO 8601 timestamp of last execution
  nextRun: string;               // ISO 8601 timestamp of next scheduled run
  timezone: string;              // IANA timezone (default: "America/Chicago")
}

Schedule Management

The cron page displays:

Active Jobs — list of all enabled cron jobs with their next run time, last run status, and schedule in human-readable format (e.g., “Every day at 7:00 AM CST”)
Paused Jobs — disabled jobs that can be re-enabled
Calendar View — a 7-day forward view showing when jobs are scheduled to run, with color coding by skill category
Execution History — a log of past cron executions with success/failure indicators

Creating a Cron Job

The creation flow:

Select a skill from the registry
Set the cron expression (with a helper UI that translates human-readable schedules to cron syntax)
Configure parameters (pre-fill from skill defaults or customize)
Set timezone (defaults to America/Chicago)
Enable/disable toggle
Save

Cron Expression Helper

The UI includes a cron expression builder that lets users set schedules without knowing cron syntax:

Preset options: every minute, hourly, daily, weekly, monthly
Custom builder: select minute, hour, day of month, month, day of week
Human-readable preview: “Runs at 7:00 AM every Monday and Thursday”
Next 5 occurrences preview

Conflict Detection

The scheduler detects when multiple cron jobs are scheduled to run at the same time and warns the administrator. If the conflicting jobs use the same agent, the scheduler queues them sequentially rather than attempting parallel execution, to prevent resource contention.

Default Cron Schedule

Arcturus-Prime ships with a default cron configuration:

Job	Schedule	Skill	Description
Morning Briefing	`0 7 * * *`	daily-briefing	Daily summary at 7 AM
Content Review	`0 12 * * 1`	content-review	Weekly Monday review
Health Check	`/15 * * *`	site-health-check	Every 15 minutes
RAG Reindex	`0 3 * * 0`	rag-reindex	Weekly Sunday rebuild
Security Scan	`0 2 * * 1`	security-scan	Weekly Monday scan
Backup Verify	`0 6 * * *`	backup-verify	Daily at 6 AM
Cert Check	`0 9 1 * *`	certificate-check	Monthly on the 1st

Configuration

OpenClaw configuration is managed through the gateway dashboard and stored in the vault. Key configuration areas:

Agent Registry

Defines which agents OpenClaw can dispatch work to:

Agent name — identifier used in skill definitions
Endpoint — HTTP URL for the agent’s API (e.g., http://10.42.0.2:3100 for Argonaut on Proxmox Izar-Host)
Health check — URL to ping for agent liveness
Capabilities — tags describing what the agent can do (used for automatic skill routing)
Priority — when multiple agents can handle a skill, higher priority agents are preferred

Resource Limits

Global and per-agent limits:

Maximum concurrent executions (default: 5)
Maximum execution time per skill (default: 300 seconds)
Maximum queue depth (default: 50)
Maximum retry attempts (default: 3)

Notification Rules

Configure who gets notified for different execution outcomes:

All failures notify admin users via the NotificationSystem
Specific skills can have custom notification targets (email, webhook)
Success notifications are disabled by default but can be enabled per skill

Model Fallback Chain

Claw uses a multi-provider fallback chain for resilience. When the primary model rate-limits, the gateway automatically tries the next provider. For full details on models, providers, auth configuration, cron jobs, heartbeat system, and troubleshooting, see the Operations & Model Configuration doc.

Priority	Provider	Model
Primary	Groq	`llama-4-scout-17b-16e-instruct`
Fallback 1	Cerebras	`llama-3.3-70b`
Fallback 2	SambaNova	`Meta-Llama-3.3-70B-Instruct`
Fallback 3	OpenRouter	`google/gemini-2.5-flash`
Fallback 4	OpenRouter	`qwen/qwen3-235b-a22b-2507`
Fallback 5	NVIDIA NIM	`meta/llama-3.3-70b-instruct`

The deep agent uses openrouter/anthropic/claude-sonnet-4-5-20250929 for complex reasoning.

Config repo: git.Arcturus-Prime.com/Arcturus-Prime/openclaw-config (private)

Channels

Telegram (@argobox_oc_bot)

Claw is accessible via Telegram DM through the @argobox_oc_bot bot. This enables mobile interaction — send commands, get alerts, and chat with Claw from anywhere. First DM triggers a pairing flow; admin approves inside the container with npx openclaw pairing approve telegram <CODE>.

Web UI

Primary interface at https://oc.Arcturus-Prime.com (CF Access protected) and embedded natively in Arcturus-Prime admin at /admin/openclaw.

Voice (Twilio)

Phone call interface via Twilio. Configured but not yet tested end-to-end. See the voice-call plugin config for details.

Email System

The email system at /admin/email uses Cloudflare Email Routing for inbound and Resend for outbound, with D1 for storage. It supports multiple mailboxes (admin@, noreply@, support@, daniel@ Arcturus-Prime.com), three-phase deletion (trash → purge → permanent), and AI-assisted compose/summarize. See Email System for full details.

Vault Documentation

The OpenClaw project in the vault includes comprehensive documentation:

DEPLOYMENT-REFERENCE.md — deployment architecture, file layout, model chain, network, troubleshooting
VISION-AND-ROADMAP.md — long-term vision for the agent gateway, planned features, and integration roadmap
SECURITY-MODEL.md — security architecture including authentication, authorization, sandboxing, and audit logging for agent operations
STATUS.md (in ~/Vaults/Arcturus-Prime/projects/openclaw/) — comprehensive project status with session history, known issues, and roadmap progress