DEV Community: steven x

FastClaw in Action: Automate Your Work with Cron Jobs

steven x — Sun, 29 Mar 2026 08:32:56 +0000

In daily work, we often need to handle various repetitive tasks: generating reports daily, backing up data on schedule, checking system status periodically, etc. FastClaw has a powerful built-in Cron scheduling system that makes these repetitive tasks simple and automated.

What is Cron?

Cron is a classic time-based job scheduler that uses cron expressions to define task execution times. FastClaw brings this concept into the AI Agent world, allowing you to define and manage scheduled tasks using natural language.

Cron Expression Basics

FastClaw uses the standard 5-field cron expression:

┌───────────── minute (0-59)
│ ┌───────────── hour (0-23)
│ │ ┌───────────── day (1-31)
│ │ │ ┌───────────── month (1-12)
│ │ │ │ ┌───────────── day of week (0-7, 0 and 7 are Sunday)
│ │ │ │ │
* * * * *

Common Cron Expression Examples

Expression	Meaning	Use Case
`/5 * * *`	Every 5 minutes	Real-time monitoring, data collection
`0 * * * *`	Every hour on the hour	Hourly reports, resource cleanup
`0 9 * * *`	Daily at 9:00 AM	Morning reports, daily generation
`0 9,18 * * *`	Daily at 9 AM and 6 PM	Morning and evening reports
`0 9 * * 1-5`	Weekdays at 9:00 AM	Weekday daily reports
`30 4 * * 0`	Sunday at 4:30 AM	Weekly reports, backups
`0 0 1 * *`	First day of month	Monthly reports
`/15 9-17 * 1-5`	Weekdays 9-17 every 15 min	Work hour monitoring

Quick Start

Start Cron Service

FastClaw's Cron service starts with the main service by default:

# Start service (includes Cron service)
python main.py start

# View Cron task list
python main.py cron list

Create Your First Scheduled Task

Create via Web UI

Open http://localhost:8765
Switch to Cron tab
Click New Task
Fill in task information:
- Task Name: Daily Weather Report
- Cron Expression: 0 8 * * *
- Agent: main_agent
- Command: Query Beijing weather and save to file
Click Save

Create via Configuration File

Edit workspace/data/cron/tasks.json:

{
  "tasks": [
    {
      "name": "Daily Weather Report",
      "cron": "0 8 * * *",
      "agent": "main_agent",
      "session_id": "weather_report",
      "command": "Query Beijing weather and save to workspace/weather_report.txt",
      "enabled": true
    }
  ]
}

Practical Use Cases

Case 1: Automated Data Backup

Requirement

Automatically backup important data to a specified directory at 2 AM daily.

Implementation

{
  "name": "Daily Data Backup",
  "cron": "0 2 * * *",
  "agent": "main_agent",
  "session_id": "backup_task",
  "command": "Create backup: backup workspace/data directory to workspace/backups/backup_$(date +%Y%m%d).tar.gz",
  "enabled": true
}

Task Execution Process

When FastClaw executes this task, it will:

Trigger cron.triggered event
Agent parses command: "Create backup: backup workspace/data directory to..."
Agent calls run_shell to execute backup command:

   mkdir -p workspace/backups
   tar -czf workspace/backups/backup_$(date +%Y%m%d).tar.gz workspace/data

Save execution result to log

Case 2: Scheduled Work Report Generation

Requirement

Automatically generate work report before end of each workday (6 PM).

Implementation

{
  "name": "Work Report Generation",
  "cron": "0 18 * * 1-5",
  "agent": "main_agent",
  "session_id": "daily_report",
  "command": "Summarize today's work and generate a concise work report, save to workspace/reports/daily_$(date +%Y%m%d).md",
  "enabled": true
}

Task Execution Process

Trigger cron.triggered event
Agent understands task: "Summarize today's work, generate report"
Agent may:
- Read today's chat logs and work files
- Analyze work content
- Generate summary report
- Save to specified file

Case 3: System Health Check

Requirement

Check system resource usage every 15 minutes, alert if abnormal.

Implementation

{
  "name": "System Health Check",
  "cron": "*/15 * * * *",
  "agent": "main_agent",
  "session_id": "health_check",
  "command": "Check system resources: if CPU > 90% or Memory > 85%, send alert to feishu; otherwise log normal status to workspace/logs/health_$(date +%Y%m%d_%H%M).log",
  "enabled": true
}

Alert Logic

Agent automatically determines whether to alert:

Normal state: Resource usage is normal → Log status
Alert state: Resource usage too high → Call run_skills("feishu", {...}) to send Feishu message

Case 4: Scheduled News Aggregation

Requirement

Automatically fetch tech news and generate newsletter every morning at 8 AM.

Implementation

{
  "name": "Tech News Morning Brief",
  "cron": "0 8 * * *",
  "agent": "main_agent",
  "session_id": "tech_news",
  "command": "Fetch latest AI/programming tech news, generate newsletter and save to workspace/news/tech_daily_$(date +%Y%m%d).md",
  "enabled": true
}

