Skip to main content

Agentic platform

DIAL is an agentic platform: any model or application available in it can act as a reusable building block in a larger solution. This page explains what "agent" means in DIAL, how agents compose into multi-agent applications, and why the design favors reuse over rebuilding. It is written for architects and developers who have read What is DIAL and want to understand the platform's composition model.

What "agent" means in DIAL​

In DIAL, an agent is any conversational entity a user or another application can call through DIAL Core — a language model, an adapter-backed provider model, or a full application. Every agent is a deployment that Core calls by name, in one of its AI APIs, with the same authentication and access checks. Agents are therefore interchangeable: a client that can call a model can call an application, and an application can call another application the same way it calls a model.

This uniformity is the foundation of the agentic platform. There is no separate "tool protocol" to learn for each building block: a deployment name and the AI APIs that DIAL Core serves are the contract that lets agents be combined.

Agents as building blocks​

The platform encourages composition rather than duplication. Instead of reimplementing a capability that already exists, you call the agent that provides it. Two kinds of building blocks are most common:

  • DIAL applications. Applications built with the DIAL SDK expose chat completion or embedding endpoints that conform to the Unified API. An application can encapsulate retrieval, business logic, or a multi-step workflow and then be reused wherever an agent is expected.
  • Models through adapters. Adapters connect provider-specific APIs to DIAL Core, so commercial, open-source, self-hosted, and fine-tuned models all appear as agents. See supported providers for the full range.

Because access control travels with every agent, composing an application out of other agents does not bypass permissions: a caller can only use the building blocks it is authorized to reach.

Composing multi-agent applications​

DIAL supports both simple conversational agents and applications that coordinate several agents to solve a task. The agent builders included in the platform make this composition accessible at different levels of effort:

  • Quick Apps are no-code orchestrators. A model that supports tool use acts as the orchestrator, routing each request to the most appropriate agent, toolset, or model — without any custom code.
  • Code Apps and custom applications express orchestration logic in Python when a workflow needs more control than a no-code composer provides.

A multi-agent application can select and assign agents to tasks automatically. For example, an orchestrator might route a factual question to a retrieval agent, an image request to a text-to-image application, and a calculation to a code-execution tool — all behind a single conversational entry point.

Discovery, reuse, and sharing​

Agents only deliver leverage if developers and users can find and reuse them. DIAL Chat's Catalog lists every agent a user is permitted to see, based on their roles and permissions. From there, agents can be used directly in a conversation or composed into new applications.

Collaboration and sharing extends this further: an agent built by one team can be shared with specific colleagues or published to the whole organization, becoming a building block others reuse. The result is a growing library of capabilities rather than repeated, isolated implementations.

Running agents on a schedule​

An agent does not need a user at the keyboard. Scheduled tasks in DIAL Chat send instructions to a model or agent once or on a recurring schedule, and each run produces its own conversation. DIAL Scheduler executes the runs with the task owner's delegated credentials, so Core applies that user's permissions to every call.

Why this design​

We treat models and applications as one interchangeable category — agents — so that the cost of adding a capability falls over time. Every new application both solves its own problem and becomes a building block for the next solution. Calling every agent through DIAL Core, in standard AI APIs rather than a bespoke plugin protocol, keeps that composition predictable: the same authentication, access control, and observability apply no matter how deeply agents are nested.

Further reading​