Celigo tools are reusable, schema-driven building blocks in integrator.io that allow you to encapsulate business logic behind a defined input and output contract. Instead of duplicating logic across multiple AI agents, you build a tool once and reuse it consistently across the platform. Tools are designed for composability, governance, and runtime flexibility supporting both batch-based integrations and low-latency, real-time execution scenarios.
-
Tools support agents and MCP servers only.
-
Currently, the tool import step is not supported in flows.
-
The following capabilities are not supported for tools:
-
ILM (Integration Lifecycle Management)
-
Cloning
-
Download
-
Upload
-
Debug logs
-
-
If a tool is referenced in a flow or integration, that flow or integration cannot be cloned, downloaded, or included in ILM.
-
Diagnostic download is not supported when tools are added.
Build reusable tools in a dedicated integration tile (for example, Core Tools), to isolate tool-related limitations from other integrations and improve governance, reuse, and visibility.
A tool is a reusable, first-class component in integrator.io that encapsulates business logic behind a strict JSON-based contract.
Conceptually, tools functions like a sub-flow, but with:
-
Explicit input and output schemas
-
Strong validation
-
Runtime adaptability
-
Platform-wide reusability
Tools are built in a visual, low-code canvas similar to the Flow builder but are designed to operate as composable units that can be invoked by:
-
Flows (available only in the future releases)
-
APIs (available only in the future releases)
-
MCP servers
-
AI agents
You build it once. You reuse it everywhere.
As your integration usage grows, repeating the same logic in multiple places can lead to inconsistencies and higher maintenance effort. Tools help you centralise that logic, reduce duplication, and maintain consistent behaviour across implementations.
Tools address these challenges by providing:
Reusability: Build logic once and invoke it across AI-driven workflows.
Low-code simplicity: Use familiar constructs such as:
-
Mappings
-
Connectors
-
Lookups
-
Imports
-
Conditional logic
Adaptable runtime: Tools automatically adapt based on how they are invoked:
|
Invocation context |
Runtime behaviour |
|---|---|
|
Flow |
Batch-oriented, resilient execution with retry policies |
|
API / AI Agent |
Low-latency, synchronous execution for real-time responses |
Governance:
-
Dependency visibility (“Used by” view)
-
Deletion safeguards
-
Audit logging
-
Controlled promotion across environments
A tool functions like a sub-flow but with stricter contracts and a wider range of applications. Each tool consists of three main components:
Tools are contract-driven. You define:
-
Input schema (what the tool accepts)
-
Output schema (what the tool returns)
Both are defined using JSON schema structures.
Validation: You can enforce a strict or lenient data typing (string, number, boolean, etc.), required vs optional fields and structural constraints.
Delete Mapping: Incoming data is validated against the input schema before execution. Output data is validated and mapped to the defined output schema before returning to the caller. This ensures predictable behaviour especially important when tools are used by APIs or AI Agents.
Between the input and output nodes, you define business logic using supported step types:
Lookups: Retrieve data from external systems. Example use cases:
-
Fetch customer by email
-
Retrieve order status
-
Validate SKU existence
Imports: Create or update data in destination applications. Example use cases:
-
Create a support ticket
-
Update customer record
-
Insert order into ERP
Transfers: Move data between systems or storage locations.
Branching: Apply conditional logic to execute different paths based on data conditions.These steps allow tools to orchestrate multi-system workflows while maintaining a single reusable contract.
This section provides examples to help you understand how to design reusable tools with clear inputs, focused logic, and predictable outputs. These examples can be used across flows, APIs, AI agents, and MCP servers.
Example 1 - Cross-system utilities
Customer Lookup (by Email): Use this when multiple integrations need customer details.
-
Input: email
-
Logic: Looks up customer in CRM/ERP
-
Output: customerId, accountName, tier
Eliminates repeated customer lookup steps across flows.
Example 2 - HR / employee patterns
Provisioning decision: Use this to centralize access rules.
-
Input: role, department, region
-
Logic: Router branches (e.g. IT vs sales vs contractor), each with a small lookup or mapping-table import.
-
Output: groupsToAdd, licenseSku, requiresApproval
Centralizes access decision logic across onboarding processes.
Example 3 - Order and fulfillment
Order eligibility check: Use this before processing or fulfilling orders.
-
Input: orderID
-
Logic: checks fraud, hold status, inventory
-
Output: eligible, reasonCode, nextAction
Works well for real time validation in APIs or AI agents.
Example 4 - Finance and master data
GL account mapper: Use this when transforming financial data.
-
Input: sourceSystem, sourceAccountCode
-
Logic: Lookup mapping table (Celigo lookup to a mapping object or database).
-
Output: glAccountId, mappingRuleId
Ensures consistent account mapping.
Example 5 - Agent and MCP friendly tools
Ticket summary fetcher: Use this to safely expose ticket data to AI agents.
-
Input: ticketKey
-
Logic: Jira/ServiceNow export; trim to safe fields
-
Output: summary, status, assignee, priority.
Keeps responses structured and minimal.
Use the Tool Builder to create reusable tools using a visual, low-code interface. You can define input and output schemas, add lookups or imports, configure mappings and transformations, set error handling, and test execution before publishing.
You can create a tool in multiple ways:
-
On the Home, open an integration, then select the Tools tab.
-
On the Home, Click Create → Integration, open an integration, then select the Tools tab.
-
From the top left navigation pane:
-
Click AI Studio → Tools
-
click Build → Tools
-
Use the following options to create a tool:
-
If no tools exist, click Create tool at the centre of the page or in the upper-right corner.
-
If you have previously created a tool, click + Create tool in the upper right side of the page.
After you create a tool, configure the tool input, logic steps, and output before testing and publishing. Each newly created tool includes tool input and tool output steps. You can add both schemas. Use the Tool Builder to define your tool’s contract and logic. Tools are schema-driven, ensuring structured input and output.
Define the input schema:
-
Add fields and data types
-
Mark required or optional fields
-
Define validations
You can create mock input data to test schema validation and logic before using live payloads.
Use logic steps to integrate with external systems:
-
Lookup – Retrieve data from a source application
-
Import – Create or update records in a destination application
These steps enable real-time data retrieval and system synchronisation within the tool.
Define the output schema to control what the tool returns to the consumer. To configure mapping:
-
Open the Tool output step.
-
Click the mapping icon.
-
Map fields from previous steps to the output schema.
You can:
-
Rename fields
-
Transform structures
-
Remove unnecessary fields
Use Auto-Mapping to automatically align similar fields, then manually adjust if needed. A well-defined output schema ensures structured and predictable responses.
Use the test mode to validate your tool before publishing. Run the tool with mock input to review execution logs, schema validation, and external system responses.If errors occur, check required fields, data types, mappings, and connection authentication. Update the configuration and re-run until the tool returns schema-compliant output without failures.
After publishing, monitor your tool regularly to ensure consistent performance. Validate input/output contracts and verify connection health.
Governance : Tools are designed for safe collaboration:
-
Dependency tracking: Use the Used by section to view all resources referencing the tool.Deletion is blocked if the tool is in use.
-
Audit logs: All create, edit, and delete actions are logged with timestamp and user details for traceability.
Once published, tools are available as a step type:
-
In flows: Execute in batch mode and follow Flow-level retry and error-handling policies.
-
In APIs and AI agents (available only in the future releases): Execute synchronously for real-time data retrieval or action execution with structured output.
Celigo tools provide a structured, reusable, and governed way to build integration logic once and deploy it across AI agents, MCP servers, etc, ensuring consistency, scalability, and maintainability across your automation architecture.