eCan.ai User Manual

What is eCan.ai?

eCan.ai (E-Commerce Agent Network) is an AI-native platform that empowers e-commerce sellers to automate every aspect of their business using intelligent agents — from product sourcing and procurement to customer service, marketing research, and advertising — all with minimal human intervention.

Agents run on vehicles (host computers) connected across a LAN or WAN. One computer acts as the commander; others serve as vehicle nodes. A staff-officer device (PC, phone, or tablet) can monitor and command the whole fleet remotely over the internet.

Core Concepts

Agents

An Agent is the primary actor in eCan.ai. Each agent has an identity, an avatar, and a set of tasks it can perform. Agents run on vehicles (host computers) and communicate with humans or other agents through channels.

Tasks & Skills

A Task is a job assigned to an agent (e.g., "monitor product prices daily"). Every task requires a Skill — a LangGraph-based workflow that describes how the task is carried out. Skills are authored visually in the Skill Editor or coded directly in Python.

Tasks can be triggered by a human command, on a one-time schedule, or on a recurring schedule (e.g., every day at 08:00).

Vehicles

A Vehicle is any computer (desktop, server, VM) that hosts one or more agents. Vehicles join the eCan.ai network and receive task assignments from the commander node.

Skills

Skills are stored under $SKILL_ROOT/my_skills/. The graphical representation lives in the diagram_dir sub-directory; hand-coded LangGraph skills live in code_dir. Both can co-exist and be translated between each other.

Installation

Desktop App (Windows / macOS)

Download the latest installer from ecan.ai/download. The installer bundles Python, all dependencies, and a Chromium browser. No separate Python installation is required.

After installation, launch eCan.ai from your Applications folder or Start Menu. On first launch you will be prompted to create an account or log in.

Headless Web Server (Linux / Ubuntu)

For server deployments without a GUI, eCan.ai runs in Web Mode — a WebSocket/REST server you interact with via a browser or the CLI.

sudo apt-get update
sudo apt-get install -y python3 python3-venv python3-pip \
    libpq-dev gcc libffi-dev tesseract-ocr poppler-utils git

git clone <repo-url> eCan.ai && cd eCan.ai
chmod +x scripts/deploy-ubuntu.sh
./scripts/deploy-ubuntu.sh setup

# Edit .env.web and fill in your LLM provider keys:
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
DASHSCOPE_API_KEY=...   # Qwen / Alibaba

./scripts/deploy-ubuntu.sh start
# Verify: curl http://localhost:8765/health

Quick Start

Agents & Tasks

Managing Agents

Each agent has a name, description, avatar, and a set of default task assignments. You can create multiple agents and assign them to different vehicles (machines) in your network.

Task Triggers

Multi-Agent & Multi-Task

Multiple agents can run simultaneously, each handling different tasks in parallel threads. Agents communicate with each other using the A2A protocol (Agent-to-Agent), an emerging open standard for inter-agent messaging.

Skill Editor

The Skill Editor is a visual IDE for building LangGraph workflows. It uses a flowgram canvas where you place and connect nodes to describe agent behavior.

Canvas Basics

Adding Nodes

Right-click anywhere on the canvas (or click the node icon in the toolbar) to open the node selection menu. Click a node type, then click on the canvas to place it. Each node has a configuration panel — double-click the node to open it.

Connecting Nodes

Click and drag from a node's output port to another node's input port to draw an edge. To remove an edge, drag its endpoint to a blank canvas area. To re-route, drag the endpoint to a different input port.

Navigation

• Pan: Hold the mouse-wheel button and drag, or use the minimap.
• Zoom: Ctrl + scroll wheel.
• Multi-select: Hold Shift and drag a selection rectangle.

Multi-Sheet Workflows

Large workflows can be split across multiple sheets (canvases). Use the sheet menu (layers icon, upper right) to add, remove, or rename sheets.

Cross-Sheet References

To call another sheet's logic:

1. On the callee sheet, add a sheet-inputs node (declares input names) and a sheet-outputs node (declares output names).
2. On the caller sheet, insert a sheet-call node and select the target sheet from the dropdown.
3. Map each input/output to constants or local node ports in the sidebar.

Multi-sheet bundles are saved as a -bundle.json companion file alongside the main flow JSON.

