Custom Tools

Tools Advanced

Custom tools extend your agents with capabilities specific to your organization. You define the tool’s interface (parameters and result schema), then attach either an agentic or an edge implementation.

Tool definition structure

Every tool is defined with the following fields:

Field	Required	Description
`name`	Yes	Unique identifier used in tool calls (e.g., `restart_vpn_service`)
`title`	Yes	Human-readable display name
`description`	Yes	Explains the tool’s purpose so the agent knows when to invoke it
`group`	Yes	Category: `TICKET`, `SYSTEM`, `KNOWLEDGE`, `MEMORY`, `COMMUNICATION`, or `CUSTOM`
`parameters`	Yes	Schema defining the inputs the agent must provide
`resultSchema`	Yes	Schema defining the structured output
`documentation`	No	Metadata that guides agent behavior (see below)
`visibility`	No	`public` (shown to users) or `system` (internal only)

Documentation object

The documentation object provides structured guidance to the agent about when and how to use the tool:

Property	Description
`callWhen`	Describes the situation in which the agent should invoke this tool
`preconditions`	Conditions that must be true before the tool is called
`effects`	What the tool returns or accomplishes
`limitations`	Constraints the agent should be aware of

Creating a custom tool

Custom tools are created in the admin dashboard and then connected to an implementation.

Via the admin dashboard

Navigate to Tools in the admin sidebar and select Create Tool.
Fill in the tool definition fields (name, title, description, group, parameters, result schema).
Optionally fill in the Documentation fields to guide the agent on when and how to use the tool.
Save the tool.
Attach either an Agentic or an Edge implementation.

Agentic implementation

Use an agentic implementation when another workflow agent should fulfill the tool contract. This is useful when the tool’s behavior is primarily orchestration and reasoning rather than low-level system access.

Edge implementation

Use an edge implementation when the tool needs to run on your infrastructure. The generate command scaffolds the implementation from the tool registry:

edge-connector generate -l typescript -t <tool_name> -o ./custom-implementations

This generates a TypeScript file with typed parameters, result schema, and a handler stub that you fill in with your tool’s logic.

Edge tool bundling

Custom EDGE tools are packaged into bundles for deployment. A bundle is a compressed archive that contains:

A manifest listing all tools, their checksums, and the bundle’s target language
Compiled tool implementation files in a dist/tools/ directory

Bundles are versioned. When you upload a new bundle, the platform checks each tool’s checksum against existing versions. Unchanged tools are reused; modified tools receive a new version number automatically.

Edge tool versioning

Each tool implementation is independently versioned:

Version numbers increment automatically when a new implementation (different checksum) is uploaded
Checksums ensure that identical implementations are deduplicated across uploads
You can inspect version history and checksums via the Edge Connector CLI using edge-connector bundle tools

How edge implementations run

The Edge Connector discovers available tools during its WebSocket handshake with the platform. For each EDGE tool, the connector looks for a matching implementation in its local tool directory.

When the platform routes a tool call to the Edge Connector:

The connector receives the tool name and arguments over WebSocket
It locates the matching implementation in the deployed bundle
The implementation executes with the provided arguments
The result is serialized and sent back to the platform

Edge upload flow

Define the tool. Create the tool definition with its name, parameters, result schema, and documentation.
Implement in the Edge Connector. Write the tool’s execution logic in your Edge Connector package. The implementation receives the validated parameters and returns a result matching the resultSchema.
Package with the Edge Connector CLI. Run the Edge Connector’s bundle command to compile and package your tool implementations into a deployable archive.
Upload the bundle. Use the Edge Connector CLI’s upload command to send the bundle to the platform. The platform validates the manifest, creates new tool versions for changed implementations, and associates them with a bundle.
Terminal window
```
edge-connector upload
```
Assign the bundle to a deployment. From the admin dashboard or via the CLI, assign the uploaded bundle to one or more deployments. Edge Connectors associated with those deployments will receive the new tool implementations on their next sync.
Terminal window
```
edge-connector bundle assign <bundleId> --deployment <deploymentId>
```

Next steps

Edge Connector Overview Learn how the Edge Connector runs tools close to your infrastructure.

Tool Management Manage tools, integrations, and visibility from the admin panel.