Register agents through API

from atlanai import AtlanClient

client = AtlanClient(
    "https://api.atlan.com",
    bearer_token="...",
    workspace="workspace_01example",
)

agent = client.agents.create({
        "name": "support-rover",
        "display_name": "Support Rover",
        "workspace_id": "workspace_01example",
        "instructions": "Triage inbound support tickets and draft a first reply.",
        "model_id": "claude-sonnet-5",
        "max_step_count": 12,
    }
)

import { AtlanClient, rawAgent } from "@atlanai/sdk";

const client = new AtlanClient({
  gatewayOrigin: "https://api.atlan.com",
  bearerToken: "...",
  workspace: "workspace_01example",
});

const agent = await client.agents.create({
    name: "support-rover",
    displayName: "Support Rover",
    workspaceId: "workspace_01example",
    instructions: "Triage inbound support tickets and draft a first reply.",
    modelId: "claude-sonnet-5",
    maxStepCount: 12,
});

agent = client.agents.update("agent_01example",
    {
        "tools": [
            {"kind": "builtin", "name": "web_search"},
            {"kind": "mcp", "server": "atlan", "tool": "registry__search"},
        ]
    },
)

const agent = await client.agents.update("agent_01example", {
  tools: [
    { kind: rawAgent.GatewayToolRefOneOfKindEnum.Builtin, name: "web_search" },
    { kind: rawAgent.GatewayToolRefOneOf1KindEnum.Mcp, server: "atlan", tool: "registry__search" },
  ],
});

provider = client.agent_providers.create({
        "name": "internal-runner",
        "workspace_id": "workspace_01example",
        "provider_type": "custom",
        "base_url": "https://runner.example.internal",
    }
)

agent = client.agents.update("agent_01example",
    {"agent_provider_id": provider.id},
)

const provider = await client.agentProviders.create({
    name: "internal-runner",
    workspaceId: "workspace_01example",
    providerType: rawAgent.AgentAgentProviderType.Custom,
    baseUrl: "https://runner.example.internal",
});

const agent = await client.agents.update("agent_01example", {
  agentProviderId: provider.id,
});

import atlanai.tracing as atlan

tracer = atlan.init(service_name="support-rover")

visitor = tracer.identify(
    identity_source="slack",
    external_id="U0123ABC",
    traits={"name": "Jordan Lee"},
)

with atlan.propagate_attributes(
    session_id="ticket-4821",
    visitor_id=visitor.id if visitor else None,
):
    with tracer.start_as_current_span("handle-ticket", as_type="task") as root:
        with tracer.start_as_current_span("chat", as_type="llm") as generation:
            generation.update(
                model="claude-sonnet-5",
                provider="anthropic",
                usage={"input_tokens": 1200, "output_tokens": 340},
                cost={"input": 0.0036, "output": 0.0051},
            )
        root.score_trace("resolved", value=True, data_type="BOOLEAN")

tracer.flush()

import * as atlan from "@atlanai/sdk/tracing";

const tracer = atlan.init({ serviceName: "support-rover" });

const visitor = await tracer.identify({
  identitySource: "slack",
  externalId: "U0123ABC",
  traits: { name: "Jordan Lee" },
});

await atlan.propagateAttributes(
  { sessionId: "ticket-4821", visitorId: visitor?.id },
  async () => {
    await tracer.startAsCurrentSpan("handle-ticket", { asType: "task" }, async (root) => {
      await tracer.startAsCurrentSpan("chat", { asType: "llm" }, async (generation) => {
        generation.update({
          model: "claude-sonnet-5",
          provider: "anthropic",
          usage: { input_tokens: 1200, output_tokens: 340 },
          cost: { input: 0.0036, output: 0.0051 },
        });
      });
      root.scoreTrace("resolved", true, { dataType: "BOOLEAN" });
    });
  },
);

await tracer.flush();

matches = client.agents.search({
        "query": "support triage",
        "workspace_id": "workspace_01example",
        "limit": 20,
    }
)

everything = client.agents.list(limit=20)
one = client.agents.get("agent_01example")
traces = client.agents.traces.list("agent_01example", limit=10)

const matches = await client.agents.search({
    query: "support triage",
    workspaceId: "workspace_01example",
    limit: 20,
});

const everything = await client.agents.list({ limit: 20 });
const one = await client.agents.get({ agentId: "agent_01example" });
const traces = await client.agents.traces.list({
  agentId: "agent_01example",
  limit: 10,
});

session = client.sessions.create_record(
    {
        "name": "rover-run-4821",
        "workspace_id": "workspace_01example",
        "subject_kind": "agent",
        "subject_id": "agent_01example",
        "session_status": "completed",
        "title": "Triage ticket 4821",
        "external_session_id": "run-4821",
        "model_id": "claude-sonnet-5",
        "stop_reason": "end_turn",
        "source_created_at": "2026-09-01T09:14:02Z",
    }
)

client.sessions.messages.create(
    session.id,
    {
        "name": "rover-run-4821-msg-1",
        "workspace_id": "workspace_01example",
        "sequence_number": 1,
        "message_role": "user",
        "content": "Customer cannot log in after the password reset.",
    },
)

transcript = client.sessions.messages.list(session.id)

const session = await client.sessions.createRecord({
    name: "rover-run-4821",
    workspaceId: "workspace_01example",
    subjectKind: rawAgent.AgentSubjectKind.Agent,
    subjectId: "agent_01example",
    sessionStatus: rawAgent.AgentSessionStatus.Completed,
    title: "Triage ticket 4821",
    externalSessionId: "run-4821",
    modelId: "claude-sonnet-5",
    stopReason: "end_turn",
    sourceCreatedAt: "2026-09-01T09:14:02Z",
});

await client.sessions.messages.create(session.id, {
  name: "rover-run-4821-msg-1",
  workspaceId: "workspace_01example",
  sequenceNumber: 1,
  messageRole: rawAgent.AgentMessageRole.User,
  content: "Customer cannot log in after the password reset.",
});

const transcript = await client.sessions.messages.list(session.id);

from pathlib import Path

payload = Path("./run-4821-transcript.json").read_bytes()

ticket = client.files.uploads.create({"size_bytes": len(payload)})
client.files.uploads.ingest(ticket.upload_key, payload)

import { readFile } from "node:fs/promises";

const payload = await readFile("./run-4821-transcript.json");

const ticket = await client.files.uploads.create({ sizeBytes: payload.byteLength });
await client.files.uploads.ingest(ticket.uploadKey, new Blob([payload]));