Trusted Platform for Production AI

@tool
def check_balance(account_id: str) -> dict:
    """Check the balance of a bank account."""
    return {"account_id": account_id, "balance": 5432.10, "currency": "USD"}


@tool
def lookup_order(order_id: str) -> dict:
    """Look up the status of an order."""
    return {"order_id": order_id, "status": "shipped", "eta": "2 days"}


billing = Agent(
    name="billing",
    model="openai/gpt-4o",
    instructions="Handle billing questions: balances, payments, invoices.",
    tools=[check_balance],
)

orders = Agent(
    name="orders",
    model="openai/gpt-5",
    instructions="Handle order questions: status, shipping, returns.",
    tools=[lookup_order],
)

support = Agent(
    name="support",
    model="openai/gpt-4o",
    instructions="Route each request to the right specialist.",
    agents=[billing, orders],
    strategy=Strategy.HANDOFF,
)

with AgentRuntime() as runtime:
    result = runtime.run(support, "What's the balance on account ACC-123?")
    result.print_result()

const checkBalance = tool(
  async (args: { accountId: string }) => ({
    account_id: args.accountId,
    balance: 5432.10,
    currency: 'USD',
  }),
  {
    name: 'check_balance',
    description: 'Check the balance of a bank account.',
    inputSchema: {
      type: 'object',
      properties: { accountId: { type: 'string', description: 'The account ID' } },
      required: ['accountId'],
    },
  },
);

const lookupOrder = tool(
  async (args: { orderId: string }) => ({
    order_id: args.orderId,
    status: 'shipped',
    eta: '2 days',
  }),
  {
    name: 'lookup_order',
    description: 'Look up the status of an order.',
    inputSchema: {
      type: 'object',
      properties: { orderId: { type: 'string', description: 'The order ID' } },
      required: ['orderId'],
    },
  },
);

const billing = new Agent({
  name: 'billing',
  model: 'openai/gpt-4o',
  instructions: 'Handle billing questions: balances, payments, invoices.',
  tools: [checkBalance],
});

const orders = new Agent({
  name: 'orders',
  model: 'openai/gpt-5',
  instructions: 'Handle order questions: status, shipping, returns.',
  tools: [lookupOrder],
});

const support = new Agent({
  name: 'support',
  model: 'openai/gpt-4o',
  instructions: 'Route each request to the right specialist.',
  agents: [billing, orders],
  strategy: 'handoff',
});

const runtime = new AgentRuntime();
try {
  const result = await runtime.run(support, "What's the balance on account ACC-123?");
  result.printResult();
} finally {
  await runtime.shutdown();
}

using Conductor.Api;
using Conductor.Client;
using Conductor.Client.Authentication;
using Conductor.Client.Models;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var configuration = new Configuration
        {
            BasePath = "https://api.orkes.io",
            AuthenticationSettings = new OrkesAuthenticationSettings(
                keyId: "YOUR_KEY_ID",
                keySecret: "YOUR_KEY_SECRET"
            )
        };

        var executor = new WorkflowExecutor(configuration);

        var request = new StartWorkflowRequest
        {
            Name = "ai-agent-workflow",
            Version = 1,
            Input = new Dictionary<string, object>
            {
                { "userId", "123" },
                { "message", "Run AI agent" }
            }
        };

        var workflowId = executor.StartWorkflow(request);
        Console.WriteLine($"Started workflow with ID: {workflowId}");
    }
}

import { ConductorClient, WorkflowExecutor } from '@io-orkes/conductor-javascript'

const client = new ConductorClient({
  serverUrl: 'https://api.orkes.io',
  keyId: process.env.KEY_ID,
  keySecret: process.env.KEY_SECRET
})

const workflowExecutor = new WorkflowExecutor(client)

const result = await workflowExecutor.startWorkflow({
  name: 'ai-agent-workflow',
  version: 1,
  input: {
    userId: '123',
    message: 'Run AI agent'
  }
})

console.log('Workflow started:', result.workflowId)