Data Movements — Mapping DSL

Nodes exchange data through a shared node state object. Because each workflow has a unique state shape, eCan.ai uses a simple Mapping DSL (JSON-based) to describe how data moves between nodes and between external events and node state.

The same DSL handles resume payloads when a workflow is interrupted and later resumed (e.g., when human input arrives or a timer fires).

Saving & Loading

• Skills created in the editor are stored under $SKILL_ROOT/my_skills/diagram_dir/.
• Hand-coded LangGraph skills live in code_dir/.
• Data-mapping JSON files are stored at the same level as these directories.
• To view a Python-coded LangGraph skill graphically, call langgraph2flowgram() to generate the flowgram files.

Run & Debug

When debugging a skill, it runs as a special development task under a tester agent. If your workflow involves chat, prefix your test messages with dev> to route them to the tester agent.

Breakpoints

Open the node's upper-right menu to toggle a breakpoint. When execution hits a breakpoint, it pauses before running that node. You can then inspect and modify the node state before resuming.

Controlled Execution

Use the toolbar controls: Pause · Step · Resume · Stop. A running animation highlights the currently executing node.

Test Run

Click Test Run to execute the workflow in isolation. Provide input JSON in the Inputs panel; inspect outputs from each node and the final End node in the Outputs panel.

Version Control

• eCan.ai Cloud (paid): Version-control skills on eCan.ai's Git service and optionally commercialize them.
• Local Git: Skill files are plain JSON — just git init your skill directory.

Node Reference

Browser Automation

eCan.ai integrates multiple state-of-the-art web automation libraries, making it suitable for everything from routine scraping to complex multi-step workflows on anti-bot e-commerce sites.

Computer-Vision Guided Actions

When in-browser automation isn't enough (pop-ups, CAPTCHAs, non-standard UIs), eCan.ai's eCanOCR service provides screen understanding and CV-guided mouse/keyboard actions — giving you full control over any desktop or browser window.

OCR Service (eCanOCR)

eCanOCR is an API service that converts screen images to structured text. It combines Tesseract's speed with a modified PaddleOCR engine for high accuracy, automatically restructuring raw OCR output into hierarchical paragraphs, lines, and words.

Key Capabilities

• Image-to-text extraction with paragraph and line segmentation
• Icon recognition (when configured with icon templates)
• Anchor-based content extraction — define key landmarks on a page to locate dynamic content
• Table, calendar, and bounding-box region extraction

Content Skill Files (.csk)

A .csk file describes expected page contents using a JSON instruction set. It defines anchors (distinct text or icon landmarks) and info regions (areas of interest relative to anchors). This lets agents reliably extract structured data from repeating page layouts.

MCP Tools

eCan.ai exposes a set of streamable HTTP MCP tools that any LLM-integrated workflow can call. These tools are organized into five categories:

Channel Integrations

The channel system lets eCan.ai agents receive and reply to messages from external messaging platforms. Every channel adapter normalizes inbound messages into a common format, routes them through the agent pipeline, and sends replies back to the originating platform.

* Requires a publicly accessible endpoint (e.g., via ngrok or a reverse proxy).

Quick Setup

All channel configuration lives in agent/agent_files/channels.json. Enable a channel, fill in credentials, and restart eCan.ai — the channel manager starts automatically.

{
  "channels": {
    "telegram": {
      "enabled": true,
      "bot_token": "YOUR_BOT_TOKEN",
      "allowed_chat_ids": [],
      "default_agent_id": ""
    }
  }
}

Set default_agent_id to route a channel's messages to a specific agent, or leave it empty to route to the first available agent.

Telegram Setup

1. Message @BotFather on Telegram → /newbot → copy the bot token.
2. Add the token to channels.json under "telegram".
3. Restart eCan.ai — the bot is live immediately.

Slack Setup

1. Create a Slack App at api.slack.com/apps.
2. Enable Socket Mode and subscribe to message.* events.
3. Add bot_token and app_token to channels.json.
4. Invite the bot: /invite @YourBotName in a channel.

WhatsApp / Messenger / X

These channels require a public webhook endpoint. Use ngrok for development:

ngrok http 8443   # WhatsApp
ngrok http 8444   # Messenger
ngrok http 8445   # X (Twitter)