Execution Steps

run_shell("curl https://news.example.com/tech.rss") - Fetch RSS feed
Parse news content
Generate newsletter format
Save to file

Case 5: Scheduled Database Sync

Requirement

Sync database to backup server every hour.

Implementation

{
  "name": "Database Scheduled Sync",
  "cron": "0 * * * *",
  "agent": "main_agent",
  "session_id": "db_sync",
  "command": "Execute database sync: export local database and sync to remote backup server 192.168.1.100's /backup/db/ directory",
  "enabled": true
}

Sync Script

Agent may execute:

mysqldump -u root -ppassword fastclaw_db > backup.sql
scp backup.sql user@192.168.1.100:/backup/db/

Task Management Commands

View Task List

python main.py cron list

Example output:

Task Name              Cron Expression    Status    Last Run
--------------------------------------------------------------
Daily Weather Report   0 8 * * *         Enabled   2024-01-15 08:00:00
Daily Data Backup      0 2 * * *         Enabled   2024-01-15 02:00:00
Work Report Generation 0 18 * * 1-5      Enabled   2024-01-15 18:00:00
System Health Check    */15 * * * *      Enabled   2024-01-15 10:45:00

Manually Trigger Task

# Execute specified task immediately
python main.py cron run Daily Weather Report

# Execute all tasks immediately
python main.py cron run --all

Enable/Disable Task

# Disable task
python main.py cron disable Daily Weather Report

# Enable task
python main.py cron enable Daily Weather Report

Delete Task

python main.py cron del Daily Weather Report

Task Logs and Monitoring

View Execution Logs

# View recent logs
tail -f workspace/data/cron/logs/fastclaw_cron.log

# View specific task log
cat workspace/data/cron/logs/tasks/Daily\ Weather\ Report.log

Log Format

2024-01-15 08:00:00 [INFO] Task triggered: Daily Weather Report
2024-01-15 08:00:01 [INFO] Executing command: Query Beijing weather and save to workspace/weather_report.txt
2024-01-15 08:00:03 [INFO] Execution result: Success
2024-01-15 08:00:03 [INFO] Execution time: 2.3s

Set Alert Notifications

Configure in workspace/data/settings.json:

{
  "cron": {
    "on_failure": "notify",
    "notification_channel": "feishu",
    "retry_times": 3,
    "retry_interval": 60
  }
}

Advanced Usage

1. Task Dependency Chains

Create dependency chains where one task triggers the next after completion:

{
  "name": "Task A: Data Collection",
  "cron": "0 9 * * *",
  "agent": "main_agent",
  "session_id": "task_a",
  "command": "Collect yesterday's sales data and save to workspace/data/sales_raw.json",
  "enabled": true
},
{
  "name": "Task B: Data Analysis",
  "cron": "0 10 * * *",
  "agent": "main_agent",
  "session_id": "task_b",
  "command": "Read workspace/data/sales_raw.json, perform data analysis and generate report",
  "enabled": true
}

2. Conditional Execution

Use natural language for Agent to autonomously decide whether to execute:

{
  "name": "Smart Backup",
  "cron": "0 2 * * *",
  "agent": "main_agent",
  "session_id": "smart_backup",
  "command": "Check if there were important updates today, if so perform backup; otherwise skip and log: No backup needed today",
  "enabled": true
}

3. Recurring Tasks

Create recurring tasks at intervals:

{
  "name": "Long Task Monitoring",
  "cron": "*/30 * * * *",
  "agent": "main_agent",
  "session_id": "monitor",
  "command": "Check status of previously started build task, if complete send notification and record result",
  "enabled": true
}

4. Context Preservation

Long-running tasks can preserve context across sessions:

{
  "name": "Large File Processing",
  "cron": "0 3 * * *",
  "agent": "main_agent",
  "session_id": "big_file_task",
  "session_persistence": true,
  "command": "Continue processing previously unfinished large file analysis task",
  "enabled": true
}

Best Practices

1. Task Design Principles

Single Responsibility: Each task does one thing
Idempotency: Tasks can be safely executed multiple times
Fast Execution: Avoid long execution times for single tasks
Clear Logging: Record sufficient execution info for troubleshooting

2. Time Planning Suggestions

Task Type	Recommended Time	Reason
Data Backup	2-4 AM	Lowest system load
Daily Report	1 hour before end of work	Work content is complete
Health Check	During work hours	Catch issues promptly
Data Sync	On the hour	Easy to align
Report Generation	8-9 AM	Ready before work starts

3. Resource Optimization

Stagger Execution: Avoid multiple tasks running simultaneously
Merge Tasks: Combine related small tasks
Incremental Processing: Prioritize processing incremental data

4. Monitoring and Alerts

Critical Tasks: Must set failure alerts
Normal Tasks: Log only is sufficient
Long-running Tasks: Check progress periodically

Troubleshooting

Task Not Executing

Check if task is enabled: python main.py cron list
Check if Cron service is running: ps aux | grep fastclaw
Check system logs: journalctl -u fastclaw
Verify cron expression is correct

