Verentis

Tools

Engine tools

Expose your engine's operations as typed, discoverable tools that the platform and AI agents can invoke programmatically.

Beyond "run this file", an engine can publish a set of tools — named operations with typed input and output schemas. This is an MCP-style interface: the platform (and, in future, AI agents) can discover your tools and invoke them programmatically.

Declaring tools

spec:
  tools:
    - name: run-script
      description: Execute a Python script and capture stdout
      input-schema:
        type: object
        properties:
          path: { type: string }
          args: { type: array, items: { type: string } }
        required: [path]
      output-schema:
        type: object
        properties:
          stdout: { type: string }
          stderr: { type: string }
          exitCode: { type: integer }
    - name: lint
      description: Lint a Python file and return diagnostics
      input-schema:
        type: object
        properties:
          path: { type: string }
      output-schema:
        type: object
        properties:
          diagnostics:
            type: array
            items:
              type: object
              properties:
                line: { type: integer }
                message: { type: string }
namestring
Required

Stable tool identifier (kebab-case).

descriptionstring

What the tool does — used in discovery and (for agents) tool selection.

input-schemaJSON Schema

The shape of the tool's input. Validated before invocation.

output-schemaJSON Schema

The shape of the tool's output. Lets callers (and agents) consume results reliably.

Why typed tools

Discoverable

Callers can enumerate what an engine can do without reading its source.

Composable

Typed I/O means tools can be chained and orchestrated — by the platform or by agents.

Safe

Inputs are validated against the schema before your code runs.

Designing good tools

  • Give tools narrow, single-purpose contracts — one job each.
  • Make schemas specific: prefer enums and required fields over free-form objects.
  • Keep tool names stable across versions; evolve behaviour, not identity.
  • Return structured output your callers can act on, not just a string blob.

Tools and AI agents

Agents are a planned extension type. Because engine tools are already typed and discoverable, they're the natural surface agents will call. Designing clean tools now makes your engine future-ready.

Status

The AI-agent consumer of tools is coming soon. The tool interface itself is part of the engine manifest you author today.

Next

Triggers & schedules

Run your engine automatically, without a user clicking Run.