> ## Documentation Index
> Fetch the complete documentation index at: https://docs.corti.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# 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.

<Tip>
  After completing this quickstart, you'll have a working agent and know where to go next based on your use case.
</Tip>

### Prerequisites

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

<Steps>
  <Step title="Create a Project in the Corti Console" titleSize="h3">
    Start by creating a project in the <a href="https://console.corti.app" target="_blank" rel="noreferrer">Corti console</a>. This gives you a workspace and access to manage your clients and credentials. If you haven't set up authentication before, follow the <a href="/authentication/creating_clients">Creating Clients</a> and <a href="/authentication/quickstart">authentication quickstart</a> guides.
  </Step>

  <Step title="Create Your First Agent" titleSize="h3">
    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.

    <CodeGroup>
      ```ts title="JavaScript" theme={null}
      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",
      });
      ```

      ```csharp title="C# .NET" theme={null}
      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",
          }
      );
      ```

      ```python title="Python" expandable theme={null}
      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()
      ```

      ```bash title="cURL" theme={null}
      # 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"
        }'
      ```
    </CodeGroup>
  </Step>

  <Step title="Run Your Agent" titleSize="h3">
    Use your stored credentials to authenticate, then run your agent end-to-end and verify it processes input and returns the expected outputs.

    <CodeGroup>
      ```ts title="JavaScript" theme={null}
      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);
      ```

      ```csharp title="C# .NET" theme={null}
      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,
              },
          }
      );
      ```

      ```python title="Python" expandable theme={null}
      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"])
      ```

      ```bash title="cURL" theme={null}
      # 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"
          }
        }'
      ```
    </CodeGroup>
  </Step>
</Steps>

### Next Steps

Depending on your use case:

* **Building custom agents**: See [Core Concepts](/agentic/core-concepts)
* **Integrating with existing systems**: See [SDKs & Integrations](/agentic/sdks-integrations)
* **Understanding the architecture**: See [Architecture Overview](/agentic/architecture)
* **Working with protocols**: See [A2A Protocol](/agentic/a2a-protocol) and [MCP Protocol](/agentic/mcp-protocol)

<Note>Please [contact us](https://help.corti.app/) if you need more information about the Corti Agentic Framework.</Note>