Quickstart

This guide walks you through creating your first agent with a registry connector, sending a message, and receiving a response. By the end, you will have a working end-to-end agent.

After completing this quickstart, you will have a working agent and know where to go next based on your use case.

Prerequisites

API access credentials (client ID and client secret, or an access token)
Development environment set up
Basic understanding of REST APIs

If you haven’t set up authentication, follow the Creating Clients and authentication quickstart guides first.

Create a project in the Corti Console

Start by creating a project in the Corti Console. This gives you a workspace and access to manage your clients and credentials.

Create your first agent

Use the Agentic API to create your first agent. You need an access token (obtained using your client credentials) and your tenant name.The example below creates a persistent agent with a registry connector (memory-expert) attached.

import { CortiClient } from "@corti/sdk";

// Replace these with your values
const CLIENT_ID = "<your-client-id>";
const CLIENT_SECRET = "<your-client-secret>";
const ENVIRONMENT = "<eu-or-us>";
const TENANT = "<your-tenant-name>";

const client = new CortiClient({
    tenantName: TENANT,
    environment: ENVIRONMENT,
    auth: {
        clientId: CLIENT_ID,
        clientSecret: CLIENT_SECRET,
    },
});

const myAgent = await client.agents.create({
    name: "My First Agent",
    description: "A simple agent to get started with the Corti Agentic Framework",
    lifecycle: "persistent",
    connectors: [
        { type: "registry", name: "memory-expert" },
    ],
});

using Corti;

// Replace these with your values
const string CLIENT_ID = "<your-client-id>";
const string CLIENT_SECRET = "<your-client-secret>";
const string ENVIRONMENT = "<eu-or-us>";
const string TENANT = "<your-tenant-name>";

var client = new CortiClient(
    tenantName: TENANT,
    environment: ENVIRONMENT,
    auth: CortiClientAuth.ClientCredentials(clientId: CLIENT_ID, clientSecret: CLIENT_SECRET)
);

var myAgent = await client.Agents.CreateAsync(
    new AgentsCreateRequest
    {
        Name = "My First Agent",
        Description = "A simple agent to get started with the Corti Agentic Framework",
        Lifecycle = AgentsLifecycle.Persistent,
        Connectors = new[]
        {
            new CommonRegistryConnectorCreate
            {
                Type = "registry",
                Name = "memory-expert",
            },
        },
    }
);

import requests

# Replace these with your values
ENVIRONMENT = "<eu-or-us>"
TENANT = "<your-tenant-name>"
TOKEN = "<your-access-token>"

response = requests.post(
    f"https://api.{ENVIRONMENT}.corti.app/v2/agentic/agents",
    headers={
        "Authorization": f"Bearer {TOKEN}",
        "Tenant-Name": TENANT,
        "Content-Type": "application/json",
    },
    json={
        "name": "My First Agent",
        "description": "A simple agent to get started with the Corti Agentic Framework",
        "lifecycle": "persistent",
        "connectors": [
            {"type": "registry", "name": "memory-expert"},
        ],
    },
)
response.raise_for_status()
agent = response.json()

# Replace these with your values
ENVIRONMENT="<eu-or-us>"
TENANT="<your-tenant-name>"
TOKEN="<your-access-token>"

curl -X POST "https://api.${ENVIRONMENT}.corti.app/v2/agentic/agents" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Tenant-Name: ${TENANT}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My First Agent",
    "description": "A simple agent to get started with the Corti Agentic Framework",
    "lifecycle": "persistent",
    "connectors": [
      {"type": "registry", "name": "memory-expert"}
    ]
  }'

The response includes the agent’s id (a prefixed UUIDv7 like agt.0192f4c8-...). Save this ID for the next step.

Send a message

Send a message to your agent using the A2A HTTP+JSON binding. The response is either a Task (for longer work) or a Message (for quick responses).