Task Execution Failed

View task log: cat workspace/data/cron/logs/tasks/TaskName.log
Manual execution test: python main.py cron run TaskName
Check Agent configuration: vim workspace/data/agents/main_agent/metadata.json
Confirm LLM API is available

Task Execution Timeout

Default task timeout is 5 minutes. Adjust in configuration if longer execution is needed:

{
  "cron": {
    "task_timeout": 600
  }
}

Summary

FastClaw's Cron scheduled task system makes workflow automation simple and powerful. Through natural language interaction, you can:

Easy Creation: Describe tasks in natural language, no coding required
Flexible Scheduling: Support various cron expressions for complex timing needs
Smart Execution: Agent autonomously decides, can handle complex logic
Complete Logging: Detailed execution records for tracking and troubleshooting
Alert Notifications: Automatic notifications on task failure for prompt handling

Whether you're a personal user or enterprise user, FastClaw's Cron functionality enables workflow automation, letting AI handle repetitive tasks so you can focus on more valuable work.

Related Resources

GitHub: https://github.com/kandada/fastclaw
Cron Expression Generator: https://crontab.guru/
Configuration Examples: Reference workspace/data/cron/tasks.json

Start your automation journey today!

FastMind: A Lighter Alternative to LangGraph for Python Agent Development

steven x — Sun, 29 Mar 2026 08:28:10 +0000

In the AI Agent development landscape, LangGraph is a well-known framework. But if you're looking for a lighter, simpler, and faster development alternative, FastMind deserves your attention.

Project Positioning

LangGraph

Positioning: Enterprise-level Agent development framework
Features: Comprehensive functionality, supports complex workflows
Complexity: High, steep learning curve
Ecosystem: Part of the LangChain ecosystem

FastMind

Positioning: Lightweight Python Agent development framework
Features: Minimalist design, event-driven, high performance
Complexity: Low, easy to get started
Ecosystem: Independent framework, focused on core functionality
GitHub: https://github.com/kandada/fastmind

Core Design Philosophy

FastMind's Design Philosophy

Event-Driven First: Zero polling, high-performance asynchronous execution
State Graph Visualization: Define workflows with Graphs, clear and intuitive
Minimalist API: Reduce boilerplate code, improve development efficiency
Python Native: Fully leverage Python's async ecosystem

Core Philosophy Differences vs LangGraph

Aspect	LangGraph	FastMind
Design Goal	Enterprise complete solution	Lightweight rapid development
Architecture Complexity	High (multiple abstraction layers)	Low (direct and transparent)
Learning Cost	High (need to understand LangChain ecosystem)	Low (independent framework)
Deployment Complexity	High (many dependencies)	Low (few dependencies)

Technical Architecture Comparison

LangGraph Architecture

LangChain → LangGraph → State Machine → Tool Execution
    ↑
Complex middleware, callbacks, monitoring systems

Characteristics:

Complete LangChain ecosystem integration
Rich middleware support
Complex state management
Enterprise-level feature completeness

FastMind Architecture

Event Input → FastMind Engine → State Graph Execution → Output
    ↑
Simple event queue, state management, tool system

Characteristics:

Single process, lightweight
Event-driven, zero polling
State graph defines workflows
Minimalist tool system

Core Features Comparison

1. Event-Driven Architecture

LangGraph Event Handling

# Need to manually handle event loops
async def process_event(event):
    # Complex event routing logic
    pass

FastMind Event Handling

# Native event-driven
@app.perception(interval=60.0)
async def cron_checker(app: FastMind):
    while True:
        yield Event(type="cron.triggered", payload={...})
        await asyncio.sleep(60.0)

Advantage: FastMind's event-driven architecture is native, no additional event loop management needed.

2. State Graph Definition

LangGraph State Graph

# Complex configuration and decorators
@graph.node
def my_node(state):
    # Node logic
    return state

# Need to understand LangGraph's state machine concepts

FastMind State Graph

# Simple graph definition
graph = Graph()
graph.add_node("agent", my_agent)
graph.add_node("tools", tool_node)

# Conditional edges
graph.add_conditional_edges("agent", route, {
    "tools": "tools",
    None: "__end__"
})

Advantage: FastMind's state graphs are more intuitive, similar to traditional flowcharts.

3. Tool System

LangGraph Tools

# Need to integrate LangChain tools
from langchain.tools import Tool

tool = Tool(
    name="my_tool",
    func=my_function,
    description="My tool"
)

FastMind Tools

# Simple decorator definition
@app.tool(name="my_tool", description="My tool")
async def my_tool(param: str) -> str:
    return f"Result: {param}"

Advantage: FastMind's tool definitions are simpler, no need to understand complex LangChain tool systems.

4. Streaming Output

LangGraph Streaming Output

# Need to manually handle streaming responses
async for chunk in stream:
    # Process streaming data
    pass

FastMind Streaming Output

# Native streaming support
async for chunk in stream:
    if delta.content:
        output_queue.put_nowait(Event(
            type="stream.chunk",
            payload={"delta": delta.content}
        ))

