# Quickstart This quickstart shows the shortest path from a tagIt account to a working AI journey. It is intentionally lightweight. For definitions, see [Concepts](/tagit/getting-started/concepts.md). For the runtime model, see [Orchestration architecture](/tagit/getting-started/orchestration-architecture.md) and [Presence architecture](/tagit/getting-started/presence-architecture.md). For exact request and response fields, see the [Orchestrator API reference](/tagit/reference/reference/api/orchestrator.md), [Collector API reference](/tagit/reference/reference/api/collector.md), and [AI client reference](/tagit/reference/reference/ai-client.md). ## What you are building You are building an AI experience that can: 1. run an agentic use case through the AI Orchestrator 2. return a response to a user or service 3. preserve conversation context when needed 4. optionally emit AI Presence events so the journey can be analyzed and improved over time The first version can be simple: one client, one context, one agentic use case, one published snapshot, and one API key. ## Before you begin To use tagIt effectively, you should have: * a tagIt account * a clear product or service surface where the AI experience will live * a first agentic use case in mind * an AI Orchestrator API key * a client that will call the AI Orchestrator, such as AI Canvas, a custom web client, or a backend service If you do not have an account yet, contact ****. A good first use case is narrow and concrete: * answer questions about a product or service * guide a user through onboarding * qualify a visitor before a sales handoff * generate a recommendation from known data * help an operations user complete a structured task ## Step 1: Define the AI journey Start with the moment in the product journey, not the model. Ask: * What user or operator moment are we supporting? * What outcome should the AI help produce? * What context does the AI need to behave correctly? * Is this a one-turn interaction or a multi-step workflow? For example: * A website assistant helps a visitor understand whether tagIt fits their product. * A media planning workflow gathers availability data and produces a recommendation artifact. * A support assistant answers policy questions and escalates when needed. This gives you the business shape of the journey before you configure the runtime. ## Step 2: Create a context A [context](/tagit/getting-started/concepts.md#context) is the workspace under an account where you define the shared operating environment for a set of AI experiences. Use the context to set shared governance and runtime assumptions, such as: * context-level instructions * available AI models * allowed connectors * runtime policies * tag and collection settings * access and permissions Context instructions are useful for stable guidance that should apply broadly across the agentic use cases inside that context. ## Step 3: Create an agentic use case An [agentic use case](/tagit/getting-started/concepts.md#agentic-use-case) is the executable AI capability the AI Orchestrator runs. Choose whether the first use case is: * an **agentic turn**, when the same instructions and runtime configuration should be applied repeatedly across a conversation * an **agentic workflow**, when the Orchestrator should manage multiple steps, handoffs, tools, artifacts, checkpoints, or traceability Configure the use case with the runtime behavior it needs: * use-case instructions * AI model settings * connector access * policies and limits * conversation memory settings * artifact behavior, if the workflow creates durable output The most important idea: an agentic use case is not just a prompt. It is the runtime configuration for a specific stage of the AI journey. ## Step 4: Test and publish a snapshot A [snapshot](/tagit/getting-started/concepts.md#snapshot) is a saved version of the use case runtime configuration. Before a client calls the use case in production: 1. Save the use case draft. 2. Run a test in the platform. 3. Inspect the run and execution trace. 4. Adjust instructions, model settings, connectors, or policies as needed. 5. Publish the snapshot that should power the live experience. When a client calls the use case without specifying a snapshot, the AI Orchestrator resolves the published snapshot by default. See the [Orchestrator API reference](/tagit/reference/reference/api/orchestrator.md) for execution details. ## Step 5: Call the AI Orchestrator The client sends the current request to the AI Orchestrator. Clients should send the current user message along with the identity and runtime fields needed by the Orchestrator. At minimum, a simple client usually needs: * `use_case_id` * `user_id` * `conversation_id` * the current message * an API key The conversation ID lets the Orchestrator store and rehydrate relevant conversation history when the use case allows it. You can call the Orchestrator from: * AI Canvas * a custom web client * a backend service * an automation job For exact request and response shapes, use the [Orchestrator API reference](/tagit/reference/reference/api/orchestrator.md). ## Step 6: Use AI Canvas or build your own client [AI Canvas](/tagit/getting-started/concepts.md#ai-canvas) is the quickest way to embed a tagIt-compatible AI client into a web experience. Teams can use AI Canvas to: * embed an assistant in a website or application * run the selected agentic use case * send the current user message to the AI Orchestrator * render the final response * optionally emit AI Presence events through the Collector API If you need a custom experience, use AI Canvas as a reference implementation and build your own client against the AI Orchestrator API. See the [AI client reference](/tagit/reference/reference/ai-client.md) and [Web setup](/tagit/reference/reference/ai-client/web.md) for implementation details. ## Step 7: Add AI Presence when you want journey intelligence AI Presence is optional for the first journey. The AI Orchestrator can run an agentic use case without AI Presence. Add AI Presence when you want to capture and analyze engagement across the AI and non-AI parts of the journey. With AI Presence, the client can send events to the Collector API for: * deterministic user identity * conversation identity * AI messages * non-AI interactions such as page views, clicks, product views, form starts, or conversions * device, browser, and geographic context AI Presence can use those signals to infer intent, build relationship intelligence, and inform future engagement policy. See [Set up AI Presence](/tagit/guides/guides/set-up-ai-presence.md), [Presence architecture](/tagit/getting-started/presence-architecture.md), and the [Collector API reference](/tagit/reference/reference/api/collector.md) for details. ## Step 8: Inspect runs and iterate After the first journey is live, inspect how it behaves. Implementation teams should review: * final responses * execution traces * model payloads * connector usage * artifact revisions * conversation history behavior * failures and policy limits This is how teams tune an AI journey safely. The client can stay stable while the context, use case, model, connectors, policies, and published snapshots evolve. ## What success looks like You know the first journey is working when: * the AI experience is tied to a clear user or operator outcome * the context defines the shared operating environment * the agentic use case has a published snapshot * the client can call the AI Orchestrator successfully * conversation identity is stable enough for the experience you want * the response can be inspected through runs and traces * AI Presence can be added when the team is ready for journey intelligence ## Simple mental model If you are just getting started, use this: * **Context** = where the AI operates and what governance it inherits * **Agentic use case** = what the AI is doing in this moment * **AI Orchestrator** = the API service that runs the use case * **AI Canvas** = a ready-to-use client for embedding the experience * **Conversation** = the durable thread that connects history and future context * **Artifact** = durable output a workflow can build and refine * **AI Presence** = the optional intelligence layer that learns from AI and non-AI engagement That is the foundation of a tagIt AI journey. --- # Agent Instructions: 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: ``` GET https://tagit.gitbook.io/tagit/getting-started/quickstart.md?ask= ``` The question should be specific, self-contained, and written in natural language. 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.