const agentResponse = await client.agents.messageSend(myAgent.id, {
    message: {
        role: "ROLE_USER",
        parts: [{
            text: "Hello there. This is my first message.",
        }],
        messageId: crypto.randomUUID(),
    },
});

if (agentResponse.task) {
    console.log(agentResponse.task.status.state);
    console.log(agentResponse.task.history?.at(-1)?.parts?.[0]?.text);
} else if (agentResponse.message) {
    console.log(agentResponse.message.parts[0].text);
}

var agentResponse = await client.Agents.MessageSendAsync(
    myAgent.Id,
    new A2ASendMessageRequest
    {
        Message = new CommonMessage
        {
            Role = CommonRole.RoleUser,
            Parts = new[]
            {
                new CommonPart
                {
                    Text = "Hello there. This is my first message.",
                }
            },
            MessageId = Guid.NewGuid().ToString(),
        },
    }
);

if (agentResponse.Task != null)
{
    Console.WriteLine(agentResponse.Task.Status.State);
}
else if (agentResponse.Message != null)
{
    Console.WriteLine(agentResponse.Message.Parts[0].Text);
}

import uuid
import requests

# Replace these with your values
AGENT_ID = "<your-agent-id>"
ENVIRONMENT = "<eu-or-us>"
TENANT = "<your-tenant-name>"
TOKEN = "<your-access-token>"

response = requests.post(
    f"https://api.{ENVIRONMENT}.corti.app/v2/agentic/agents/{AGENT_ID}/a2a/message:send",
    headers={
        "Authorization": f"Bearer {TOKEN}",
        "Tenant-Name": TENANT,
        "Content-Type": "application/json",
        "A2A-Version": "1.0",
    },
    json={
        "message": {
            "role": "ROLE_USER",
            "parts": [
                {"text": "Hello there. This is my first message."}
            ],
            "messageId": str(uuid.uuid4()),
        }
    },
)
response.raise_for_status()
result = response.json()

if "task" in result:
    task = result["task"]
    print(task["status"]["state"])
    if task.get("history"):
        print(task["history"][-1]["parts"][0]["text"])
elif "message" in result:
    print(result["message"]["parts"][0]["text"])

# Replace these with your values
AGENT_ID="<your-agent-id>"
ENVIRONMENT="<eu-or-us>"
TENANT="<your-tenant-name>"
TOKEN="<your-access-token>"

curl -X POST "https://api.${ENVIRONMENT}.corti.app/v2/agentic/agents/${AGENT_ID}/a2a/message:send" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Tenant-Name: ${TENANT}" \
  -H "Content-Type: application/json" \
  -H "A2A-Version: 1.0" \
  -d '{
    "message": {
      "role": "ROLE_USER",
      "parts": [{ "text": "Hello there. This is my first message." }]
    }
  }'

Verify the response

Check the response to confirm your agent processed the message:

If the response contains a task, check task.status.state. A TASK_STATE_COMPLETED state means the task finished successfully. The agent’s response is in task.history (the last ROLE_AGENT message).
If the response contains a message, the agent responded directly. The text is in message.parts[0].text.

The response includes task.metadata.$usage.credits, reporting the credits used for the request. See Tracking credit consumption to attribute this to your own customers or features.

Next steps

Core concepts

Learn the fundamental building blocks: agents, connectors, tasks, messages, and contexts.

Connectors

Understand the five connector types and how to attach them to agents.

Send a message

Go deeper into message sending: blocking vs. non-blocking, DataParts, error handling.

Stream responses

Stream agent responses in real time via SSE.

Concepts

Guides

Reference

Registry Connectors

Agent SDK

v1 Documentation (archived)

Quickstart

Prerequisites

Create a project in the Corti Console

Create your first agent

Send a message

Verify the response

Next steps

Core concepts

Connectors

Send a message

Stream responses

​Prerequisites

Create a project in the Corti Console

Create your first agent

Send a message

Verify the response

​Next steps

Core concepts

Connectors

Send a message

Stream responses

Prerequisites

Next steps