Advantage: FastMind's streaming output is framework-native, simpler integration.

Performance Comparison

Benchmark Metrics

Metric	LangGraph	FastMind	Advantage
Startup Time	Slower (loading LangChain)	Faster (lightweight dependencies)	FastMind 2-3x faster
Memory Usage	Higher (full ecosystem)	Lower (core functionality)	FastMind saves 30-50%
Response Latency	Higher (multiple abstraction layers)	Lower (direct processing)	FastMind 20-40% lower latency
Concurrent Processing	Needs configuration	Native support	FastMind better concurrency

Performance Advantage Analysis

Event-Driven: Zero polling wait, reduces CPU idle time
Lightweight Design: Reduces unnecessary abstraction layers
Async Native: Fully utilizes Python asyncio
Memory Optimization: Intelligent context management, prevents memory leaks

Development Experience Comparison

Code Complexity Comparison

LangGraph Example: Simple Agent

from langgraph.graph import StateGraph, END
from langchain_core.messages import HumanMessage
from langchain_openai import ChatOpenAI

# Define state
class AgentState(TypedDict):
    messages: list

# Create graph
graph = StateGraph(AgentState)

# Define node
def call_model(state: AgentState):
    model = ChatOpenAI()
    messages = state["messages"]
    response = model.invoke(messages)
    return {"messages": messages + [response]}

# Add nodes and edges
graph.add_node("agent", call_model)
graph.add_edge("agent", END)
graph.set_entry_point("agent")

# Compile graph
app = graph.compile()

FastMind Example: Same Functionality

from fastmind import FastMind, Graph, Event

app = FastMind()

# Define Agent
@app.agent(name="my_agent")
async def my_agent(state: dict, event: Event) -> dict:
    user_text = event.payload.get("text", "")
    # Processing logic
    return {"response": "Hello from FastMind"}

# Create graph
graph = Graph()
graph.add_node("agent", my_agent)
graph.set_entry_point("agent")
app.register_graph("main", graph)

Lines of Code Comparison:

LangGraph: ~25 lines
FastMind: ~15 lines

Complexity Comparison:

LangGraph: Need to understand StateGraph, TypedDict, compilation concepts
FastMind: Simple decorators and graph operations

Debugging Experience Comparison

LangGraph Debugging

Need to understand complex state machines
Debug information may be hidden by multiple abstraction layers
Need familiarity with LangChain debugging tools

FastMind Debugging

State graph visualization, intuitive and clear
Event flow traceable, simple debugging
Lightweight, no complex middleware

Practical Use Cases

Case 1: Chatbot

LangGraph Implementation

Need to integrate LangChain's chat models, memory systems, toolchains, etc.

FastMind Implementation

@app.agent(name="chatbot", tools=["search", "calculator"])
async def chatbot(state: dict, event: Event) -> dict:
    # Simple chat logic
    return state

# State graph definition
graph = Graph()
graph.add_node("chat", chatbot)
graph.set_entry_point("chat")

Case 2: Automated Workflow

LangGraph Implementation

Need to configure complex workflow engines and task scheduling.

FastMind Implementation

# Scheduled task perceiver
@app.perception(interval=60.0)
async def task_scheduler(app: FastMind):
    tasks = get_pending_tasks()
    for task in tasks:
        yield Event(type="task.triggered", payload=task)

# Task processing Agent
@app.agent(name="task_processor")
async def task_processor(state: dict, event: Event) -> dict:
    task = event.payload
    # Process task
    return {"result": "Task completed"}

Case 3: Multi-Agent System

LangGraph Implementation

Need complex multi-agent coordination and communication mechanisms.

FastMind Implementation

# Define multiple Agents
@app.agent(name="analyzer")
async def analyzer(state: dict, event: Event) -> dict:
    # Analyze data
    return {"analysis": "..."}

@app.agent(name="reporter")
async def reporter(state: dict, event: Event) -> dict:
    # Generate report
    return {"report": "..."}

# Coordination graph
graph = Graph()
graph.add_node("analyze", analyzer)
graph.add_node("report", reporter)
graph.add_edge("analyze", "report")

Migration Guide

Migrating from LangGraph to FastMind

Migration Steps

Analyze Existing Workflow: Understand current graph structure and node logic
Rewrite Tool Definitions: Convert LangChain tools to FastMind tools
Refactor State Graph: Rewrite workflow with FastMind's Graph API
Update Event Handling: Change callbacks to event-driven
Test Validation: Ensure functional consistency and performance improvement

Migration Benefits

Performance Improvement: Reduce abstraction layers, improve execution efficiency
Code Simplification: Reduce boilerplate code, improve maintainability
Deployment Simplification: Reduce dependencies, simplify deployment process
Debugging Improvement: More intuitive state graphs and event flows

Migration Example

LangGraph Code

from langgraph.graph import StateGraph, END
from langchain.tools import Tool

def my_function(input: str) -> str:
    return f"Processed: {input}"

