> For the complete documentation index, see [llms.txt](https://docs.concurrence.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.concurrence.com/developer-guide/readme.md).

# Welcome

Choose the correct Concurrence API, configure credentials and region, and follow implementation guides for data, agents, channels, and operations.

{% hint style="info" %}
**Amigo is now Concurrence.** Keep using the API hosts, package names, and imports shown in the examples. This documentation rebrand does not rename those integration contracts. See [Rebrand and Compatibility](https://docs.concurrence.com/reference/concurrence-rebrand).
{% endhint %}

Build an integration with Concurrence using the API and credentials assigned to your deployment. This guide connects setup, SDK examples, and endpoint contracts to the workflow you want to implement.

For the system model and deployment responsibilities, start with [Core Concepts](https://docs.concurrence.com/platform-overview/core-concepts) and [Operating Model](https://docs.concurrence.com/platform-overview/operating-model). For generated operation and schema references, use the [API Reference](https://docs.concurrence.com/api-reference).

## Choose a Task

| Goal                                       | Start here                                                                                                          |
| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------- |
| Evaluate architecture and deployment fit   | [Technical evaluation packet](https://docs.concurrence.com/platform-overview/evaluation-packet)                     |
| Try the Platform SDK without credentials   | [First Verified Conversation](/developer-guide/guides/first-verified-conversation.md), **Local walkthrough**        |
| Test an existing service in the browser    | [First Console Conversation](/developer-guide/guides/first-console-conversation.md)                                 |
| Connect the starter to your test workspace | [First Verified Conversation](/developer-guide/guides/first-verified-conversation.md), **Provisioned test service** |
| Choose Platform, Classic, or Scribe access | [Choose Credentials](/developer-guide/getting-started/credentials.md)                                               |
| Verify an action or managed channel        | [Task guides](/developer-guide/guides.md)                                                                           |
| Investigate an incomplete result           | [Troubleshooting](/developer-guide/guides/troubleshooting.md)                                                       |
| Plan an upgrade                            | [Current integration and upgrade guidance](https://docs.concurrence.com/api-reference/change-logs/upgrade-guide)    |

## Quick Start

Choose your API before installing a client or copying a request. Both APIs support conversational workflows; the distinction is their resource and authentication contracts, not simply text versus voice.

{% tabs %}
{% tab title="Platform API" %}
Use the workspace-scoped Platform API for deployed agent workflows, shared world-model data, supported voice and messaging channels, integrations, and operator controls.

1. Download and run [First Verified Conversation](/developer-guide/guides/first-verified-conversation.md) locally. The starter includes the SDK and needs no Concurrence credentials in local mode.
2. When your test workspace is ready, confirm its ID, [regional endpoint](/developer-guide/getting-started/regions-and-endpoints.md), and [accepted credential](/developer-guide/platform-api/platform-api/authentication.md).
3. Complete the starter's **Provisioned test service** checklist, then run it against that service and inspect the result.
4. Follow [Build and Prove](/developer-guide/guides/build-and-prove.md), then [Operate and Improve](/developer-guide/guides/operate-and-improve.md). Use the [SDK quickstart](/developer-guide/platform-api/platform-sdk/quickstart.md) to explore additional operations.
   {% endtab %}

{% tab title="Classic API" %}
Use the organization-scoped Classic API for integrations built around Classic users, services, conversation event streams, Actions, and Dynamic Behaviors.

1. Confirm the organization ID, user ID, and [regional endpoint](/developer-guide/getting-started/regions-and-endpoints.md).
2. Set up the [Classic API key-to-token exchange](/developer-guide/getting-started/authentication.md).
3. Install a [Classic SDK](/developer-guide/classic-api/sdks/sdk-installation.md): `amigo-sdk` for Python or `@amigo-ai/sdk` for TypeScript.
4. Run [Hello World](/developer-guide/classic-api/sdks/sdk-hello-world.md), including incremental handling of conversation events.
5. Continue with the [Classic resource guide](/developer-guide/classic-api/core-api.md).
   {% endtab %}
   {% endtabs %}

## API Comparison

| Decision           | Platform API                                                                                            | Classic API                                                                     |
| ------------------ | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| Resource boundary  | Workspace for workspace-scoped resources; some identity and management routes have other scopes         | Organization and authenticated user                                             |
| Credential flow    | Workspace keys, interactive identity credentials, or scoped OAuth credentials on their supported routes | API key credentials exchanged for a user bearer token                           |
| Conversation paths | Text turns, persistent sessions, phone calls, and managed messaging with channel-specific lifecycles    | Conversation create/interact streams, voice notes, and supported realtime paths |
| Agent capabilities | Context Graph tool bindings, Skills, platform functions, and integrations                               | Versioned Tools/Actions and Dynamic Behaviors                                   |
| Client packages    | `@amigo-ai/platform-sdk`                                                                                | `@amigo-ai/sdk`, `amigo-sdk`                                                    |

Shared names such as service, agent, or version set do not make IDs, credentials, payloads, or SDK methods interchangeable. [Core Concepts](/developer-guide/getting-started/core-concepts.md) maps each resource to its owning API.

### System Architecture

For a workflow that crosses data retrieval, agent execution, an external action, and human follow-up, read [How It Works](https://docs.concurrence.com/platform-overview/how-it-works). This guide owns the implementation details for those boundaries.

## Documentation Structure

[Guides](/developer-guide/guides.md) follow the customer workflow: Build, Prove, Operate, Improve, Data, and Govern. [Scribe](/developer-guide/guides/scribe-capture-to-note.md) has its own provider workflow. Use [Compatibility and Retirements](/developer-guide/guides/compatibility-and-retirements.md) for Classic setup and removed interfaces.

| Your next task                                    | Start here                                                                                                                                                                                             |
| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Establish credentials and regional routing        | [Getting Started](/developer-guide/getting-started.md)                                                                                                                                                 |
| Configure agents, services, and version selection | [Platform resources](/developer-guide/platform-api/platform-api.md) or [Classic resources](/developer-guide/classic-api/core-api.md)                                                                   |
| Build a specific workflow                         | [Guides](/developer-guide/guides.md)                                                                                                                                                                   |
| Use a typed client                                | [Platform SDK](/developer-guide/platform-api/platform-sdk.md) or [Classic SDKs](/developer-guide/classic-api/sdks.md)                                                                                  |
| Connect workspace data and external systems       | [Data & World Model](/developer-guide/platform-api/data-world-model.md) and [Integrations](/developer-guide/platform-api/integrations.md)                                                              |
| Query Classic organization data                   | [Data Access](/developer-guide/classic-api/data-access.md)                                                                                                                                             |
| Inspect runtime outcomes                          | [Runs](/developer-guide/platform-api/conversations/runs.md), [Operators](/developer-guide/platform-api/conversations/operators.md), and [Safety & Monitoring](/developer-guide/platform-api/safety.md) |
| Maintain an existing deployment                   | [Best Practices](/developer-guide/operations/devops.md), with each page's API and CLI scope                                                                                                            |
| Check terminology or compatibility                | [Reference](/developer-guide/operations/reference.md) and [Change Logs](https://docs.concurrence.com/api-reference/change-logs)                                                                        |

## Support and Resources

Use the public schema embedded in each endpoint section for its request and response contract. The surrounding prose explains authorization, lifecycle, failure handling, and availability that a schema alone cannot establish. WebSocket and separately served routes identify their own protocol or schema boundary.

For deployment-specific access and support, contact your Concurrence representative through your agreed support channel. Report SDK issues in the relevant package repository: [Platform TypeScript](https://github.com/concurrence-hq/amigo-platform-typescript-sdk/issues), [Classic TypeScript](https://github.com/concurrence-hq/amigo-typescript-sdk/issues), or [Classic Python](https://github.com/concurrence-hq/amigo-python-sdk/issues).


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.concurrence.com/developer-guide/readme.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.