Register the ngrok URL as the webhook in each platform's developer console, then fill in the credentials in channels.json.

Avatar System

Each agent can have a static image avatar or a dynamic video avatar. Avatars are stored locally and automatically synced to AWS S3 in the background.

Supported Formats

S3 Cloud Sync

After upload, the file is saved locally and then uploaded to AWS S3 in a background thread — the UI is not blocked. The S3 URL is stored in the database and used when syncing agent data to the cloud.

CLI Reference

The eCan.ai CLI provides full control over the server and all resources in headless mode. No GUI required.

python ecan_cli.py --help          # global help
python ecan_cli.py version         # show version
python ecan_cli.py status          # system status

Authentication

python ecan_cli.py auth login -u username -p password
python ecan_cli.py auth status
python ecan_cli.py auth logout

Resource Commands

Server Management

python ecan_cli.py server start                        # start in background
python ecan_cli.py server start --host 0.0.0.0 --port 8080
python ecan_cli.py server start --foreground           # foreground (debug)
python ecan_cli.py server logs --follow                # tail logs
python ecan_cli.py server stop

Output Formats

Most list commands support --output table (default) and --output json for scripting:

python ecan_cli.py agents list --output json | jq '.agents[0].name'

Server Deployment

Environment Variables

Docker

docker-compose -f docker-compose.web.yml up -d
docker-compose -f docker-compose.web.yml logs -f

Nginx Reverse Proxy (Production)

server {
    listen 80;
    server_name your-domain.com;
    location / {
        proxy_pass http://127.0.0.1:8765;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 86400;
    }
}

Systemd Service

[Unit]
Description=eCan.ai Web Server
After=network.target

[Service]
Type=simple
User=www-data
WorkingDirectory=/opt/eCan.ai
EnvironmentFile=/opt/eCan.ai/.env.web
ExecStart=/opt/eCan.ai/venv/bin/python -m uvicorn web_server:app \
          --host 127.0.0.1 --port 8765
Restart=always

[Install]
WantedBy=multi-user.target

Web Mode Limitations

Proxy Management

eCan.ai includes a built-in proxy management system for routing browser automation through HTTP/SOCKS proxies — essential for e-commerce workflows that require IP rotation or geo-specific access.

Proxies are configured per-agent or per-task and are automatically applied to Playwright, Selenium, and HTTP request nodes.

Settings & API Keys

LLM Providers

Add API keys for the LLM providers you want to use. Keys are stored in .env (desktop) or .env.web (server).

In-App Settings

Open Settings from the sidebar to configure LLM defaults, browser automation options, memory limits, update preferences, and more. Changes take effect immediately without restarting.

Keyboard Shortcuts

Skill Editor

General App

FAQ & Troubleshooting

The skill editor doesn't load

Refresh the page and ensure the eCan.ai backend server is running. In desktop mode, check the system tray icon — if it shows an error, restart the app.

My agent doesn't respond on a channel

1. Verify "enabled": true is set in channels.json.
2. Ensure at least one agent has a running task with a skill containing a chat or Pend For Event node.
3. Check app logs for [ChannelBridge] entries — look for "No agent available" or "dispatch_inbound error".
4. For webhook channels (WhatsApp, Messenger, X): verify the webhook URL is publicly accessible and the verify token matches.

Server won't start

# Check if the port is already in use
netstat -an | grep 8765
# Or use a different port
./scripts/deploy-ubuntu.sh start -- --port 8080
# View logs
./scripts/deploy-ubuntu.sh logs

LLM calls are failing

• Verify your API key is set in .env / .env.web and is valid.
• Check token quota with your provider.
• For local Ollama: ensure the model is downloaded (ollama pull <model>) and the base URL is correct in Settings.

Browser automation errors

• Run playwright install chromium --with-deps to ensure the bundled browser is present.
• For Selenium-based tools: ensure ChromeDriver matches the installed Chrome/Chromium version.
• On headless servers: screen capture and desktop automation tools are unavailable — use Playwright or Crawl4ai instead.

How do I switch languages in a Code node?

Use the language dropdown above the Monaco editor in the Code node's editor panel. Supports Python, JavaScript, and TypeScript.

All Documents

Detailed reference documents for each subsystem:

User-Facing Guides

Deployment & Operations

Architecture & Internals