tool = Tool(name="my_tool", func=my_function)
graph = StateGraph(dict)
graph.add_node("process", lambda state: {"result": tool.run(state["input"])})
graph.add_edge("process", END)
graph.set_entry_point("process")
app = graph.compile()

FastMind Migrated Code

from fastmind import FastMind, Graph

app = FastMind()

@app.tool(name="my_tool", description="My tool")
async def my_tool(input: str) -> str:
    return f"Processed: {input}"

@app.agent(name="processor", tools=["my_tool"])
async def processor(state: dict, event: Event) -> dict:
    input_text = event.payload.get("input", "")
    # Tools are automatically called
    return state

graph = Graph()
graph.add_node("process", processor)
graph.set_entry_point("process")
app.register_graph("main", graph)

Technology Selection Recommendations

Choose LangGraph When

Enterprise Needs: Require complete LangChain ecosystem
Complex Workflows: Need advanced workflow functionality
Team Familiarity: Team already familiar with LangChain
Production Ready: Need enterprise-level monitoring and operations tools

Choose FastMind When

Rapid Development: Need quick prototyping and iteration
Lightweight Deployment: Resource-constrained or need lightweight solution
Performance Sensitive: Have requirements for performance and resource consumption
Simple Architecture: Prefer simple and transparent architecture design
Python Native: Want to fully utilize Python's async ecosystem

FastMind's Unique Advantages

1. Event-Driven Architecture

Zero Polling: Reduce CPU idle time
High Performance: Better resource utilization
Real-time Response: Low-latency event processing

2. State Graph Visualization

Intuitive Debugging: Workflow visualization
Easy to Understand: Define Agents like drawing flowcharts
Flexible Control: Support conditional branches and loops

3. Automatic Context Management

Intelligent Unloading: Automatically manage LLM context
Prevent Explosion: Avoid context length limits
Recovery Mechanism: Support context recovery

4. Minimalist API Design

Low Learning Cost: Quick to get started
Clean Code: Reduce boilerplate code
Easy Maintenance: Clear code structure

Ecosystem

FastMind Ecosystem Components

Core Framework: FastMind base framework
FastClaw: AI Agent assistant built on FastMind
Tool Library: Common tools and integrations
Community Contributions: User-contributed plugins and extensions

Integration with Python Ecosystem

Async Ecosystem: Native asyncio support
Web Frameworks: Can integrate with FastAPI, Django, etc.
Data Science: Support for NumPy, Pandas, etc.
AI/ML: Compatible with mainstream AI libraries

Getting Started with FastMind

Installation

pip install fastmind

Quick Example

from fastmind import FastMind, Graph, Event

app = FastMind()

@app.agent(name="hello_agent")
async def hello_agent(state: dict, event: Event) -> dict:
    name = event.payload.get("name", "World")
    return {"message": f"Hello, {name}!"}

graph = Graph()
graph.add_node("hello", hello_agent)
graph.set_entry_point("hello")
app.register_graph("main", graph)

# Usage
result = await app.process_event(Event("greet", {"name": "FastMind"}))
print(result["message"])  # Hello, FastMind!

Learning Resources

GitHub: https://github.com/kandada/fastmind
Documentation: README and example code
FastClaw: Complete application example based on FastMind
Community: GitHub Issues and Discussions

Conclusion

FastMind is not meant to replace LangGraph, but provides a lighter, simpler alternative. Its design philosophy is "less is more," making Agent development simpler and more efficient through minimalist API and event-driven architecture.

Core Value

Development Efficiency: Reduce boilerplate code, increase development speed
Runtime Performance: Event-driven, high resource utilization
Maintenance Cost: Clean code, easy to understand and maintain
Learning Curve: Simple concepts, quick to get started

Suitable Scenarios

Rapid Prototyping: Need to quickly validate ideas
Resource-Constrained: Need lightweight solutions
Performance-Sensitive: Have requirements for response time and resource consumption
Simple Architecture: Prefer transparent and direct architecture design

If you're looking for a lighter, simpler Python Agent framework than LangGraph, FastMind is a choice worth trying. It not only provides core Agent development functionality but also makes important optimizations in development experience and runtime performance.

Start your FastMind journey and experience simpler Agent development!

FastClaw 5-Minute Quick Start: From Installation to Your First Task

steven x — Sun, 29 Mar 2026 08:19:49 +0000

FastClaw is a lightweight Python AI Agent assistant built on the FastMind framework. This guide will take you from zero to hero in 5 minutes, covering installation, configuration, and your first task.

Prerequisites

Python 3.10+
pip package manager
An OpenAI-compatible API Key (DeepSeek recommended)

Step 1: Install FastClaw

Method 1: Clone from GitHub (Recommended)

# Clone the project
git clone https://github.com/kandada/fastclaw.git
cd fastclaw

# Create virtual environment (optional but recommended)
python -m venv .venv
source .venv/bin/activate  # Linux/Mac
# or .venv\Scripts\activate  # Windows

# Install dependencies
pip install -r requirements.txt

Method 2: Quick Install Script

