Quickstart & First Build

Get started with the Corti Agentic Framework

This guide will walk you through setting up your first agent and getting it running end-to-end.

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

Prerequisites

• API access credentials
• Development environment set up
• Basic understanding of REST APIs

1. 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. If you haven’t set up authentication before, follow the Creating Clients and authentication quickstart guides.

2. Create Your First Agent

   Use the Corti Agentic API to create your first agent. You’ll need an access token (obtained using your client credentials) and your tenant name.

   JavaScript

   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",
   });
   

   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 AgentsCreateAgent
       {
           Name = "My First Agent",
           Description = "A simple agent to get started with the Corti Agentic Framework",
       }
   );
   

   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/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",
       },
   )
   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/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"
     }'
   
3. Run Your Agent

   Use your stored credentials to authenticate, then run your agent end-to-end and verify it processes input and returns the expected outputs.

   JavaScript

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

   var agentResponse = await client.Agents.MessageSendAsync(
       myAgent.Id,
       new AgentsMessageSendParams
       {
           Message = new AgentsMessage
           {
               Role = AgentsMessageRole.User,
               Parts = new AgentsPart[]
               {
                   new AgentsTextPart
                   {
                       Kind = AgentsTextPartKind.Text,
                       Text = "Hello there. This is my first message.",
                   }
               },
               MessageId = "messageId",
               Kind = AgentsMessageKind.Message,
           },
       }
   );
   

   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/agents/{AGENT_ID}/v1/message:send",
       headers={
           "Authorization": f"Bearer {TOKEN}",
           "Tenant-Name": TENANT,
           "Content-Type": "application/json",
       },
       json={
           "message": {
               "role": "user",
               "parts": [
                   {
                       "kind": "text",
                       "text": "Hello there. This is my first message.",
                   }
               ],
               "messageId": str(uuid.uuid4()),
               "kind": "message",
           }
       },
   )
   response.raise_for_status()
   task_response = response.json()
   
   # Print the task status message text (equivalent to agentResponse.task.status.message.parts[0].text)
   print(task_response["task"]["status"]["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/agents/${AGENT_ID}/v1/message:send" \
     -H "Authorization: Bearer ${TOKEN}" \
     -H "Tenant-Name: ${TENANT}" \
     -H "Content-Type: application/json" \
     -d '{
       "message": {
         "role": "user",
         "parts": [{ "kind": "text", "text": "Hello there. This is my first message." }],
         "messageId": "msg-001",
         "kind": "message"
       }
     }'
   

Next Steps

Depending on your use case:

• Building custom agents: See Core Concepts
• Integrating with existing systems: See SDKs & Integrations
• Understanding the architecture: See Architecture Overview
• Working with protocols: See A2A Protocol and MCP Protocol

Please contact us if you need more information about the Corti Agentic Framework.