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

# Quickstart: from first trace to first insight

> Send your first agent run, open the trace, tag a user and session, and see the platform detect a behavioral pattern.

This quickstart takes you past "telemetry is arriving" and through the workflow you will actually use: send a real run, inspect its trace, attach user and session identity, and see The Context Company detect a behavioral signal.

Plan on about 10 minutes.

<Steps>
  <Step title="Create an account and grab a key">
    Sign up at [thecontextcompany.com](https://www.thecontextcompany.com) and copy an ingestion key (prefixed `tcc_prod` for production or `dev_` for your personal dev environment) from **Settings**.

    Set it as `TCC_API_KEY` in your environment. See [Environments](/environments) for the difference between dev, prod, and local mode.
  </Step>

  <Step title="Instrument your agent">
    Pick your framework and follow its integration page. Each one installs a small package and hooks into the framework's native tracing.

    <CardGroup cols={2}>
      <Card title="Vercel AI SDK" icon="rocket" href="/frameworks/vercel-ai-sdk/index" />

      <Card title="Claude Agent SDK" icon="robot" href="/frameworks/claude-agent-sdk/index" />

      <Card title="Mastra" icon="gear" href="/frameworks/mastra/index" />

      <Card title="LangChain & LangGraph" icon="link" href="/frameworks/langchain-langgraph/index" />

      <Card title="CrewAI" icon="users" href="/frameworks/crewai/index" />

      <Card title="Agno" icon="microchip" href="/frameworks/agno/index" />
    </CardGroup>

    If you use another framework, use the [Python](/frameworks/custom-instrumentation/python/setup) or [TypeScript](/frameworks/custom-instrumentation/typescript/setup) custom instrumentation, or the [OpenTelemetry integration](/integrations/opentelemetry/index).
  </Step>

  <Step title="Send a real interaction, not a hello world">
    Trigger your agent the way a real user would (a real prompt, real tools, real downstream calls). One good run is enough.

    On that call, attach the reserved metadata that turns the run into something you can analyze:

    ```ts theme={null}
    ...tccTelemetry({
      metadata: {
        "tcc.runId": crypto.randomUUID(),
        "tcc.sessionId": conversationId,
        "tcc.conversational": true,
        "tcc.agent": "support-agent",
        "tcc.userId": user.id,
        "tcc.userName": user.name,
        "tcc.orgId": user.orgId,
        "tcc.orgName": user.orgName,
      },
    })
    ```

    Setting `tcc.conversational: true` enables behavioral pattern analysis on the run. Framework-specific syntax lives on each integration page.
  </Step>

  <Step title="Open the run">
    In the [dashboard](https://www.thecontextcompany.com/prod/runs), open the run you just sent. You will see:

    * The full prompt and response
    * Every model step in order
    * Every tool call with its arguments, result, latency, and status
    * Tokens and cost per step
    * The user, organization, session, and agent it belongs to

    This is the [trace](/investigate/traces). It is the primary evidence for every failure, pattern, and Insight Search result later on.
  </Step>

  <Step title="Filter by user, org, or agent">
    From the runs list, filter by the `tcc.userId`, `tcc.orgId`, or `tcc.agent` you just set. These are first-class filters, not custom metadata. See [Users and organizations](/analyze/users-and-organizations) for the analyses this unlocks.
  </Step>

  <Step title="Send a few more runs, then check patterns">
    Send a handful more conversational runs (a mix of good, bad, and ambiguous is ideal).

    Open [Patterns](/analyze/patterns). Three built-in patterns run automatically on conversational runs:

    * **Frustration** — user expresses annoyance
    * **Confusion** — user indicates they don't understand
    * **Task failure reported** — user reports the agent didn't complete their request

    Open any pattern to see matching runs, the confidence score, and the evidence the classifier used.
  </Step>

  <Step title="Ask a question in natural language">
    Open [Insight Search](/analyze/insight-search) and ask something specific about your data:

    > What are the most expensive runs in the last day and which tools did they call?

    You get a written answer, the runs behind it, and links straight into their traces. Insight Search is also available from [Slack](/integrations/slack) and [MCP](/access-data/mcp).
  </Step>

  <Step title="Optional: connect Slack">
    Connect [Slack](/integrations/slack) to receive pattern alerts, subscribe channels to [Recaps](/analyze/recaps), and run Insight Search from a thread. Add the bot with `/subscribe` in any channel.
  </Step>
</Steps>

## What you have now

* Runs, sessions, users, organizations, and agents flowing in with the identity your product knows about
* Full execution traces (model calls, tool calls, arguments, results, errors, cost, latency) per run
* Automatic pattern detection on conversational runs
* Natural-language investigation over the whole dataset from the dashboard, Slack, MCP, and the [REST API](/access-data/api)

## Next

<CardGroup cols={2}>
  <Card title="Walk through a silent tool failure" icon="bug" href="/investigate/tutorial-silent-tool-failure">
    See exactly how execution-aware analytics catches a bug that transcript-only analytics would miss.
  </Card>

  <Card title="Concepts" icon="cubes" href="/concepts">
    Runs, sessions, users, organizations, and the reserved metadata keys.
  </Card>

  <Card title="Patterns" icon="magnifying-glass" href="/analyze/patterns">
    Add custom classifiers for domain-specific behaviors.
  </Card>

  <Card title="Traces" icon="diagram-project" href="/investigate/traces">
    How trace data drives every analysis feature.
  </Card>
</CardGroup>