# One-line installation script
curl -sSL https://raw.githubusercontent.com/kandada/fastclaw/main/install.sh | bash

Step 2: Configure LLM API

FastClaw supports all OpenAI-compatible APIs. We'll use DeepSeek as an example:

Get API Key

Visit DeepSeek website
Register and log in
Create a new API Key in the API Keys page

Configure FastClaw

Edit the configuration file:

vim workspace/data/agents/main_agent/metadata.json

Modify the content to:

{
  "llm": {
    "api_key": "your_deepseek_api_key_here",
    "base_url": "https://api.deepseek.com/v1",
    "model": "deepseek-chat"
  }
}

Other Supported LLMs

FastClaw supports all OpenAI-compatible interfaces:

Kimi: base_url: "https://api.moonshot.cn/v1", model: "kimi-k2.5"
Minimax: base_url: "https://api.minimax.chat/v1", model: "MiniMax-M2.7"
OpenAI: base_url: "https://api.openai.com/v1", model: "gpt-5.4"
Local models: Any locally deployed model supporting OpenAI format

Step 3: Start FastClaw

Start Web Service

# Start service (default port 8765)
python main.py start

# Or run in background
nohup python main.py start > fastclaw.log 2>&1 &

Verify Service

# Check service status
curl http://localhost:8765/health

# View logs
tail -f fastclaw.log

After service starts, open http://localhost:8765 to access the Web UI.

Step 4: Using Web UI

Interface Overview

FastClaw Web UI has three main tabs:

Chat: Interactive chat interface
Cron: Scheduled task management
Settings: System settings

First Conversation

Open http://localhost:8765
Type a message in the Chat page input box
Press Enter to send, Shift+Enter for new line

Example Conversation:

You: Hello, FastClaw!
FastClaw: Hello! I'm FastClaw, your AI assistant. I can help you execute commands, manage files, and automate tasks. How can I assist you today?

You: Show files in current directory
FastClaw: Executing run_shell("ls -la")
(Shows current directory file list)

Step 5: Basic Functionality Experience

1. File Operations

You: Show README.md file content
FastClaw: Executing run_shell("cat README.md")

You: Create test.txt file in current directory
FastClaw: Executing run_shell("echo 'Test content' > test.txt")

2. System Information

You: Check system memory usage
FastClaw: Executing run_shell("free -h")

You: Check disk space
FastClaw: Executing run_shell("df -h")

3. Network Requests

You: Get current time
FastClaw: Executing run_shell("date")

You: Query weather (requires network)
FastClaw: Executing run_shell("curl wttr.in/London?format=3")

Step 6: Using Skills System

View Available Skills

You: What skills are available?
FastClaw: Executing run_skills("__list__")

Use Built-in Skills

You: Get current time
FastClaw: Executing run_skills("current_time")

You: Send Feishu message
FastClaw: Executing run_skills("feishu", {"message": "Test message"})

Step 7: Create Scheduled Tasks

Create via Web UI

Switch to Cron tab
Click "New Task"
Fill task information:
- Name: Daily Report
- Cron Expression: 0 9 * * * (9 AM daily)
- Agent: main_agent
- Command: Generate today's work report
Click Save

Create via Configuration File

Edit workspace/data/cron/tasks.json:

{
  "tasks": [
    {
      "name": "Daily Report",
      "cron": "0 9 * * *",
      "agent": "main_agent",
      "session_id": "daily_report",
      "command": "Generate today's work report and save to file",
      "enabled": true
    }
  ]
}

Cron Expression Examples

Expression	Meaning
`/5 * * *`	Every 5 minutes
`0 * * * *`	Every hour
`0 9 * * *`	Daily at 9 AM
`0 9 * * 1-5`	Weekdays at 9 AM
`0 9,18 * * *`	Daily at 9 AM and 6 PM

Step 8: Advanced Features Exploration

1. Session Management

# List all sessions
python main.py session list

# Export session history
python main.py session export default

2. Command Line Interface

# Start CLI interaction
python main.py chat

# New session
python main.py chat --new

# Specific session
python main.py chat --session-id my_session

3. Skill Development

Create custom skills:

# Create skill directory
mkdir -p workspace/skills/user/my_skill

# Create skill description
cat > workspace/skills/user/my_skill/SKILL.md << EOF
# My Skill

## Description
My custom skill example

## Parameters
- param1: Parameter 1 description
- param2: Parameter 2 description
EOF

# Create skill implementation
cat > workspace/skills/user/my_skill/main.py << EOF
async def execute(param1: str = "", param2: str = "") -> str:
    return f"Skill executed with params: {param1}, {param2}"
EOF

Step 9: Troubleshooting

Common Issues

1. Service Startup Failure

# Check port usage
lsof -i:8765

# Check dependencies
pip list | grep fastmind

# View detailed logs
python main.py start --verbose

2. API Connection Failure

Check if API Key is correct
Check network connection
Try other LLM providers

3. Permission Issues

# Check file permissions
ls -la workspace/

# Fix permissions
chmod -R 755 workspace/

