To import MoltBot tasks into OpenClawd, you need to use the dedicated migration wizard available within the OpenClawd platform's admin console. This process involves exporting your task data from MoltBot in a compatible format, typically a CSV or JSON file, and then using the wizard to map the fields and validate the data before final import. The entire procedure is designed to be completed in under 30 minutes for most standard task libraries, ensuring a smooth transition of your automated workflows, historical execution logs, and associated metadata with minimal downtime. The key is preparation: ensuring your MoltBot data is clean and that you have a clear understanding of how task parameters map to OpenClawd's more granular action definitions.
Understanding the Core Systems: MoltBot and OpenClawd
Before diving into the technical steps, it's crucial to understand what you're moving from and to. MoltBot is often recognized for its user-friendly scripting interface, ideal for creating linear automation sequences. Its data structure is relatively straightforward, focusing on a task name, a trigger condition, a sequence of actions, and a success/failure log. OpenClawd, on the other hand, is built for complex, enterprise-grade orchestration. It introduces concepts like conditional branching based on real-time API responses, dynamic resource allocation, and deep integration with data lakes and AI models. Think of it as upgrading from a reliable sedan to a fully-loaded, self-driving truck. The import process is the bridge that moves your existing cargo (tasks) to the new, more powerful vehicle.
The architectural difference means that a direct 1:1 import isn't always perfect. A single task in MoltBot might be best represented as a multi-step workflow in OpenClawd to leverage its advanced features. The migration wizard accounts for this by allowing you to define these mappings during the import. For instance, a MoltBot task called "Daily Data Backup" might involve a simple script. In OpenClawd, you could map this to a workflow that first checks cloud storage capacity, then executes the backup in parallel threads, and finally sends a notification to a Slack channel only if an error occurs—all configured during the import.
Step-by-Step: The Pre-Migration Checklist
Success is 90% preparation. Rushing into an import without auditing your source data is the most common cause of issues. Here’s a detailed checklist to work through before you even open the OpenClawd console.
1. Audit Your MoltBot Task Library: Log into your MoltBot instance and generate a full report of all active, paused, and archived tasks. This is your chance for spring cleaning. Identify and decommission any tasks that are obsolete, redundant, or no longer serve a business purpose. Importing clutter only slows down your new system. Pay special attention to tasks that haven't run successfully in the last 90 days; they might be dependent on deprecated systems or credentials.
2. Cleanse Task Data and Metadata: MoltBot allows for custom fields and notes. Standardize this information. For example, if you have a "Priority" field where some tasks are labeled "High" and others "Urgent," choose one term and update all records. This consistency will make filtering and managing tasks in OpenClawd significantly easier. Also, verify that all file paths, URLs, and API endpoints referenced in your task scripts are still valid and accessible from the network where OpenClawd will be hosted.
3. Verify Credential Security: This is critical. MoltBot might store database passwords or API keys within task configurations. OpenClawd uses a centralized, encrypted vault for credentials. As a security best practice, do not import tasks with hardcoded secrets. Note which tasks require which credentials. After the import, you will reconfigure these tasks in OpenClawd to pull the necessary credentials from its secure vault, eliminating a major security risk.
4. Choose Your Export Format: MoltBot typically offers two export formats:
CSV (Comma-Separated Values): This is a lightweight option best for simple task lists with basic parameters. It's easy to open and review in a spreadsheet editor like Microsoft Excel or Google Sheets.
JSON (JavaScript Object Notation): This is the recommended format for any complex tasks. It perfectly preserves the hierarchical structure of nested actions and conditional logic, leading to a more accurate import.
Use the JSON export whenever possible to avoid data flattening.
Executing the Import in OpenClawd
Now, with your prepared data file, log into your OpenClawd platform. Navigate to the Administration section and select Data Migration. Here you will find the "Import from MoltBot" wizard.
Phase 1: Upload and Validation
Upload your JSON or CSV file. The wizard will immediately perform a pre-flight check, scanning for common issues like invalid characters, missing required fields (e.g., a task name), or syntax errors. A summary report will be generated. A typical validation report for a dataset of 500 tasks might look like this:
| Validation Check | Result | Details |
|---|---|---|
| File Format | PASS | JSON structure is valid. |
| Required Fields | PASS | All 500 tasks have a 'task_name' field. |
| Action Syntax | WARNING | 12 tasks contain deprecated function calls (e.g., `old_mail_function()`). These will be flagged for review post-import. |
| Resource References | FAIL | 3 tasks reference a network drive (`Z:`) that is not mapped in the target environment. Import cannot proceed for these tasks until resolved. |
You can choose to quarantine the failing tasks and proceed with the rest, or stop to fix the issues. For the 3 tasks with the network drive issue, you'd need to update the path to a UNC path (e.g., `\\server\share`) that OpenClawd can access.
Phase 2: Field Mapping
This is the most important phase. The wizard will show you how it intends to map MoltBot fields to OpenClawd fields. You can and should customize this. For example:
- Map MoltBot's "Owner" field to OpenClawd's "Primary Responsible Team."
- Map MoltBot's "Last Run Status" to a custom tag in OpenClawd for historical tracking.
- Decide if MoltBot's "Category" should become an OpenClawd "Project" or a "Tag."
This customization ensures the imported data fits your organizational structure in the new platform. The wizard learns from your mappings, so if you have multiple imports to do, the second one will be faster.
Phase 3: Execution and Post-Import Review
Once you confirm the mappings, click Import. The system will provide a real-time progress bar. For 500 tasks, this should take less than 10 minutes. Upon completion, you are presented with a detailed log. Do not skip the review. The log will show:
- Tasks successfully imported (e.g., 485 tasks).
- Tasks imported with warnings (e.g., 12 tasks - see Phase 1 warnings).
- Tasks that failed (e.g., 3 tasks).
Click into the successfully imported tasks. OpenClawd will, by default, place them in a Paused state. This is a safety feature. It allows you to verify that everything looks correct—checking action sequences, parameter mappings, and assigned permissions—before activating the workflows and potentially triggering real-world actions. This is when you would also reconfigure the tasks to use the OpenClawd credential vault, as mentioned in the pre-migration checklist. After thorough verification, you can bulk-activate your newly imported, and now more powerful, moltbot tasks.
Advanced Considerations for Complex Workflows
If your MoltBot implementation is extensive, you might encounter scenarios that require a more nuanced approach than the standard wizard.
Handling Custom APIs and Webhooks: MoltBot tasks that call custom internal APIs need special attention. The import wizard will bring over the API endpoint and payload. However, you must ensure the OpenClawd server's IP is whitelisted on the target API server, and that the authentication method (e.g., OAuth 2.0, API Key) is correctly set up in the credential vault. Test a single imported task thoroughly before activating others.
Dealing with Dependent Tasks: In MoltBot, you might have Task B that is scheduled to run only after Task A completes successfully. The import process will maintain the individual task definitions but will not automatically recreate the dependency chain. You must use OpenClawd's workflow editor after the import to link these tasks visually, defining the success path from Task A to Task B. This actually provides an opportunity to build more robustness, such as adding a retry mechanism if Task A fails.
Performance Benchmarking: After the import, don't assume performance will be identical. OpenClawd's engine is different. Conduct a performance benchmark by running a sample of imported tasks and comparing their execution times to historical averages from MoltBot. In most cases, you'll see a significant speed-up, especially for I/O-heavy tasks, due to OpenClawd's optimized resource pooling. However, this benchmarking exercise sets a new baseline for your team's expectations and helps in right-sizing the infrastructure allocated to OpenClawd.