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)
When you run a tool, incoming data is validated against the input schema before execution, and the returned data is validated against the output schema before it's passed back to the caller. This ensures predictable behavior, especially important when tools are invoked by APIs or AI agents.
Schema mode toggle
Each schema panel includes a Schema mode toggle:
- Manual: Visual field builder. Supports basic types and required/optional flags
- JSON: JSON editor. Supports all keywords available in the library
Note
Schemas created before the August 2026 release open in Manual mode. If your schema includes complex validations that are supported only in JSON mode, then switch to JSON before editing or saving. Saving the schema in Manual mode removes any unsupported JSON only validations.
Switching from JSON back to manual removes any keywords the visual editor doesn't support. A confirmation dialog appears before the switch. For tool configurations, the schema mode is saved automatically to prevent accidental resets.
Additional settings - field reference
The fields available in Additional settings depend on the data type of the field. Select the gear icon next to any data type field to open the panel.
| Field | What it does | Applies to |
|---|---|---|
| Regex | Validates the value against a regular expression. | String, String array (per item) |
| Minimum length | Fewest characters the value can contain (inclusive). | String, String array (per item) |
| Maximum length | Most characters the value can contain (inclusive). | String, String array (per item) |
| Minimum value | Lowest number allowed (inclusive). | Number, Number array (per item) |
| Maximum value | Highest number allowed (inclusive). | Number, Number array (per item) |
| Exclusive minimum | Value must be strictly greater than this — not equal. | Number, Number array (per item) |
| Exclusive maximum | Value must be strictly less than this — not equal. | Number, Number array (per item) |
| Multiple of | Value must be an exact multiple of this number. | Number, Number array (per item) |
| Minimum items | Fewest items the array must contain (inclusive). | String array, Number array, Object array, Boolean array |
| Maximum items | Most items the array can contain (inclusive). | String array, Number array, Object array, Boolean array |
| Add enums | Define a fixed set of allowed values for the field. | String, String array, Number, Number array |
| Required | Field must be present. Validation fails if it's missing. | All types |
| Allow null | Field accepts null in addition to its declared type. | All types |
| Description | Plain-language note about what this field represents. | All types |
JSON schema validation
JSON mode supports the keywords available in the library for both input and output schemas.
Note
The keywords allOf, oneOf, and uniqueItems are not supported in OpenAI strict mode and behave inconsistently across Gemini and Anthropic providers. Use anyOf instead of oneOf for broader AI agent compatibility. See Configure tool output for the full provider compatibility table.
Manual schema validations
| Validation | Fields in Additional settings | Supported data types |
|---|---|---|
| Regex pattern | Regex | String, String array |
| Length constraints | Minimum length, Maximum length | String, String array |
| Numeric range | Minimum value, Maximum value, Exclusive minimum, Exclusive maximum, Multiple of | Number, Number array |
| Enum | Add enums | String, String array, Number, Number array |
| Array size | Minimum items, Maximum items | String array, Number array, Boolean array, Object array |
| Allow null | Allow null | All types |
| Required | Required | All types |
| Description | Description | All types |
Regex is useful for enforcing formats like email addresses (^[\w.+-]+@[\w-]+\.[a-z]{2,}$), URLs, or phone numbers. It applies to each item individually in a string array.
Note
Object fields don't have their own validations, open the nested properties inside the object to configure them individually. Boolean fields only support Required, Allow null, and Description..
AI agent provider compatibility
When an AI agent calls this tool using structured output (json_schema format), advanced keyword support varies by LLM provider. Refer to the below table before finalising your output schema for agent use.
| Keyword | OpenAI (strict mode) | Gemini 2.0+ | Anthropic |
| enum, pattern, minimum/maximum, minLength/maxLength, minItems/maxItems, anyOf, $ref/$defs | Supported | Supported | Supported |
| allOf | Not supported | Varies by model | Varies by model |
| oneOf | Not supported, use anyOf | Varies by model | Varies by model |
| uniqueItems | Not supported | Varies by model | Varies by model |
To maximize compatibility across providers, prefer anyOf over oneOf and avoid allOf and uniqueItems in output schemas used with AI agents.
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.