Debug Mode

# Enable debug logging
export FASTCLAW_LOG_LEVEL=DEBUG
python main.py start

Step 10: Production Deployment

Using systemd (Linux)

# Create service file
sudo cat > /etc/systemd/system/fastclaw.service << EOF
[Unit]
Description=FastClaw AI Assistant
After=network.target

[Service]
Type=simple
User=fastclaw
WorkingDirectory=/opt/fastclaw
ExecStart=/opt/fastclaw/.venv/bin/python main.py start
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

# Start service
sudo systemctl daemon-reload
sudo systemctl enable fastclaw
sudo systemctl start fastclaw

Using Docker

FROM python:3.9-slim

WORKDIR /app
COPY . .

RUN pip install -r requirements.txt

EXPOSE 8765
CMD ["python", "main.py", "start"]

Best Practices

1. Security Configuration

Use environment variables for API Keys
Limit accessible directories
Regularly update dependencies

2. Performance Optimization

Use lightweight LLM models
Set appropriate context length
Enable automatic context unloading

3. Backup Strategy

# Backup configuration and data
tar -czf fastclaw_backup_$(date +%Y%m%d).tar.gz workspace/

Next Steps

Learning Resources

Official Documentation: Project README.md
Code Examples: Core implementation in core/app.py
Community Support: GitHub Issues and Discussions

Advanced Topics

Custom Agents: Create agents with specific personalities
Third-party Integrations: Connect to databases, message queues, etc.
Performance Monitoring: Add monitoring and alerts
Cluster Deployment: Multi-node high-availability deployment

Contribution Guide

Report Issues: GitHub Issues
Submit PRs: Follow code standards
Write Documentation: Help improve documentation
Share Use Cases: Share your experience

Summary

Through this tutorial, you have completed:

✅ FastClaw installation and configuration
✅ LLM API setup
✅ Basic functionality usage
✅ Scheduled task creation
✅ Troubleshooting methods

FastClaw's design philosophy is "simple yet powerful." With minimal configuration and intuitive interface, it makes AI Agent technology accessible to everyone. Whether you're a developer, operations engineer, or regular user, you can quickly get started and leverage its value.

Start your AI Agent journey today!

FastClaw vs OpenClaw: Why Choose the Python Version for Your AI Agent?

steven x — Sun, 29 Mar 2026 08:17:17 +0000

In the AI Agent landscape, OpenClaw is a well-known open-source project. But if you're looking for a lighter, more integrable, and Python-ecosystem-friendly alternative, FastClaw might be your best choice.

Project Background

OpenClaw

Language: TypeScript
Positioning: General-purpose AI Agent platform
Features: Comprehensive functionality, supports multiple tools and plugins
Ecosystem: Node.js/TypeScript ecosystem

FastClaw

Language: Python
Positioning: Lightweight Python AI Agent assistant
Features: Minimalist design, event-driven, state graph visualization
Ecosystem: Python ecosystem, based on FastMind framework
GitHub: https://github.com/kandada/fastclaw

Core Architecture Comparison

OpenClaw Architecture

User → API Gateway → Core Engine → Tool Execution → Response
    ↑
Plugin System, Configuration Management, State Storage

Characteristics:

Complete microservices architecture
Complex configuration management
Requires maintaining multiple service components

FastClaw Architecture

User → FastMind Engine → Agent → Tool Execution → Response
    ↑
State Graph Driven, Event Queue, Automatic Context Management

Characteristics:

Single process, lightweight
State graph defines workflows
Event-driven, zero polling
Automatic context unloading

Technical Advantages Comparison

1. Language Ecosystem Advantages

Aspect	OpenClaw (TypeScript)	FastClaw (Python)
AI Ecosystem	Requires bridging	Native support (OpenAI, LangChain, etc.)
Data Science	Limited support	Strong support (NumPy, Pandas, etc.)
System Integration	Requires additional tools	Native Shell integration
Deployment Complexity	Higher (Node.js environment)	Lower (Python environment)

Python Advantages:

Richer AI/ML library ecosystem
Better data science toolchain
Simpler system command integration
Broader developer community

2. Performance Comparison

Metric	OpenClaw	FastClaw
Startup Time	Slower (multiple services)	Faster (single process)
Memory Usage	Higher	Lower
Response Latency	Higher (IPC overhead)	Lower (in-process communication)
Scalability	Horizontal scaling	Vertical scaling + event-driven

FastClaw Performance Advantages:

Event-driven architecture, zero polling wait
Single-process design, reduces IPC overhead
Automatic context unloading, prevents memory explosion

3. Development Experience Comparison

OpenClaw Development

// Need to define complex plugin system
class MyPlugin implements Plugin {
  async execute(command: string): Promise<string> {
    // Implementation logic
  }
}
// Need to configure routing, middleware, etc.

4. Core Features Comparison

Feature	OpenClaw	FastClaw	Advantage
Tool System	Plugin system	run_shell + run_skills	Simpler, more powerful
Workflow	Custom logic	State graph driven	Visualizable, debuggable
Context Management	Manual management	Automatic unloading	Intelligent, prevents explosion
Streaming Output	Need implementation	Native support	Better user experience
Scheduled Tasks	Need extension	Built-in Cron	Out-of-the-box
Multi-channel	Need plugins	Built-in support	Easier integration

FastClaw's Core Innovations

1. run_shell Atomic Capability

# Complete any task through Shell commands
run_shell("ls -la")  # View files
run_shell("grep -r 'function' .")  # Search code
run_shell("curl https://api.example.com")  # Network requests

Philosophy: "Everything can be command-line" - Complex capabilities emerge from run_shell combinations

2. State Graph Driven

# Define workflow
graph = Graph()
graph.add_node("agent", fastclaw_agent)
graph.add_node("tools", tool_node)

# Conditional branching
graph.add_conditional_edges("agent", route, {
    "tools": "tools",
    None: "__end__"
})
graph.add_edge("tools", "agent")

Advantage: Workflow visualization, easy debugging, clear logic

3. Automatic Context Unloading

Problem: LLM context is limited (typically 8K-128K tokens)
Solution: Automatically unload early messages when context approaches threshold
Recovery mechanism: AI can restore context by reading message files via run_shell

4. Event-Driven Architecture

@app.perception(interval=60.0, name="cron_checker")
async def cron_checker(app: FastMind):
    while True:
        # Check scheduled tasks
        yield Event(type="cron.triggered", payload={...})
        await asyncio.sleep(60.0)

Advantage: Zero polling, high performance, better resource utilization

Practical Use Case Comparison

Use Case 1: Personal AI Assistant

OpenClaw Solution:

Need to configure multiple plugins
Need to manage TypeScript project
Relatively complex deployment

FastClaw Solution:

# One-line installation
git clone https://github.com/kandada/fastclaw.git
cd fastclaw
pip install -r requirements.txt
python main.py start

Out-of-the-box
Natural language computer operation
Simple JSON configuration

Use Case 2: Automated Workflows

OpenClaw: Need to write complex scheduled task logic

FastClaw: Built-in Cron scheduling

{
  "name": "Daily Report",
  "cron": "0 9 * * *",
  "agent": "main_agent",
  "command": "Generate today's work report"
}

Use Case 3: Enterprise Multi-channel Assistant

OpenClaw: Need to develop plugins for each channel

FastClaw: Built-in multi-channel support

Feishu messages
iMessage (Mac)
Telegram
Web UI

Migration Cost Analysis

Migrating from OpenClaw to FastClaw

Simple Migration (Basic Features)

Tool Migration: Rewrite TypeScript plugins as Python tools
Configuration Migration: Simplify complex configurations to JSON files
Deployment Migration: Change from multi-service to single-process deployment

Benefits Gained

Performance Improvement: Reduce IPC overhead, increase response speed
Development Simplification: Simpler API, less boilerplate code
Ecosystem Enhancement: Better Python AI ecosystem integration

Technology Selection Recommendations

Choose OpenClaw When

Already have TypeScript/Node.js tech stack
Need complex microservices architecture
Team familiar with TypeScript ecosystem
Need enterprise-level feature completeness

Choose FastClaw When

Using Python tech stack
Need rapid prototyping and deployment
Value development efficiency and simplicity
Need better AI/ML ecosystem integration
Care about performance and resource utilization

FastMind Framework Advantages

FastClaw is built on the FastMind framework, which is another significant advantage:

FastMind vs LangGraph

Aspect	LangGraph	FastMind
Complexity	High	Low
Event-Driven	❌	✅
Streaming Output	Need handling	Native
Python Integration	Good	Better

FastMind Characteristics:

Simpler API
Better event handling
Lighter runtime
Better for rapid development

Conclusion

FastClaw is not simply an OpenClaw clone, but an innovation and optimization based on OpenClaw's concepts:

Core Value Proposition

Lighter: Single-process design, reduces resource consumption
Easier to Use: Python ecosystem, simple API
Smarter: State graph driven, automatic context management
More Efficient: Event-driven architecture, zero polling wait

Target Audience

Python Developers: Want to quickly build AI Agents
Individual Users: Need lightweight AI assistant
SMBs: Need low-cost AI automation solutions
Researchers: Need flexible Agent experimentation platform

Getting Started

# Quick start
git clone https://github.com/kandada/fastclaw.git
cd fastclaw
pip install -r requirements.txt

# Configure LLM (supports all OpenAI-compatible APIs)
vim workspace/data/agents/main_agent/metadata.json

# Start service
python main.py start

# Access Web UI
# http://localhost:8765

Related Resources

FastClaw GitHub: https://github.com/kandada/fastclaw
FastMind GitHub: https://github.com/kandada/fastmind
Documentation: Project README.md
Community: GitHub Issues and Discussions

If you're looking for a lighter, easier-to-use, Python-ecosystem-friendly AI Agent solution, FastClaw is worth trying. It not only provides OpenClaw's core functionality but also makes important improvements in architecture design, development experience, and performance optimization.