# Done-when checklist Source: https://docs.deductive.ai/admins/checklist Confirm admin setup is genuinely complete before sharing user docs with your team. Run through this. Anything not checked is either a real gap, or a "you forgot to test it". Fix before sharing the user docs with your team. ## Sign in * [ ] You can sign in at your workspace URL (`app.deductive.ai` for self-serve / Team plans, or `.deductive.ai` for Enterprise). ## Connectors * [ ] At least one **code** source is green (typically GitHub). * [ ] At least one **observability** source is green (Datadog, Grafana, Prometheus, or New Relic). * [ ] At least one **incidents** source is green if your team uses one (PagerDuty, Incident.io, Rootly). * [ ] **Test connection** passed for every connector you set up. Not just "saved without error". * [ ] No connector shows **Indexing failed**. ## Cross-source smoke test * [ ] Asked a real question that requires multiple connectors to answer (e.g. "Summarize last week's incidents and point at the code change that likely caused each one"). The answer cited both incidents *and* code, proving cross-source reasoning works. ## Slack * [ ] Deductive Slack app is installed at the workspace level. * [ ] DM'd `@Deductive` and got a reply within a few seconds. * [ ] `/invite @Deductive` works in at least one channel and the bot replied to a `@mention` test. ## Hand-off * [ ] Shared [Use Deductive → Welcome](/users/welcome) with the team. * [ ] Dropped a one-liner in your team channel pointing at the docs. ## You're done That's the whole admin job. Day-to-day use (alert routing per channel, MCP install in each user's IDE, feedback, reinforcing decision trees) is all user-track work that doesn't require admin involvement. You'll only come back here when you add a new tool to your stack. ## Try this next If you haven't yet, run through the user-side experience yourself once. It's the best way to know what your team is about to see, and you might catch a missing connector you'd otherwise hear about as a Slack DM. The user-facing entry point. Take ten minutes to actually use it. # Connect your stack Source: https://docs.deductive.ai/admins/connect-stack One sitting. Connect every relevant tool at once so the agent can reason across all of it. Not a "pick one and come back later" exercise. This is the single highest-leverage page in admin setup. The more sources you connect in this one sitting, the more reasoning surface Deductive has from day one. By the end of this page, every category that matters to your team has at least one green connector and the agent has been verified to actually see your data. ## Before you start: gather credentials Five minutes of prep saves an hour of context switching. Open a tab for each tool you'll connect and have these handy: * **GitHub.** Org-admin access (for the GitHub App install path), or a PAT with `repo` scope. * **Observability provider.** Typically Datadog, Grafana, or Prometheus. API key + app key + site/URL. * **Incident provider.** PagerDuty, Incident.io, or Rootly. Read API key. * **Errors / traces.** Sentry, Rollbar. Auth token. * **Logs (deep).** If your team uses Splunk, Elasticsearch, OpenSearch, Loki, or Sumo Logic. Endpoint + token. * **Cloud.** AWS access. Either an IAM role ARN (preferred) or an access key pair with read-only policies. * **Tickets.** Jira. Domain + email + API token. * **Internal alert URL patterns.** If your team has in-house alerting, grab one example alert message so you can write a regex against it later. ## The recommended day-one set If you're starting cold and want a sane minimum, this combo covers most teams: 1. **Code.** GitHub 2. **Observability.** Datadog *or* Grafana *or* Prometheus 3. **Incidents.** PagerDuty *or* Incident.io 4. **Errors.** Sentry 5. **Cloud.** AWS Adding more later is fine, but doing the first five together is what makes investigations cross-correlate properly. ## Open the integrations index Open **Settings → Integrations**. Connected sources show a green dot; everything else is one click from a setup wizard. Integrations index page Work through the sections below in order. Each section is a compact "credentials → connect → test" walkthrough; deep per-field reference is one click away on each connector's dedicated page. *** ## Code The fastest, safest path is the **Deductive GitHub App** for `github.com`. 1. **Settings → Integrations → GitHub → Install GitHub App**. 2. GitHub redirects to its app installation page. Choose the org and the repos you want Deductive to read. Read access is enough. Deductive never writes to your repos. 3. Confirm. The connector flips to a green dot when GitHub's callback completes. If your repos live on GitHub Enterprise Server, or you'd rather use a token: use **GitHub PAT** instead. Generate a PAT with `repo` scope at GitHub **Settings → Developer settings → Personal access tokens**, paste it into Deductive along with your hostname (`github.com` or `github.yourcompany.com`, no `https://`, no trailing slash), click **Test connection**. Per-field detail and edge cases: [GitHub integration](/integrations/github). *** ## Observability Pick at least one. Most teams have a primary metric/log provider; connect that one first. Adding more later is fine. The safest path is a **read-only service account** so Deductive sees observability data only. 1. In Datadog, create (or reuse) a service account and assign it the **Datadog Read Only** role. 2. From the service account, create a **Datadog Application Key** with **Unscoped** scope. (Unscoped app keys automatically include the read permissions you need.) 3. Create a standard **Datadog API Key** for authentication. 4. Note your Datadog **site** (`datadoghq.com`, `datadoghq.eu`, `us3.datadoghq.com`, etc.). 5. In Deductive, paste API key + app key + site into **Settings → Integrations → Datadog**, click **Test connection**. Detail: [Datadog integration](/integrations/datadog). Service-account token is the modern path; API key is the legacy path. 1. In Grafana, navigate to **Administration → Users And Access → Service accounts**. 2. **Add service account** with role **Editor** or **Admin**. 3. **Add service account token**, copy the `glsa_…` token immediately. 4. Note your Grafana URL: for cloud, `your-org.grafana.net`; for self-hosted, the bare domain (no `https://`, no path). 5. In Deductive, paste URL + token into **Settings → Integrations → Grafana**, click **Test connection**. Detail: [Grafana integration](/integrations/grafana). For self-hosted Prometheus or any Prometheus-compatible query API. 1. Determine your Prometheus query endpoint (e.g. `https://prometheus.example.com`). 2. If your endpoint is auth-protected, gather the credential it requires (basic auth, bearer token, etc.). 3. In Deductive, paste the endpoint and credential into **Settings → Integrations → Prometheus**, click **Test connection**. Detail: [Prometheus integration](/integrations/prometheus). 1. In New Relic, generate a **User API key** under **API keys**. 2. Note your account region (`us` or `eu`). 3. Paste both into **Settings → Integrations → New Relic** in Deductive. Click **Test connection**. Detail: [New Relic integration](/integrations/newrelic). *** ## Incidents Pick the one your team uses. If you have multiple (e.g. PagerDuty for paging, Incident.io for IM), connect both. 1. In PagerDuty: **Integrations → Developer Tools → API Access Keys → Create New API Key**. 2. Pick **Read-only**. 3. Copy the key (PagerDuty only shows it once). 4. Paste into **Settings → Integrations → PagerDuty** in Deductive. **Test connection**. Detail: [PagerDuty integration](/integrations/pagerduty). 1. In Incident.io: **Settings → API keys → Create new API key**. 2. Grant the standard read scopes for incidents and post-incident actions. 3. Paste into **Settings → Integrations → Incident.io** in Deductive. **Test connection**. Detail: [Incident.io integration](/integrations/incidentio). 1. In Rootly: **Settings → API keys → New API key**. 2. Grant read scopes for incidents. 3. Paste into **Settings → Integrations → Rootly** in Deductive. **Test connection**. Detail: [Rootly integration](/integrations/rootly). *** ## Errors & traces 1. In Sentry: **Settings → Auth Tokens → Create New Token**. 2. Grant `event:read`, `org:read`, `project:read`. 3. Paste token + your Sentry org slug into **Settings → Integrations → Sentry** in Deductive. **Test connection**. Detail: [Sentry integration](/integrations/sentry). 1. In Rollbar: **Account Settings → Account Access Tokens → Create new token**. 2. Choose `read` scope. 3. Paste into **Settings → Integrations → Rollbar** in Deductive. **Test connection**. Detail: [Rollbar integration](/integrations/rollbar). *** ## Cloud The recommended path is a cross-account IAM role with read-only managed policies. 1. In AWS: **IAM → Roles → Create Role**. 2. Select **AWS account** as the trusted entity. Set the trust policy to allow Deductive's account ID (shown in **Settings → Integrations → AWS** in Deductive). 3. Attach `ReadOnlyAccess` (or a tighter custom read policy if your team prefers). 4. Optionally set an **External ID** for additional security. 5. Note the role ARN (`arn:aws:iam:::role/`) and your primary AWS region. 6. Paste role ARN + region (and external ID if used) into Deductive. **Test connection**. Static access keys are also supported as a fallback. See the deep page if your team can't grant cross-account roles. Detail: [AWS integration](/integrations/aws). *** ## Deep logs (optional) If your team's primary log provider isn't already covered above, connect it here. 1. In Splunk: **Settings → Tokens → New Token**. 2. Note your Splunk endpoint (e.g. `https://splunk.example.com:8089`). 3. Paste endpoint + token into **Settings → Integrations → Splunk** in Deductive. **Test connection**. Detail: [Splunk integration](/integrations/splunk). 1. Note your cluster endpoint and an API key or basic-auth credential with read access on the indices you want Deductive to query. 2. Paste into **Settings → Integrations → \[Elasticsearch | OpenSearch]** in Deductive. **Test connection**. Detail: [Elasticsearch](/integrations/elasticsearch) | [OpenSearch](/integrations/opensearch). 1. Note your Loki endpoint (Grafana Cloud users: `logs-prod-X.grafana.net`). 2. Generate a Grafana service-account token with logs read access (or use basic auth for self-hosted). 3. Paste into **Settings → Integrations → Loki** in Deductive. **Test connection**. Detail: [Loki integration](/integrations/loki). 1. In Sumo Logic: **Manage Data → Access Keys → Add Access Key**. 2. Paste access ID + access key + endpoint into **Settings → Integrations → Sumo Logic** in Deductive. **Test connection**. Detail: [Sumo Logic integration](/integrations/sumologic). *** ## Tickets & alert routing 1. In Atlassian: **Account Settings → Security → API Tokens → Create API Token**. 2. Note your Jira domain (`yourcompany.atlassian.net`, no `https://`). 3. Paste domain + your Atlassian account email + token into **Settings → Integrations → Jira** in Deductive. **Test connection**. Detail: [Jira integration](/integrations/jira). For Prometheus-based alerting where you want Deductive to see alert lifecycle (firing/resolving) in addition to the metrics that triggered them. 1. Note your Alertmanager endpoint. 2. Paste into **Settings → Integrations → Alertmanager** in Deductive. **Test connection**. Detail: [Alertmanager integration](/integrations/alertmanager). *** ## Test every connection Each connector has a **Test connection** button. **Click it for every connector you added.** Don't skip. A successful test does three things at once: * Validates the credential against the upstream API * Lists at least one resource (a repo, a metric scope, an incident) so you can confirm Deductive can actually read data * Flips the connector to a green dot in the integrations index Test connection succeeded with resource list visible If any test fails, Deductive shows the upstream error verbatim. Fix the underlying credential or scope issue and retest before moving on. ## Verify the cross-source agent works Once you have at least three categories green (e.g. GitHub + Datadog + PagerDuty), kick off a real investigation as a smoke test. From the home page, ask: > "Summarize last week's incidents and group them by likely cause. For each cause, point at the code change or config change that likely produced it." If the answer references both **specific incidents** (proves the incident connector is reading) and **specific commits or PRs** (proves the code connector is reading), the cross-source reasoning is working. You're done with the hardest part. ## What just happened You set up the workspace's data plane in one sitting. Every connector you added is now indexing. Small accounts catch up in minutes, larger ones over the next couple of hours. None of your team has to repeat this work; they just sign in. ## Try this next Install the Slack workspace bot. After this, your team can wire alerts into Deductive themselves. # Connect the Jira App Source: https://docs.deductive.ai/admins/jira Install the Deductive Jira app and link your Jira site to your organization. One-time, ~5 minutes. Enables Jira-powered automations. You need to be a Jira admin. The Deductive Jira app links your Jira site to your Deductive organization so your team can build **automations** that use Jira. Once the site is linked, automations can act on your Jira data without anyone re-authenticating. Linking is a one-time, admin-level task. You need to be a Jira admin to install the app and enter the linking code. This is separate from the [Jira data source integration](/integrations/jira), which connects Jira as read-only data via an API token. Install the Jira app here when you want to use Jira in automations; use the data source integration when you only want Deductive to reason over Jira data. ## Before you start * You must be a **Jira admin** on the site you want to link. * Have your Deductive site open. The setup dialog shows the exact site URL and generates the linking code you'll paste into Jira. ## Step 1: Open Jira setup in Deductive In Deductive, open **Integrations** and select **Jira**. The **Jira Setup** dialog walks you through linking in three steps. Deductive Jira Setup dialog showing the three linking steps and the Generate linking code button ## Step 2: Install the Deductive app on your Jira site In the setup dialog, click **Install the Deductive app on your Jira site**. Follow the prompts in Jira to install the app. You'll need Jira admin permissions to complete the install. ## Step 3: Generate a linking code Back in the Deductive setup dialog, click **Generate linking code** and copy the code. Keep the dialog open. You'll also need the **site URL** shown in step 3 of the dialog. ## Step 4: Enter the code in Jira 1. In Jira, go to **Apps → Deductive**. 2. Enter the **site URL** shown in the Deductive setup dialog. 3. Paste the **linking code** you copied. 4. Confirm. Once Jira accepts the code, your site is linked to your Deductive organization. ## What just happened Your Jira site is now linked to your Deductive organization. Automations that use Jira can run against this site without per-user authentication. Any team member can now [create a Jira automation](/automations/jira). # Admin setup overview Source: https://docs.deductive.ai/admins/overview One-time setup that turns an empty Deductive workspace into one your team can actually use. Plan on 30 minutes, mostly waiting on credentials. This is the section to send to whoever's setting up Deductive for your team. It's a one-time, sequential walkthrough. Sign in, connect every relevant tool at once, install Slack, and confirm the workspace is ready. Once you're done, point your team at [Use Deductive → Welcome](/users/welcome) and you're out of the loop. If you're a regular user who landed here by accident, jump to [Use Deductive → Welcome](/users/welcome). ## Who should do this One person. Typically the team lead, an SRE, or a platform engineer with credentials access. You need to be the one who can either get or already has: * Admin access to your team's Datadog / Grafana / Splunk / etc. * Owner or admin access to your GitHub org (for the GitHub App install) * Slack workspace admin (for installing the bot) * A list of any internal alerting URL patterns your team uses Setting up Deductive once shares it across the entire workspace. Members don't need their own credentials. ## What you'll do ```mermaid theme={null} flowchart LR A[Sign in
find your workspace URL] --> B[Connect your stack
code + telemetry + incidents at once] B --> C[Connect Slack
workspace + bot] C --> D[Verify
checklist + first investigation] ``` Five short pages, in order: Find your workspace URL (`app.deductive.ai` for self-serve, or your `.deductive.ai` Enterprise URL). Sign in. Single comprehensive page. Walk through every connector your team needs in one sitting. Code, observability, incidents, infra, errors. Install the Deductive Slack app at the workspace level. Once. Everyone benefits. Confirm the workspace is genuinely ready before sharing the user docs with the team. ## How long this actually takes | Phase | Active time | Realistic wall-clock | | ------------------------- | ----------- | ----------------------------------------------------------------- | | Sign in | 1 min | 1 min | | Connect your stack | 15 min | 15–60 min (depends on how many credentials you have to hunt down) | | Connect Slack | 5 min | 5 min | | Verify with the checklist | 5 min | 5 min | The honest answer: about 30 minutes if your credentials are all at hand, up to an hour if you have to ping a teammate for the right service-account key. ## Hand-off when you're done Once the [checklist](/admins/checklist) is fully green: 1. Share [Use Deductive → Welcome](/users/welcome) with your team. That's the user-facing entry point. 2. Optionally, drop a one-liner in your team channel: *"Deductive is set up. Start at \[link]."* 3. You're done. Day-to-day use doesn't require admin involvement; users configure their own per-channel alert routing, MCP installs in their IDEs, and feedback. You will need to come back **once a quarter or so** to add new connectors as your stack changes, but that's it. ## Try this next First step. Find your workspace URL and sign in. # Sign in Source: https://docs.deductive.ai/admins/sign-in Find your workspace URL and sign in. One minute. The Deductive workspace your team will use lives at one of two URL shapes. Find yours and sign in. ## Find your workspace URL | Plan | URL | Notes | | --------------------- | -------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | | **Self-serve / Team** | [app.deductive.ai](https://app.deductive.ai) | The default. If you signed up directly from deductive.ai, this is you. | | **Enterprise** | `.deductive.ai` | Dedicated subdomain. Examples: `acme.deductive.ai`, `northwind.deductive.ai`. Your account team gives you the exact hostname. | Throughout these docs we'll write `app.deductive.ai` as a stand-in. Substitute your real workspace URL anywhere you see it. ## Sign in Open your workspace URL and sign in. Depending on how your tenant is provisioned, you'll see one of: * **Google / GitHub / email + password**. For self-serve and Team plans, plus Enterprise tenants that haven't enforced SSO. * **Your company's SSO provider**. If SSO has been enforced for your tenant. Click **Continue with SSO**. Deductive sign-in page If your tenant needs SSO configured for the first time, your account team handles it as part of provisioning. Email [support@deductive.ai](mailto:support@deductive.ai) with your IdP details if you're unsure of the status. ## What just happened You're in the workspace you'll be setting up. Anything you connect from here on. Connectors, Slack, alert routing. Applies to the whole workspace. Members don't have to redo this work; they just sign in. ## Try this next The single biggest piece of admin setup. One sitting. Connect everything you reasonably can. # Connect Slack Source: https://docs.deductive.ai/admins/slack Install the Deductive Slack app at the workspace level. One-time, ~5 minutes. After this your team can wire their own channels. The Slack app gets installed once at the workspace level. After that, every member of your team can `/invite @Deductive` into channels and configure per-channel alert routing without admin involvement. Your job is the install. ## Step 1: Install the Slack app 1. In Deductive, open **Integrations → Slack**. 2. Click **Install Slack app**. You'll be redirected to Slack's standard app authorization screen. 3. Pick the Slack workspace where your team's alerts post. (If you administer multiple workspaces, double-check.) 4. Slack shows you the requested OAuth scopes. Read messages from public channels the bot is invited to, post messages, read alert metadata. Click **Allow**. 5. You'll be redirected back to Deductive. The Slack connector flips to a green dot. Slack OAuth authorization screen Slack requires a workspace admin to authorize new apps unless your workspace allows non-admin installs. If you hit a "must be approved by an admin" wall, request approval through Slack's flow and resume here once it's granted. ## Step 2: Verify the bot is in your workspace Open Slack. Search for `@Deductive` in the people sidebar. You should see the bot listed as a workspace member. Send it a quick DM (`hi` is enough) and you should get a "👋 ready" reply within a few seconds. Deductive bot profile in Slack ## Step 3: Invite the bot to one channel as a smoke test You don't need to invite the bot to every alert channel right now. That's a per-team thing your members will do themselves. But it's worth proving the channel-level integration works once. 1. Pick any channel. Your own DM, a sandbox channel, or your real `#alerts` channel. 2. `/invite @Deductive` 3. Type `@Deductive what can you do?` in the channel. The bot should reply with a short capabilities summary. If you get a reply, your team is now unblocked. ## Step 4: Hand off to the team The rest of Slack setup is per-channel and per-team. Your team members can do it themselves without admin involvement. Point them at: * [Use Deductive in Slack](/users/in-slack). Daily Slack use patterns. * [Wire alerts to auto-investigate](/users/auto-alerts). Channel filters, custom regex, triage mode. You don't need to pre-configure any of this. Different teams will want different alert routing, and the user docs walk them through it. ## What just happened The Slack workspace knows the Deductive bot, OAuth is in place, and the bot can be invited into channels. Per-channel alert routing, custom regex patterns, triage-mode toggles. All of that is user-track work, not admin-track. You're out of the loop. ## Try this next Confirm the workspace is genuinely ready before sharing user docs with your team. # Investigate Jira issues automatically Source: https://docs.deductive.ai/automations/jira Create a Jira automation that starts a Deductive investigation and posts the results back to the issue. Use a Jira automation to start an investigation whenever a matching issue is created or updated. Deductive acknowledges the issue immediately, investigates it using your connected stack, and updates the Jira comment with its findings. Any member of your Deductive team can create an automation. A Jira admin must first [connect the Deductive Jira app](/admins/jira). This app works through automations only. To give Deductive read-only access to Jira as a data source, use the separate [Jira integration](/integrations/jira). ## Step 1: Open Automations Open your Deductive workspace and select **Automations** in the sidebar. You can also add `/automations` to the end of your workspace URL. Click **New** to create an automation. ## Step 2: Configure the Jira trigger Give the automation a descriptive name, such as **Jira bugs**, then add the **Jira issue created or updated** trigger. You can filter Jira issues using: * **Project key** * **Issue type** * **Summary** For example, select project key `KAN` and issue type **Bug** to investigate bugs in that project. Leave a filter set to **Any** when you do not want to restrict it. The **updated** event lets the automation work with issues that existed before the automation was created. The first time an issue matches—whether it was created or updated—Deductive associates it with one investigation thread in that automation. Later updates never create a duplicate thread for the same issue. ## Step 3: Add investigation instructions In **Instructions**, describe what Deductive should do. A short instruction is enough: > Investigate this bug. You can add more context when you want the investigation to focus on a particular service, environment, or type of evidence. ## Step 4: Set the daily limit Set the **Daily trigger limit** to control how many times the automation can run each day. The recommended range is **15–20 runs per day**. When the limit is reached, additional matching events do not start runs until the daily limit resets. ## Step 5: Review the Jira action The automation uses **Comment on the triggering Jira issue**. Deductive posts an initial comment when it begins investigating, then updates that same comment when the run completes. Jira bugs automation with a Jira issue trigger, investigation instructions, a daily trigger limit, and the comment action Click **Save** and make sure the automation is **Active**. ## Step 6: Test the automation Create a Jira issue that matches the trigger, or update an existing matching issue. Deductive first posts a comment confirming that it is investigating the issue. Select **Follow along in Deductive** to open the active investigation. Jira issue with a Deductive AI comment saying the issue is being investigated When the investigation finishes, Deductive updates the same comment with: * Issue details * The likely root cause * Key findings and supporting evidence * A link to the full investigation in Deductive Completed Deductive AI Jira comment showing issue details, root cause, key findings, and a full investigation link ## What just happened The Jira issue now has a persistent Deductive investigation associated with it. Future matching updates remain associated with the same thread, while the Jira comment serves as the shared summary for everyone following the issue. # Alertmanager Source: https://docs.deductive.ai/integrations/alertmanager Connect Alertmanager to Deductive AI to enable reasoning over your alertmanager data. ## Grafana Cloud Setup Connect to Grafana Cloud Alertmanager for managed alert routing 1. Log in to your Grafana Cloud account 2. Navigate to your Grafana Cloud portal 3. Go to 'My Account' → 'Alertmanager' section 4. Find your Tenant ID (Instance ID) in the Alertmanager details 5. Note your region (e.g., prod-us-west-0) 6. Create an API token: 'Security' → 'Access Policies' → 'Create access policy' 7. Ensure the token has 'alerts:read' scope 8. Copy the generated API token (starts with glc\_) **Related Documentation**: [View Grafana Cloud Alerting Documentation](https://grafana.com/docs/grafana-cloud/alerting-and-irm/alerting/) ## Self-Hosted Alertmanager Setup Connect to your own Prometheus Alertmanager instance 1. Identify your Alertmanager server hostname or IP address 2. Ensure port 9093 (default) is accessible 3. If using basic authentication, prepare your credentials 4. For HTTPS, ensure SSL certificates are properly configured 5. Test connectivity: curl [http://alertmanager.example.com:9093/-/healthy](http://alertmanager.example.com:9093/-/healthy) **Related Documentation**: [View Alertmanager Documentation](https://prometheus.io/docs/alerting/latest/alertmanager/) ## Field Reference The following fields are used when configuring this integration: * **API Token** (`apiToken`) * **Alertmanager URL** (`hostname`) * **Password** (`password`) * **Cloud Region** (`region`) * **Tenant ID / Instance ID** (`tenantId`) * **Username** (`username`) # Astronomer Source: https://docs.deductive.ai/integrations/astronomer Connect Astronomer to Deductive AI to enable reasoning over your astronomer data. ## Create an API Token Generate a workspace or deployment API token from your Astronomer account 1. Log in to the Astronomer UI 2. Navigate to your Workspace 3. Go to Workspace Settings > Access Management > API Tokens 4. Click '+ API Token' and select 'Create Workspace API Token' 5. Fill in the required details (name, role, expiration) 6. Click 'Create API Token' 7. Copy the generated token immediately - it won't be shown again **Related Documentation**: [View Astronomer API Tokens Documentation](https://www.astronomer.io/docs/astro/workspace-api-tokens/) ## Find Your Deployment Hostname Locate your Astronomer deployment hostname 1. Log in to the Astronomer UI 2. Navigate to your Workspace 3. Select your Deployment 4. The hostname is displayed on the Deployment overview page 5. It typically follows the format: app.\ **Related Documentation**: [View Deployment Documentation](https://www.astronomer.io/docs/astro/deployment-api-tokens/) ## Field Reference The following fields are used when configuring this integration: * **API Token** (`api_key`) * **Deployment Hostname** (`host_name`) # AWS Source: https://docs.deductive.ai/integrations/aws Connect AWS to Deductive AI to enable reasoning over your aws data. ## IAM Role Authentication Setup Create an IAM role for cross-account or service access 1. Log in to AWS Console 2. Navigate to IAM > Roles 3. Click 'Create Role' 4. Select the trusted entity type 5. Attach the necessary policies 6. Enter a role name and create the role 7. Copy the Role ARN (format: arn:aws:iam::ACCOUNT:role/ROLE\_NAME) 8. Optionally set an External ID for additional security 9. Identify the AWS region where your resources are located (common regions: us-east-1, us-west-2, eu-west-1) **Related Documentation**: [View AWS IAM Roles Documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html) ## Static Credentials Setup Create access keys for programmatic access 1. Log in to AWS Console 2. Navigate to IAM > Users 3. Select or create a user 4. Go to the 'Security credentials' tab 5. Click 'Create access key' 6. Select the use case (Application running outside AWS) 7. Click 'Create access key' 8. Copy both the Access Key ID and Secret Access Key immediately 9. Store them securely - the Secret Access Key won't be shown again 10. Identify the AWS region where your resources are located (common regions: us-east-1, us-west-2, eu-west-1) **Related Documentation**: [View AWS Access Keys Documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) ## Field Reference The following fields are used when configuring this integration: * **Access Key ID** (`accessKeyId`) * **External ID** (`externalId`) * **Profile Name** (`profileName`) * **AWS Region** (`region`) * **Role ARN** (`roleArn`) * **Secret Access Key** (`secretAccessKey`) # AWS Bedrock Source: https://docs.deductive.ai/integrations/aws-bedrock Route Deductive AI model calls through your own AWS account using Amazon Bedrock. Route all Deductive AI model calls through your own AWS account using Amazon Bedrock. This keeps inference traffic within your AWS environment, gives you unified cost visibility in AWS Cost Explorer, and lets you enforce your organization's data residency and access control policies. When enabled, every model call Deductive makes is routed through Amazon Bedrock in your chosen AWS region. Deductive's default model providers are bypassed entirely. Your AWS credentials are stored encrypted server-side and are only used to invoke models. ## Availability The AWS Bedrock integration is available for certain Enterprise customers. Because this feature depends on your Deductive billing structure, please reach out to your account team or [support@deductive.ai](mailto:support@deductive.ai) to discuss enabling this integration. ## Prerequisites Before configuring the gateway: 1. **Enable Amazon Bedrock in your AWS account.** Bedrock is a regional service — enable it in the specific region you plan to use. Visit the [Bedrock console](https://console.aws.amazon.com/bedrock/home) to get started. 2. **Request foundation model access.** Bedrock requires explicit opt-in for each model family. In the Bedrock console, go to **Model access** and request access to the Anthropic and OpenAI model families. See [Supported models](#supported-models) below. 3. **Create an IAM user with the required permissions.** You will need an Access Key ID and Secret Access Key. See [IAM permissions](#iam-permissions) below. ## Supported models Deductive routes the following models through your Bedrock account: | Deductive model | Amazon Bedrock model ID | | ----------------- | ------------------------------------------ | | Claude 4.6 Sonnet | `anthropic.claude-sonnet-4-6` | | Claude 4.5 Haiku | `anthropic.claude-haiku-4-5-20251001-v1:0` | | GPT-OSS 120B | `openai.gpt-oss-120b-1:0` | | GPT-5.4 | `openai.gpt-5.4` | You must request model access for each provider family (Anthropic and OpenAI) separately in the Bedrock console. If a provider's models are not enabled, validation will flag an error for those models but other enabled models will continue to work. Not every Bedrock region hosts every model. Check [Bedrock model availability by region](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) to confirm your chosen region supports the models we need. ## IAM permissions Attach the following policy to the IAM user whose credentials you will enter in Deductive: ```json theme={null} { "Version": "2012-10-17", "Statement": [ { "Sid": "StsVerify", "Effect": "Allow", "Action": "sts:GetCallerIdentity", "Resource": "*" }, { "Sid": "BedrockListModels", "Effect": "Allow", "Action": "bedrock:ListFoundationModels", "Resource": "*" }, { "Sid": "BedrockInvoke", "Effect": "Allow", "Action": [ "bedrock:InvokeModel", "bedrock:InvokeModelWithResponseStream", "bedrock:Converse", "bedrock:ConverseStream" ], "Resource": [ "arn:aws:bedrock:*::foundation-model/*", "arn:aws:bedrock:*:*:inference-profile/*" ] }, { "Sid": "BedrockMantleInvoke", "Effect": "Allow", "Action": [ "bedrock-mantle:CreateInference", "bedrock-mantle:GetProject", "bedrock-mantle:ListProjects", "bedrock-mantle:GetModel", "bedrock-mantle:ListModels" ], "Resource": "arn:aws:bedrock-mantle:*:*:project/*" }, { "Sid": "BedrockMantleBearerToken", "Effect": "Allow", "Action": "bedrock-mantle:CallWithBearerToken", "Resource": "*" } ] } ``` Once you attach this policy, generate an **Access Key ID** and **Secret Access Key** for that user. Those are the two credential values you will enter in Deductive. ## Setup 1. In Deductive, open **Settings → Integrations**. 2. Select **Model Gateway** in the left sidebar. 3. Click **AWS Bedrock**. 4. Fill in the three required fields: * **AWS Region** — the region where you enabled Bedrock and requested model access (e.g. `us-east-1`, `us-west-2`). * **AWS Access Key ID** — the access key ID for your IAM user. * **AWS Secret Access Key** — the corresponding secret access key. 5. Click **Save**. Deductive saves your credentials and immediately runs validation. Results appear below the form. ## Validating your configuration After saving, or any time you want to confirm the gateway is working, click **Validate Credentials**. Deductive runs the following checks: | Check | What it confirms | | ----------------------------------- | -------------------------------------------------------------------------------- | | **STS: Verify AWS credentials** | The access key and secret are valid and can authenticate with AWS. | | **Bedrock: List foundation models** | The IAM user has `bedrock:ListFoundationModels` access in the configured region. | | **Bedrock: Invoke ``** | Each supported model can be invoked end-to-end from your account. | A failed check includes the error message returned by AWS. Use that message to diagnose permission or model-access issues. Failed checks do not remove your saved credentials. ## Removing the gateway 1. Open **Settings → Integrations → AWS Bedrock**. 2. Click **Remove credentials** and confirm. All Deductive model calls will fall back to the default providers. Your credentials are permanently deleted from Deductive's secrets store. You can re-enable the gateway at any time. ## Troubleshooting **STS check fails — "InvalidClientTokenId" or "AuthFailure"** The access key or secret is invalid or belongs to a deactivated IAM user. Double-check the values you entered, or generate a new access key in the [AWS IAM console](https://console.aws.amazon.com/iam/home). *** **Bedrock: List foundation models fails** The IAM user is missing the `bedrock:ListFoundationModels` permission, or Bedrock is not enabled in the selected region. Verify both in the AWS console. *** **Invoke check fails — "AccessDeniedException" for Claude models** Anthropic model access has not been granted in your Bedrock account. In the Bedrock console, go to **Model access** and request access to the **Anthropic** Claude model family. Approval may take a few minutes to a few hours. *** **Invoke check fails — "AccessDeniedException" for GPT models** OpenAI model access has not been granted. In the Bedrock console, go to **Model access** and request access to the **OpenAI** model family. *** **All checks pass but I need to change regions** The region in Deductive must match the region where you enabled Bedrock and requested model access. The gateway does not cross regions. To change, save updated credentials with the correct region. *** **Something else isn't working** Reach out to [support@deductive.ai](mailto:support@deductive.ai) and include the error message from the validation results — that message comes directly from AWS and is the fastest way to diagnose the issue. ## Field Reference * **AWS Region** (`region`) — the AWS region for your Bedrock endpoint (e.g. `us-west-2`) * **AWS Access Key ID** (`accessKeyId`) — the access key ID for the IAM user * **AWS Secret Access Key** (`secretAccessKey`) — the secret access key for the IAM user # Claude Source: https://docs.deductive.ai/integrations/claude Connect Claude to Deductive AI to enable reasoning over your claude data. ## Add Deductive MCP Server to Claude Code Copy the displayed command and run it in your terminal to register the Deductive MCP server with Claude Code. 1. Copy the displayed command from the setup page. 2. Paste and run the command in your terminal. The command will complete without output if successful. **Related Documentation**: [Claude Code MCP Documentation](https://docs.anthropic.com/claude/docs/mcp) ## Restart and Authenticate Restart Claude Code to activate the MCP server, then complete the authentication flow. 1. Restart Claude Code. Authentication flow should begin automatically. 2. If the authentication flow doesn't start automatically, type '/mcp' in Claude Code and select 'Authenticate' from the menu. 3. Complete the authentication flow in the browser window that opens. 4. Once this is complete, you're ready to go! You can now use Deductive AI MCP Server tools in Claude Code chat. ## Troubleshooting If you encounter authentication issues, check the following requirements. 1. If the Deductive MCP server is failing to authenticate, make sure your Node.js version is >20 (latest is 22). 2. You can check your Node.js version by running 'node --version' in your terminal. 3. If your version is outdated, update Node.js to the latest version and restart Claude Code. # ClickHouse Source: https://docs.deductive.ai/integrations/clickhouse Connect ClickHouse to Deductive AI to enable reasoning over your clickhouse data. ## Find Your ClickHouse Cloud Connection Details Retrieve connection information from ClickHouse Cloud 1. Log in to your ClickHouse Cloud account 2. Navigate to your service 3. Go to the 'Connect' tab 4. Find the hostname (e.g., \.clickhouse.cloud) 5. Note the port (typically 9440 for secure connections) 6. Create or use an existing database user 7. Note the username and password 8. Identify the database containing your logs 9. Identify the table name within that database **Related Documentation**: [View ClickHouse Cloud Connection Documentation](https://clickhouse.com/docs/en/cloud/manage/connect) ## Field Reference The following fields are used when configuring this integration: * **Database** (`database`) * **Host** (`host`) * **Password** (`password`) * **Port** (`port`) * **Table** (`table`) * **Username** (`username`) # Cursor Source: https://docs.deductive.ai/integrations/cursor Connect Cursor to Deductive AI to enable reasoning over your cursor data. ## Add Deductive MCP Server to Cursor Click the 'Add to Cursor' button to automatically open Cursor and begin the installation process. Cursor will navigate to the Tools page where you can complete the setup. 1. Click the 'Add to Cursor' button in the setup panel. This will automatically open Cursor and take you through the authentication flow. 2. Once in Cursor, you will be taken to the Tools page. From here, hit the 'Install' button. 3. After you hit the install button, select 'Connect' on the Deductive MCP server. This will initiate an installation flow with your browser. 4. The browser authentication flow will begin automatically. **Related Documentation**: [Cursor MCP Documentation](https://docs.cursor.com/mcp) ## Complete Authentication Complete the authentication flow in your browser to finish setting up the Deductive AI MCP server in Cursor. 1. Complete the authentication flow in the browser window that opens. 2. You're done! Happy chatting. You can now use Deductive AI MCP Server tools in Cursor chat. # Datadog Source: https://docs.deductive.ai/integrations/datadog Connect Datadog to Deductive AI to enable reasoning over your datadog data. ## Create Datadog Keys The simplest and safest way to connect Datadog is by using a service account with read-only access. This limits Deductive to observability data only. 1. Create (or reuse) a Datadog service account. 2. Assign it the 'Datadog Read Only' role. 3. From the service account, create a 'Datadog Application Key'. 4. Set the key to 'Unscoped' - unscoped application keys automatically include the required read permissions. 5. Create a standard 'Datadog API Key' - these are account-wide and used for authentication. **Related Documentation**: [Datadog Service Accounts Documentation](https://docs.datadoghq.com/account_management/org_settings/service_accounts/#create-service-account) ## Connect Datadog in Deductive Once connected, Deductive will begin ingesting Datadog metrics, logs, traces, and dashboards for alert investigation. 1. Navigate to 'Integrations' -> 'Datadog' in the Deductive settings. 2. Enter your 'Datadog API Key' and 'Application Key'. 3. Select the correct 'Datadog API endpoint' for your region. 4. Click 'Add' to complete the connection. **Related Documentation**: [Datadog Site Documentation](https://docs.datadoghq.com/getting_started/site/) ## Field Reference The following fields are used when configuring this integration: * **API Endpoint** (`api endpoint`) * **API Key** (`api key`) * **Application Key** (`application key`) # Elasticsearch Source: https://docs.deductive.ai/integrations/elasticsearch Connect Elasticsearch to Deductive AI to enable reasoning over your elasticsearch data. ## API Key Authentication Setup Create an API key for Elasticsearch authentication 1. Log in to your Elasticsearch cluster or Elastic Cloud 2. Navigate to Stack Management > Security > API Keys 3. Click 'Create API key' 4. Enter a name and description 5. Select the appropriate permissions (read access to indices) 6. Click 'Create' 7. Copy the generated API key immediately **Related Documentation**: [View Elasticsearch API Key Documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-create-api-key.html) ## Username/Password Authentication Setup Use basic authentication with Elasticsearch 1. Ensure your Elasticsearch cluster has security enabled 2. Create a user in Elasticsearch Security 3. Assign appropriate roles to the user (e.g., read-only access) 4. Note the username and password **Related Documentation**: [View Elasticsearch Security Documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/security-minimal-setup.html) ## Find Your Elasticsearch Host and Index Locate your Elasticsearch cluster hostname and index name 1. Find your Elasticsearch cluster endpoint 2. For Elastic Cloud: \.\.cloud.es.io 3. For self-hosted, use your cluster's hostname or IP 4. Identify the index name containing your logs 5. Common index patterns: logs-*, app-logs-*, filebeat-\* **Related Documentation**: [View Elasticsearch Index Documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/indices.html) ## Field Reference The following fields are used when configuring this integration: * **API Key** (`ApiKey`) * **Elasticsearch Host** (`Host`) * **Elasticsearch Index** (`Index`) * **Password** (`Password`) * **Username** (`Username`) # GitHub Source: https://docs.deductive.ai/integrations/github Connect GitHub to Deductive AI to enable reasoning over your github data. # GitHub Deductive supports GitHub in two ways: 1. `GitHub` for GitHub App-based access on `github.com` 2. `GitHub PAT` for Personal Access Token-based access on `github.com` or GitHub Enterprise Server ## If you use GitHub.com If your code is hosted on `github.com`, the recommended setup is to install the Deductive GitHub App on your organization or repository. You do not need to create and paste a Personal Access Token for this setup. ### How it works * Install the Deductive GitHub App * Approve access to the organization or repositories you want Deductive to read * Deductive uses the app installation to access your code, pull requests, and commit history ### When to use this Use this option if your repositories live on standard GitHub Cloud at `github.com`. ## If you want to connect with a Personal Access Token Use `GitHub PAT` when: * Your repositories are hosted on a self-managed GitHub Enterprise Server instance * You want to use a GitHub Personal Access Token instead of a GitHub App * You want to connect private repositories using token-based credentials This option supports both: * `github.com` * Self-hosted GitHub Enterprise Server hostnames ### What you need Provide: * Your GitHub hostname, such as `github.com` or `github.yourcompany.com` * A Personal Access Token with `repo` scope Do not include `https://` or a trailing slash in the hostname field. ### How to set it up 1. Open `GitHub PAT` from integrations page 2. Enter your GitHub hostname 3. Create a Personal Access Token in GitHub 4. Grant the token `repo` scope so Deductive can access private repositories 5. Paste the token into the `Personal Access Token` field 6. Save the integration ### Test connection behavior The PAT integration includes a test connection flow. When you test the connection, Deductive: * Validates the stored hostname and token * Connects to the configured GitHub instance * Lists repositories accessible to that token * Shows whether the connection succeeded and which repositories were found If the token is valid but cannot access any repositories, the integration can still authenticate successfully, but no accessible repositories will be listed. ## Which one should I choose? * Use `GitHub` if you want the standard GitHub App setup on `github.com` * Use `GitHub PAT` if you want PAT-based access * Use `GitHub PAT` for self-hosted GitHub Enterprise Server ## Summary There are only two real cases: 1. `github.com` with GitHub App: use `GitHub` 2. `github.com` or self-hosted GitHub with a PAT: use `GitHub PAT` ## How to create a Personal Access Token 1. Log in to your GitHub instance 2. Go to Settings > Developer settings > Personal access tokens 3. Click `Generate new token` 4. Grant the token `repo` scope 5. Copy the generated token 6. Paste it into Deductive **Related Documentation**: [GitHub: Managing your personal access tokens](https://docs.github.com/en/enterprise-server/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens) ## Field Reference The following fields are used when configuring this integration: * **GitHub Hostname** (`hostname`) * **Personal Access Token** (`pat`) # Grafana Source: https://docs.deductive.ai/integrations/grafana Connect Grafana to Deductive AI to enable reasoning over your grafana data. ## Find your Grafana URL Locate your Grafana server URL to connect Deductive 1. Open your Grafana instance in a web browser and log in 2. Look at the address bar in your browser - this shows your Grafana URL 3. For self-hosted Grafana: Use your domain (e.g., grafana.example.com) 4. For Grafana Cloud: Use your organization URL (e.g., your-org.grafana.net) 5. Copy only the base domain from the address bar (without https\:// and without any paths like /d/ or /dashboard/) 6. Enter this base domain in the 'Grafana URL' field in Deductive **Related Documentation**: [View Grafana Setup Documentation](https://grafana.com/docs/grafana/latest/setup-grafana/) ## Service Account Token Setup (Recommended) Create a service account token for API access 1. As an admin, navigate to \{\{GRAFANA\_URL:/org/users/service-accounts}} ('Administration' → 'Users And Access' → 'Service accounts') 2. Click 'Add service account' 3. Enter a name (e.g., 'Deductive Integration') 4. Assign appropriate role (Editor or Admin recommended for full access) 5. Click 'Create' 6. In the service account, click 'Add service account token' 7. Set token expiration (or no expiration for persistent access) 8. Copy the generated token immediately (starts with glsa\_) **Related Documentation**: [View Service Account Documentation](https://grafana.com/docs/grafana/latest/administration/service-accounts/) ## API Key Setup (Legacy) Create an API key for older Grafana versions 1. As an admin, navigate to \{\{GRAFANA\_URL:/org/apikeys}} ('Configuration' → 'API keys') 2. Click 'Add API key' 3. Enter a name for the key 4. Select role (Admin recommended for full access) 5. Set time to live or leave blank for no expiration 6. Click 'Add' and copy the generated key 7. Note: API keys are deprecated in Grafana 9+, use service accounts instead **Related Documentation**: [View API Keys Documentation](https://grafana.com/docs/grafana/latest/administration/api-keys/) ## Basic Authentication Setup Use username and password for authentication 1. Ensure basic authentication is enabled in your Grafana configuration 2. Use a user account with appropriate permissions 3. For production, consider creating a dedicated service user 4. Ensure the user has access to required dashboards and alerts **Related Documentation**: [View Authentication Documentation](https://grafana.com/docs/grafana/latest/setup-grafana/configure-security/configure-authentication/) ## Field Reference The following fields are used when configuring this integration: * **API Key** (`apiKey`) * **Grafana URL** (`hostname`) * **Password** (`password`) * **Service Account Token** (`serviceAccountToken`) * **Username** (`username`) # Incident.io Source: https://docs.deductive.ai/integrations/incidentio Connect Incident.io to Deductive AI to enable reasoning over your incident.io data. ## Create an API Key Generate an API key for incident.io integration 1. Log in to your incident.io account 2. Navigate to Settings > API Keys 3. Click 'Create API Key' 4. Enter a name for the API key 5. Select the appropriate permissions 6. Click 'Create' 7. Copy the generated API key immediately **Related Documentation**: [View incident.io API Keys Documentation](https://docs.incident.io/api-keys) ## Field Reference The following fields are used when configuring this integration: * **API Key** (`apiKey`) # Jira Source: https://docs.deductive.ai/integrations/jira Connect Jira to Deductive AI to enable reasoning over your jira data. ## Configure Jira Domain Enter your Atlassian Jira domain 1. Enter your Jira domain (e.g., yourcompany.atlassian.net) 2. Do not include 'https\://' - just the domain name 3. For Jira Cloud, this is typically yourcompany.atlassian.net ## Create an API Token Generate an API token for Jira access 1. Log in to your Atlassian account 2. Navigate to Account Settings > Security > API Tokens 3. Click 'Create API Token' 4. Enter a label for the token (e.g., 'Deductive AI') 5. Click 'Create' 6. Copy the generated token immediately (you won't see it again) 7. Enter your Atlassian account email in the 'Email' field 8. Paste the API token in the 'API Token' field **Related Documentation**: [Open Atlassian API Tokens Page](https://id.atlassian.com/manage-profile/security/api-tokens) ## Field Reference The following fields are used when configuring this integration: * **API Token** (`apiToken`) * **Jira Domain** (`hostname`) * **Email** (`username`) # LangSmith Source: https://docs.deductive.ai/integrations/langsmith Connect LangSmith to Deductive AI to enable reasoning over your langsmith data. ## Create an API Key Generate a LangSmith API key for authentication 1. Log in to your LangSmith account 2. Navigate to Settings > API Keys 3. Click 'Create API Key' 4. Enter a name for the API key 5. Select the appropriate permissions 6. Click 'Create' 7. Copy the generated API key (starts with lsv2\_sk\_) 8. The default API endpoint is [https://api.smith.langchain.com](https://api.smith.langchain.com) **Related Documentation**: [View LangSmith Documentation](https://docs.smith.langchain.com/) ## Field Reference The following fields are used when configuring this integration: * **API Endpoint** (`api_endpoint`) * **API Key** (`api_key`) # Loki Source: https://docs.deductive.ai/integrations/loki Connect Loki to Deductive AI to enable reasoning over your loki data. ## Grafana Cloud Setup Connect to Grafana Cloud Loki for managed log aggregation 1. Log in to your Grafana Cloud account 2. Navigate to your Grafana Cloud portal 3. Go to 'My Account' → 'Loki' section 4. Find your Tenant ID (Instance ID) in the Loki details 5. Note your region (e.g., prod-us-central-0) 6. Create an API token: 'Security' → 'Access Policies' → 'Create access policy' 7. Ensure the token has 'logs:read' scope 8. Copy the generated API token (starts with glc\_) **Related Documentation**: [View Grafana Cloud Logs Documentation](https://grafana.com/docs/grafana-cloud/send-data/logs/) ## Self-Hosted Loki Setup Connect to your own Loki instance 1. Identify your Loki server hostname or IP address 2. Ensure port 3100 (default) is accessible 3. If using basic authentication, prepare your credentials 4. For HTTPS, ensure SSL certificates are properly configured 5. Test connectivity: curl [http://loki.example.com:3100/ready](http://loki.example.com:3100/ready) **Related Documentation**: [View Loki Documentation](https://grafana.com/docs/loki/latest/) ## Field Reference The following fields are used when configuring this integration: * **API Token** (`apiToken`) * **Loki URL** (`hostname`) * **Password** (`password`) * **Cloud Region** (`region`) * **Tenant ID / Instance ID** (`tenantId`) * **Username** (`username`) # New Relic Source: https://docs.deductive.ai/integrations/newrelic Connect New Relic to Deductive AI to enable reasoning over your new relic data. ## Get New Relic User API Key Create a User API key in New Relic to allow Deductive to access your observability data. User API keys provide read access to metrics, logs, traces, and events. 1. Log in to your New Relic account. 2. Navigate to 'Account settings' > 'API keys' (or go to one.newrelic.com/api-keys). 3. Click 'Create a key' and select 'User key' as the key type. 4. Give the key a descriptive name (e.g., 'Deductive Integration'). 5. Copy the API key immediately - you won't be able to see it again after closing the dialog. 6. The key will be used to authenticate API requests from Deductive to New Relic. **Related Documentation**: [New Relic User API Key Documentation](https://docs.newrelic.com/docs/apis/intro-apis/new-relic-api-keys/#user-api-key) ## Connect New Relic in Deductive Once connected, Deductive will use your API key to access New Relic data for alert investigation and system analysis. 1. Navigate to 'Integrations' > 'New Relic' in the Deductive settings. 2. Enter your 'New Relic User API Key' in the API Key field. 3. Click 'Save' to complete the connection. 4. Deductive will begin accessing your New Relic data for observability analysis. **Related Documentation**: [New Relic API Keys Documentation](https://docs.newrelic.com/docs/apis/intro-apis/new-relic-api-keys/) ## Field Reference The following fields are used when configuring this integration: * **API Key** (`apiKey`) # OpenSearch Source: https://docs.deductive.ai/integrations/opensearch Connect OpenSearch to Deductive AI to enable reasoning over your opensearch data. ## API Key Authentication Setup Create an API key for OpenSearch authentication 1. Log in to your OpenSearch cluster 2. Navigate to Security > API Keys 3. Click 'Create API Key' 4. Select permissions: indices:data/read/\* 5. Copy the generated API key immediately 6. Enter your OpenSearch endpoint (e.g., [https://search-logs-prod.us-west-2.es.amazonaws.com](https://search-logs-prod.us-west-2.es.amazonaws.com)) 7. Enter your index pattern (e.g., logs-*, app-logs-*) **Related Documentation**: [View OpenSearch API Access Control Documentation](https://opensearch.org/docs/latest/security/access-control/api-access-control/) ## IAM Role Authentication Setup Configure IAM role for AWS OpenSearch Service 1. Log in to AWS Console 2. Navigate to IAM > Roles 3. Create or select an IAM role with OpenSearch permissions (es:ESHttpGet, es:ESHttpPost) 4. Configure the role's trust relationship to trust Deductive's AWS account 5. Note the Role ARN (format: arn:aws:iam::\[0-9]:role/YourRoleName) 6. Enter your OpenSearch endpoint (e.g., [https://search-prod-logs.us-east-1.es.amazonaws.com](https://search-prod-logs.us-east-1.es.amazonaws.com)) 7. Enter your index pattern (e.g., logs-\*) **Related Documentation**: [View AWS OpenSearch IAM Documentation](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/fgac.html) ## Username/Password Authentication Setup Use basic authentication with OpenSearch 1. Ensure your OpenSearch cluster has internal user database enabled 2. Create a user in OpenSearch Security 3. Assign appropriate roles to the user 4. Note the username and password 5. Enter your OpenSearch endpoint (e.g., [https://opensearch.internal:9200](https://opensearch.internal:9200)) 6. Enter your index pattern (e.g., logs-*, app-logs-*) **Related Documentation**: [View OpenSearch Users & Roles Documentation](https://opensearch.org/docs/latest/security/access-control/users-roles/) ## Field Reference The following fields are used when configuring this integration: * **API Key** (`Api Key`) * **OpenSearch Endpoint** (`Host`) * **Index or Index Pattern** (`Index`) * **Password** (`Password`) * **Role ARN** (`Role arn`) * **Username** (`Username`) # Integrations Overview Source: https://docs.deductive.ai/integrations/overview How Deductive integrations work and how to connect your tools. # Overview Deductive connects to your observability, development, and incident tools so the AI SRE Agent can reason over your full production context. ## How It Works Integrations follow a simple flow: 1. **Connect.** You add an integration in Deductive (API keys, OAuth, or other credentials). 2. **Ingest.** Deductive ingests metrics, logs, traces, incidents, and code context from that source. 3. **Reason.** The AI SRE Agent uses this context to answer questions, explain root cause, and guide or apply fixes. No integration can see or modify another; each is configured and used independently. You control which sources are connected and what scope they have (e.g., read-only, specific projects). ## Integration Categories Integrations are grouped by the kind of context they provide: | Category | Purpose | Examples | | -------------------- | ----------------------------------------- | -------------------------------------------- | | **AI Coding Agents** | Bring Deductive into your coding workflow | Cursor, Claude Code | | **AI Model Gateway** | Route model calls through your own cloud | AWS Bedrock | | **Observability** | Logs, metrics, traces, and events | Datadog, Prometheus, Grafana, Loki, Sentry | | **Incidents** | Alert lifecycles, ownership, escalation | PagerDuty, Rootly, Incident.io, Alertmanager | | **Development** | Code, infra, and workflow context | GitHub, AWS, Jira, Astronomer | | **Collaboration** | Conversations and coordination | Slack (when available) | ## Browse by Category Use the sidebar to browse integrations by category. Each integration has a setup guide with step-by-step instructions for credentials and configuration. * [AI Coding Agents](/integrations/cursor): Cursor, Claude * [AI Model Gateway](/integrations/aws-bedrock): AWS Bedrock * [Observability](/integrations/datadog): Datadog, Prometheus, New Relic, Grafana, Sentry, and more * [Incidents](/integrations/pagerduty): PagerDuty, Rootly, Incident.io, Alertmanager * [Development](/integrations/github): GitHub, AWS, Jira, Astronomer ## Getting Help * **First time?** Start with [Onboarding → Welcome](/users/welcome). * **Security and privacy:** See [Security](/resources/security) and [Privacy](/resources/privacy). # PagerDuty Source: https://docs.deductive.ai/integrations/pagerduty Connect PagerDuty to Deductive AI to enable reasoning over your pagerduty data. ## Create an API Key Generate an API key for PagerDuty integration 1. Log in to your PagerDuty account 2. Navigate to Integrations > Developer Tools > API Access Keys 3. Click 'Create New API Key' 4. Enter a description for the key 5. Select the appropriate permissions (read/write) 6. Click 'Create Key' 7. Copy the generated API key immediately **Related Documentation**: [View PagerDuty API Access Keys Documentation](https://support.pagerduty.com/docs/api-access-keys) ## Field Reference The following fields are used when configuring this integration: * **API Key** (`apiKey`) # Prometheus Source: https://docs.deductive.ai/integrations/prometheus Connect Prometheus to Deductive AI to enable reasoning over your prometheus data. ## AWS IAM Role Setup Configure IAM role auth for AWS Managed Prometheus (AMP). 1. Log in to AWS Console 2. Navigate to Amazon Managed Service for Prometheus 3. Create or select a workspace 4. Note the workspace ID 5. Create an IAM role with appropriate permissions 6. Note the role ARN 7. If the role is cross-account, note the External ID (if configured) 8. Select the AWS region where your workspace is located **Related Documentation**: [View AWS Managed Prometheus Documentation](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-onboard.html) ## Username and Password Authentication Setup Configure basic auth for Prometheus. 1. Ensure your Prometheus instance has basic authentication enabled 2. Obtain your Prometheus username 3. Obtain your Prometheus password 4. Find your Prometheus server URL (hostname) 5. The hostname should be accessible from your network **Related Documentation**: [View Prometheus Basic Auth Documentation](https://prometheus.io/docs/guides/basic-auth/) ## Field Reference The following fields are used when configuring this integration: * **External ID** (`externalId`) * **Prometheus Hostname** (`hostname`) * **Password** (`password`) * **AWS Region** (`region`) * **Role ARN** (`roleArn`) * **Username** (`username`) * **Workspace ID** (`workspaceId`) # Rollbar Source: https://docs.deductive.ai/integrations/rollbar Connect Rollbar to Deductive AI to enable reasoning over your rollbar data. ## Overview Deductive connects to Rollbar to help you analyze errors, track deployments, and investigate issues across all your Rollbar projects. The setup process automatically creates read-only access tokens for each of your projects, so you only need to configure the connection once—even if you have many projects. ## Step 1: Create an Account Access Token (Temporary) Generate a temporary Rollbar **account** access token with write scope. Deductive uses this token once to create read-only project tokens for all your projects, then you can delete it. 1. Log in to your Rollbar account 2. Go to **Account Settings** → **Account Access Tokens** 3. Click **Create new access token** 4. Name the token (e.g., `Deductive Setup - Temporary`) 5. Select **write** scope (required to create project tokens) and **read** scope (required to view project tokens) 6. Click **Create** and copy the access token immediately Rollbar only shows the token value once at creation time. Make sure to copy it before closing the dialog. **Related Documentation**: [Rollbar Access Tokens Documentation](https://docs.rollbar.com/docs/access-tokens) ## Step 2: Generate Project Tokens In the Deductive integration settings: 1. Paste your account access token 2. Click **Generate Project Tokens** 3. Review the list of projects that were set up (you'll see a success/failure indicator for each) 4. Click **Save** to store the read-only project tokens Deductive will automatically: * Discover all projects in your Rollbar account * Create a dedicated read-only token for each project (named `deductive-{project}`) * Store only the read-only tokens—the account token is never saved ## Step 3: Delete the Account Token (Recommended) For security, you can delete the temporary account access token after setup: 1. Return to **Account Settings** → **Account Access Tokens** in Rollbar 2. Find and delete the temporary token you created 3. Your Deductive integration will continue working with the read-only project tokens Deductive only stores read-only project tokens. These tokens can view error data but cannot modify your Rollbar configuration or create new tokens. ## Capabilities Once connected, Deductive can: * **View errors and items**: Access error details, stack traces, and metadata * **Analyze occurrences**: Review individual error occurrences and their context * **Track deployments**: Correlate errors with deployment events * **Query with RQL**: Run Rollbar Query Language queries for advanced analysis * **Access reports**: View top active items and occurrence statistics * **Check environments**: See which environments are configured ## Field Reference The following fields are used when configuring this integration: | Field | Description | | ------------------------ | ------------------------------------------------------------------------- | | **Account Access Token** | Temporary token with write scope used only during setup (not stored) | | **Project Tokens** | Auto-generated read-only tokens for each project (stored as JSON mapping) | ## Troubleshooting ### "Invalid access token" during setup Ensure your account access token has **write** scope. Read-only account tokens cannot create project tokens. ### A project failed to set up Some projects may have restricted permissions. Check that your Rollbar account has access to all projects you expect to see. Projects that fail will show an error message—you can still use Deductive with the projects that succeeded. ### Need to reconnect or update tokens Simply repeat the setup process with a new account access token. Deductive will automatically replace any existing project tokens with fresh ones. # Rootly Source: https://docs.deductive.ai/integrations/rootly Connect Rootly to Deductive AI to enable reasoning over your rootly data. ## Create an API Key Generate a Rootly API key for authentication 1. Log in to your Rootly account 2. Click on your organization dropdown in the top navigation 3. Navigate to Organization Settings > API Keys 4. Click 'Generate New API Key' 5. Choose the appropriate scope (Global, Team, or Personal) 6. Copy the generated API key 7. The default API URL is [https://api.rootly.com](https://api.rootly.com) **Related Documentation**: [View Rootly API Documentation](https://docs.rootly.com/api-reference/overview) ## Field Reference The following fields are used when configuring this integration: * **API Key** (`apiKey`) * **API URL** (`apiUrl`) # Sentry Source: https://docs.deductive.ai/integrations/sentry Connect Sentry to Deductive AI to enable reasoning over your sentry data. ## Configure Sentry Host Enter your Sentry host (default: sentry.io) 1. For Sentry Cloud, use the default: sentry.io 2. For self-hosted Sentry, enter your Sentry instance URL 3. Do not include 'https\://' - just the hostname ## Enter Organization Slug Provide your Sentry organization slug 1. Find your organization slug in Sentry 2. Navigate to Settings > Organizations 3. The slug is shown in the organization URL 4. Enter it in the 'Organization Slug' field ## Create an Auth Token Generate an authentication token for Sentry API access 1. Log in to your Sentry account 2. Navigate to Settings > Account > API > Auth Tokens 3. Click 'Create New Token' 4. Enter a name for the token (e.g., 'Deductive AI') 5. Select the required scopes: 6. * project:read (required) 7. * event:read (required) 8. Click 'Create Token' 9. Copy the generated token immediately (you won't see it again) 10. Paste the token in the 'Auth Token' field **Related Documentation**: [Open Sentry Auth Tokens Page](https://sentry.io/settings/account/api/auth-tokens/) ## Field Reference The following fields are used when configuring this integration: * **Auth Token** (`authToken`) * **Sentry Host** (`hostname`) * **Organization Slug** (`organization`) # SignalFX Source: https://docs.deductive.ai/integrations/signalfx Connect SignalFX to Deductive AI to enable reasoning over your signalfx data. ## Generate an API Token Create an API token in SignalFX for authentication 1. Log in to your Splunk Observability Cloud (SignalFX) account 2. Navigate to Settings > Access Tokens 3. Click 'New Token' 4. Select appropriate permissions (read access for metrics/dimensions) 5. Copy the generated token **Related Documentation**: [View SignalFX Token Documentation](https://docs.splunk.com/Observability/admin/authentication/authentication-tokens/org-tokens.html) ## Find Your API Endpoint Determine the correct API endpoint for your realm 1. Identify your SignalFX realm (e.g., us0, us1, eu0) 2. Use the format: api.\.signalfx.com 3. Common endpoints: api.us1.signalfx.com, api.eu0.signalfx.com **Related Documentation**: [View SignalFX API Reference](https://dev.splunk.com/observability/docs/apibasics/api_list) ## Field Reference The following fields are used when configuring this integration: * **X-SF-TOKEN authentication header value** (`API Token`) * **SignalFX API endpoint for your realm** (`SignalFX API URL`) # Splunk Source: https://docs.deductive.ai/integrations/splunk Connect Splunk to Deductive AI to enable reasoning over your splunk data. ## Create an Authentication Token Generate an authentication token for Splunk API access 1. Log in to your Splunk instance 2. Navigate to Settings > Tokens 3. Click 'New Token' 4. Enter a name for the token 5. Select the appropriate permissions 6. Set expiration if needed 7. Click 'Create' 8. Copy the generated token immediately **Related Documentation**: [View Splunk Authentication Tokens Documentation](https://docs.splunk.com/Documentation/Splunk/latest/Security/Setupauthenticationtokens) ## Find Your Splunk API URL Determine the API endpoint URL for your Splunk instance 1. Identify your Splunk instance URL 2. The API URL typically follows: https\://\:\/services 3. Common ports: 8089 (management), 8000 (web) 4. For Splunk Cloud, use the provided API endpoint 5. Enter the full API endpoint URL **Related Documentation**: [View Splunk REST API Documentation](https://docs.splunk.com/Documentation/Splunk/latest/RESTREF/RESTintro) ## Field Reference The following fields are used when configuring this integration: * **Authentication Token** (`API Key`) * **API URL** (`API URL`) # Sumo Logic Source: https://docs.deductive.ai/integrations/sumologic Connect Sumo Logic to Deductive AI to enable reasoning over your sumo logic data. ## Create Access Keys Generate Access ID and Access Key for Sumo Logic API 1. Log in to your Sumo Logic account 2. Navigate to Administration > Security > Access Keys 3. Click 'Add Access Key' 4. Enter a name for the access key 5. Select the appropriate permissions 6. Click 'Create' 7. Copy both the Access ID and Access Key immediately 8. Store them securely - the Access Key won't be shown again **Related Documentation**: [View Sumo Logic Access Keys Documentation](https://help.sumologic.com/docs/manage/security/access-keys/) ## Find Your API Endpoint Determine the correct API endpoint for your Sumo Logic deployment 1. Check your Sumo Logic deployment region 2. US1: [https://api.sumologic.com/api](https://api.sumologic.com/api) 3. US2: [https://api.us2.sumologic.com/api](https://api.us2.sumologic.com/api) 4. EU: [https://api.eu.sumologic.com/api](https://api.eu.sumologic.com/api) 5. JP: [https://api.jp.sumologic.com/api](https://api.jp.sumologic.com/api) 6. Enter the appropriate endpoint URL for your region **Related Documentation**: [View Sumo Logic Endpoints Documentation](https://help.sumologic.com/docs/api/getting-started/#sumo-logic-endpoints) ## Field Reference The following fields are used when configuring this integration: * **Access ID** (`accessId`) * **Access Key** (`accessKey`) * **API Endpoint** (`apiEndpoint`) # Tempo Source: https://docs.deductive.ai/integrations/tempo Connect Tempo to Deductive AI to enable reasoning over your tempo data. ## Grafana Cloud Setup Connect to Grafana Cloud Tempo for managed distributed tracing 1. Log in to your Grafana Cloud account 2. Navigate to your Grafana Cloud portal 3. Go to 'My Account' → 'Tempo' section 4. Find your Tenant ID (Instance ID) in the Tempo details 5. Note your region (e.g., prod-us-central-0) 6. Create an API token: 'Security' → 'Access Policies' → 'Create access policy' 7. Ensure the token has 'traces:read' scope 8. Copy the generated API token (starts with glc\_) **Related Documentation**: [View Grafana Cloud Traces Documentation](https://grafana.com/docs/grafana-cloud/send-data/traces/) ## Self-Hosted Tempo Setup Connect to your own Tempo instance 1. Identify your Tempo server hostname or IP address 2. Ensure the query frontend port (default 3200) is accessible 3. If using basic authentication, prepare your credentials 4. For HTTPS, ensure SSL certificates are properly configured 5. Test connectivity: curl [http://tempo.example.com:3200/ready](http://tempo.example.com:3200/ready) **Related Documentation**: [View Tempo Documentation](https://grafana.com/docs/tempo/latest/) ## Field Reference The following fields are used when configuring this integration: * **API Token** (`apiToken`) * **Tempo URL** (`hostname`) * **Password** (`password`) * **Cloud Region** (`region`) * **Tenant ID / Instance ID** (`tenantId`) * **Username** (`username`) # Asking better questions Source: https://docs.deductive.ai/users/ask The prompt patterns that consistently produce sharp investigations, plus a role-based prompt library you can steal from. Deductive is good at clarifying when it needs to, so you don't need to write the perfect prompt, but a few patterns reliably produce tighter, faster, more useful investigations. This page is the cheat sheet. ## The four patterns that always work ### 1. Anchor in time Vague: *"Why is the API slow?"* Anchored: *"Why did the API's p99 latency jump at 14:30 today and stay elevated?"* Time anchors give the agent a window to focus its evidence-gathering. "Yesterday between 11pm and 2am" beats "last night". "From the last successful deploy onward" beats "recently". ### 2. Anchor in change If you suspect something changed (a deploy, a config flip, a feature flag), say so. The agent will pull the change set and correlate against it as a first-class hypothesis. > "Did anything in PR #1234 cause the payment errors after we merged it?" > "We flipped the `cache_v2` flag to true at 12:00 PT. Did anything regress in the next hour?" > "Has any deploy in the last week touched code paths that the `auth-service` calls?" ### 3. Compare Comparison prompts force the agent to fetch baselines, which is almost always the correct framing for "is this normal?". > "Compare today's checkout error rate to the same time last week." > "Which services are noisier in their logs this week than last week?" > "How does the latency profile of `payments` look against the rolling 30-day baseline?" ### 4. Ask for the timeline, not the answer If you don't yet know what you're looking at, ask the agent to assemble the timeline first. The right answer often falls out of the timeline. > "Walk me through what happened to the payment service between 14:00 and 15:00, in order." > "Build me a timeline of every event. Deploys, alerts, infra changes. Touching the auth path yesterday." ## A prompt library by role Steal these. They work because they hit one of the four patterns above. > "What was the worst-looking thing in production last night between 11pm and 2am? Build the timeline first, then propose root cause." > "Has anything weird happened with the `` in the past 24 hours? Anchor on the last successful deploy." > "Summarize this week's incidents, group them by likely cause, and flag any that look like they share a root cause." > "Walk me through what changed between when `` fired and when it cleared." > "Three pages in two days for the same service. Are they actually the same incident or three different ones?" > "I merged PR #1234 yesterday. Did it break anything? Compare the metrics before and after the deploy." > "Has anyone else's recent PR touched the same files as #1234? If so, what did they change?" > "What does a normal deploy of the `` service look like in metrics? Compare against today's deploy." > "If I revert PR #1234, what else might I be reverting that depends on it?" > "Before I open this PR for review. Does it touch any code path that's recently been flagged in an incident?" > "Which services have the noisiest error logs in the last week, and is the noise growing?" > "Where are we paying the most for compute that's idle most of the time?" > "Show me services whose p99 has drifted up over the last 30 days without a corresponding traffic increase." > "Which alerts in `#prod-alerts` have fired more than three times this month? Cluster them by likely root cause." > "Compare the deploy frequency and revert rate of every service. Which teams are healthiest? Which need attention?" > "A customer says checkout has been slow for them since Tuesday. What does the data show for that customer specifically?" > "Which incidents in the last 30 days had visible customer impact, and how long did each one last?" > "What's the status of the open bugs filed against the payments team this quarter?" > "Build me a list of every recurring issue customers have raised about ``, grouped by likely cause." ## When the agent asks you a follow-up Sometimes Deductive will respond with a clarifying question instead of an answer. That's a feature, not a bug. It means the prompt was ambiguous in a way that would have led to a wasted investigation. Answer the question and the investigation continues. If you find yourself repeatedly answering the same clarifying question across different investigations, that's a signal that the underlying decision tree is worth reinforcing so the agent doesn't have to ask next time. See [Teach Deductive](/users/teach). # Wire alerts to auto-investigate Source: https://docs.deductive.ai/users/auto-alerts Make Deductive react when an alert fires in your channels. The investigation is in the thread before the on-call finishes reading the page. This is the highest-leverage user-facing setting in the product. You configure a few rules per channel; an alert fires; Deductive runs a full investigation against your stack; the answer is sitting in the thread by the time the on-call opens it. Five minutes of setup; permanent reduction in time-to-context. By the end of this page you'll have alert triggers configured for at least one channel, you'll know how to test them without paging anyone, and you'll know the difference between full-investigation mode and triage mode. This page assumes the Slack workspace is already connected and the Deductive bot has been installed. If it hasn't, point your admin at [Admin setup → Connect Slack](/admins/slack). That's a one-time, workspace-wide thing. ## What "wired up" means ```mermaid theme={null} flowchart LR A[Alert fires
Grafana / Datadog / Splunk / custom] --> B[Slack post
your existing alert channel] B --> C[Deductive bot
matches a trigger] C --> D[Investigation runs
decision tree, evidence] D --> E[Reply in thread
summary + canvas link] E --> F[On-call reads
continues investigation] ``` You control three knobs: **which alerts trigger**, **which channels they're allowed to fire in**, and **how loudly Deductive responds**. ## Step 1: Invite the bot to the channel `/invite @Deductive` in every channel where alerts post. The bot has to be a member to read messages. Slack doesn't expose channel posts to bots that aren't invited, even with workspace-level permissions. This is the single most common reason "alerts don't trigger anything". ## Step 2: Pick alert sources Open **Integrations → Slack → Settings**. The popup lists every supported alert source with a toggle. Turn on the ones your team uses. Slack integration settings popup with alert source toggles Built-in sources: * Grafana (`*.grafana.net` and `grafana.com` URLs) * Datadog (alert URLs and API-formatted alerts) * Splunk * Sentry * New Relic * PagerDuty (incident URLs) * Alertmanager / Prometheus * Rollbar * Sumo Logic Each source pattern is a regex that matches the URL or message shape your alerting system posts into Slack. If your alerts come from one of these, you don't need to configure anything else. ## Step 3: Add custom patterns for in-house alerts If your team has an internal alerting system or a non-default URL shape, add a custom pattern. 1. Click **Custom patterns → Add pattern**. 2. Paste a regex that matches your alert message. Usually a unique URL fragment or a header line. 3. Save. The pattern is live immediately for newly posted alerts. Quickest way to find a working regex: copy the most recent alert from your channel, find the most stable line in it (often a URL or a header like `[ALERT][prod]`), and write a regex that matches just that. Specific beats permissive. ## Step 4: Scope which channels can trigger By default, Deductive will react to matching alerts in any channel it's a member of. For most teams that's too aggressive. Use **Channel filters** to scope. Add a filter row for each channel where you want Deductive active: | Field | What it does | | ---------------------- | ------------------------------------------------------------------------------------------------------------------ | | **Channel** | The Slack channel ID (e.g. `C0123ABCDEF`). | | **Pattern (optional)** | Restrict to alerts matching this additional regex. Useful when one channel sees mixed alert types. | | **Respond in thread** | If on, Deductive replies visibly in the alert thread. If off, it runs silently and only the canvas link is posted. | ## Step 5: Pick a response mode Two modes: ### Full investigation (default) Deductive runs the investigation, replies in the thread with the answer (root-cause hypothesis, evidence summary, recommended actions), and posts a canvas link. Best when: * The channel is real-incident-only and the on-call wants context immediately * You want every alert to leave a paper trail an exec can read ### Triage mode Deductive runs the investigation but the visible reply is a one-liner ("triaged: looks like a transient redis blip, likely safe to ignore. Full investigation: \[link]"). The full investigation is still there if anyone wants to dig in. Best when: * The channel is high-volume and you don't want the bot lengthening every thread * You're piloting Deductive and don't want it speaking authoritatively yet Toggle triage mode on a per-trigger basis from **Alert triggers → \[trigger] → Triage mode**. ## Step 6: Test without paging anyone You don't have to wait for a real incident. Three ways: **Forward an existing alert.** Go to a known-good alert post in another channel and use Slack's **Forward** action to send it to your test channel. Deductive will pick it up exactly as if it were freshly fired. **Paste a bare alert URL.** Most alert patterns match on URL shape alone. Paste a Grafana alert URL (e.g. `https://your-org.grafana.net/alerting/grafana/abc123/view?orgId=1`) into a channel where the bot is present. Deductive should react. **Run an investigation from the web app.** If you just want to confirm Deductive can investigate the underlying question, ask it directly: "Investigate the most recent alert in `#prod-alerts-payments`." That isolates the agent's reasoning from the trigger plumbing. ## Step 7: Tune as alerts come in Once real alerts start flowing, two knobs tune most of the noise: * **Trigger specificity.** If Deductive is reacting to messages you don't want, tighten the regex on the trigger or the channel filter. * **Triage threshold.** If the channel is busy and you only want investigations on the high-confidence ones, switch the trigger to triage mode. The feedback you leave on alert investigations also tunes the agent's behavior over time. See [Teach Deductive](/users/teach). ## What just happened Alerts that fire into your existing Slack channels now have a Deductive investigation attached automatically. The on-call sees evidence-backed context the moment they read the page, not after they've spent ten minutes context-switching. The same investigation is reachable from the web app. If the on-call wants to dig in, they click the canvas link, fork the decision tree, and continue from where Deductive left off. ## Try this next Prompt patterns that consistently produce sharp investigations. Useful when you reply in alert threads. # Continuous learning Source: https://docs.deductive.ai/users/continuous-learning How Deductive thinks, learns, and gets sharper over time. Shape the knowledge graph that grounds every answer and read the decision trees that produced it. Most "AI for ops" products give you an answer and ask you to trust it. Deductive gives you the answer **and** the knowledge graph it pulled context from, plus the tree of decisions that produced the answer. You can read both, click into either, and reshape both. Together they form the continuous-learning loop: the knowledge graph keeps growing as you connect new sources; every investigation builds a decision tree; every comment reinforces or penalizes branches; the next investigation starts from a sharper baseline. This page is a tour of those two surfaces and how they learn. ## Part 1. The knowledge graph Open **Agent → Knowledge** in the left nav (or `/knowledge`). The Knowledge Archive is the index Deductive consults to ground every investigation, before it even forms a hypothesis. Hand-drawn napkin sketch of the Deductive Knowledge Archive page. Tabs across the top read Knowledge, Reinforcement Learning, Decision Trees. Below the search bar, a treemap of colorful tiles labeled with service and concept names like doordashv2, turing, datahub, inference, app-ui, copilot, latency, staging, Slack, newrelic, Prometheus, Loki. Underneath the treemap, two example knowledge entries: 'Deductive AI Release & Deployment Process' with sections on release cadence, deployment pipeline, and team contributors; and the start of 'Inference Service: Deployment, Topology & Observability'. The graph has two pieces. ### Knowledge entries Short, curated pieces of context Deductive consults during investigations. Each entry has a title, a body, source memories it was built from, and a usefulness + confidence score. Examples of the kind of context an entry captures: * "`payments-api` is owned by Team Atlas. Page Atlas via `#oncall-atlas` for prod issues." * "Anything in the `legacy-` namespace is being deprecated; don't propose changes there." * "When `redis_evictions` spikes, look at `cache-warmer` deploy timing. They're correlated 80% of the time." * "Our staging cluster routinely has `error.rate=0.02` baseline; ignore unless it crosses 0.05." Click any entry to read its full body and the source memories it cites. You can rate an entry's usefulness from the entry view, which feeds into the confidence score Deductive carries with it on future investigations. ### The keyword graph Beyond explicit entries, Deductive maintains a keyword-ranked graph across everything you've connected. Repos, dashboards, incidents, PRs. The treemap at the top of the Knowledge Archive visualizes the relative weight of each keyword across your stack: the bigger the tile, the more central that concept is to your team's work. This isn't just decoration. Deductive uses the graph to retrieve context at investigation time: when a question mentions `checkout`, the graph surfaces the repos, dashboards, recent incidents, and knowledge entries that historically co-occur with `checkout`. The denser and better-curated your graph, the sharper investigations get. ## Part 2. Decision trees Once a question is grounded in the knowledge graph, Deductive plans an investigation as a **decision tree** and executes it. The tree is the audit trail. Open **Agent → Decision Trees** in the left nav, then pick a monitor or symptom from the dropdown at the top of the page. Each selection loads the trees Deductive has built for that monitor over time. Hand-drawn napkin sketch of the Deductive Decision Trees page. Top filter shows monitor_id 'VisualizeAnswerLongTailLatencyHigh' with 92 trees available. Header counts read: 49 nodes, 53 edges, end 19, evidence gatherer 14, decision 14, symptom 2. EVAL SCORES row: Overall 93%, Timeline OK 100%, Investigation Complete 100%, grpo rca conclusion quality 100%, Temporal Proximity 58%, Anti-Leakage 100%, Conclusion Quality 100%. The main pane shows a branching tree starting from a Symptom node ('Symptom: High latency detected'), fanning out through diamond-shaped Decision nodes ('Is the slow fraction below threshold?', 'Is there a saturation signal on gateway?', etc.) and rectangular Evidence-gatherer nodes ('Save evidence: Constants normal, check downstream', 'Save evidence: Gateway latency normal'), terminating in red End nodes ('Root cause: Slow fraction too high, deeper investigation', 'Root: Network not the cause', etc.). The right side panel shows the selected node D8 with type 'decision', label 'Is the actual slow fraction below threshold when computed from raw counters?', and a visit_stats block with visit_count 4, reinforced_count 0, plus tree_id and team_id fields. ### How to read it Trees grow top-to-bottom. Each tree investigates a single monitor or symptom from the dropdown above. | Node type | What it represents | Visual | | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | --------------- | | **Symptom** | The starting observation the tree is investigating ("high latency detected"). One per tree, at the root. | Green rectangle | | **Evidence gatherer** | A step that pulls or saves data: a metric query, a log search, "save evidence: gateway latency normal". | Rectangle | | **Decision** | A branching choice: "is the slow fraction below threshold?", "is there a saturation signal?". The yes/no answer routes to different sub-branches. | Diamond | | **End** | A terminal conclusion: a root cause, or a no-issue-here branch. Color-coded by severity. | Red rectangle | Above the tree, a header reports the counts: total nodes, total edges, and a breakdown by type ("end: 19 / evidence gatherer: 14 / decision: 14 / symptom: 2"). Edges carry the routing: a "yes" or "no" out of a decision diamond, or the outcome of an evidence gatherer that informed the next step. ### Click into any node Selecting a node opens a detail panel on the right with the node's full metadata: * **`node_id` and `node_type`.** The canonical id (e.g. `D8`) and category (`symptom`, `decision`, `evidence_gatherer`, `end`). * **`label`.** The question the node is asking, or the evidence statement it captured. * **`evidence_keys` and `node_metadata`.** Structured pointers to the data the node touched. Empty for purely-routing decision nodes; populated for evidence gatherers. * **`visit_stats`.** How often this node has been traversed (`visit_count`), when it was last hit (`last_visited_at`), how many times it's been reinforced as part of a canonical path (`reinforced_count`), and when (`last_reinforced_at`). This is the surface where reinforcement learning is visible at the node level. * **`guid`, `tree_id`, `team_id`.** References for cross-linking and team scoping. ### Eval scores Above the tree, Deductive shows an **eval scores** row computed across the trees for the selected monitor. Each axis grades a different property of the reasoning. The number in parentheses is the sample size (how many trees were evaluated): * **Overall.** The rollup across all axes. * **Timeline OK.** Whether the events the tree references actually line up in time. * **Investigation Complete.** Whether the tree explored enough branches before terminating. * **Temporal Proximity.** Whether the evidence the tree cited was close enough in time to the symptom to be causally plausible. * **Anti-Leakage.** Whether the tree avoided using information from after the symptom that wouldn't have been available at investigation time. * **Conclusion Quality.** How sharp and well-supported the terminal conclusions are. * **Domain-specific axes** (e.g. `grpo rca conclusion quality`). Additional axes the evals team has trained for your stack. A low score on any axis is the leading indicator of where to invest training. Drill into the trees that scored low on that axis, find the recurring failure mode, and reinforce a better path (see [Teach Deductive](/users/teach)). ## How the graph and the tree work together ```mermaid theme={null} flowchart TB Q[Your question or alert] --> G[Knowledge graph
retrieves grounding context] G --> S[Symptom
root of decision tree] S --> D1[Decision] S --> D2[Decision] D1 --> EG1[Evidence gatherer] D2 --> EG2[Evidence gatherer] EG1 --> E1[End: root cause] EG2 --> E2[End: no issue] E1 --> K[Comments feed back into
knowledge + reinforced trees] E2 --> K ``` The knowledge graph is "what the agent always knows." The decision tree is "what the agent did this time." They're two views of the same loop, and you can shape both. ## Try this next Turn the eval scores and knowledge entries you just saw into reinforced decision trees the agent reuses. Make Deductive react when an alert fires, so the decision trees you just learned to read get built in real time. # Your first investigation Source: https://docs.deductive.ai/users/first-investigation Deductive gives you two ways to talk to it. Ask for a quick answer, Investigate for a full reasoning run. This page walks through both so you know which to reach for. The chat input has two buttons: **Ask** and **Investigate**. The choice between them is the most important habit to form on day one. * **Ask** is a fast lookup. A single-pass answer grounded in your workspace's knowledge and recent telemetry. Typically tens of seconds, up to about a minute depending on the question. Best for "what is X", "where do I find Y", "when did Z last happen". * **Investigate** is a full reasoning run. Deductive forms competing hypotheses, gathers evidence in parallel across your connectors, and produces an answer with citations and a shareable canvas. Tens of seconds to a few minutes. Best for "why is X happening", "what changed", "is it the deploy or the dependency". Same input box, different button. Most teams hit Ask twenty times for every Investigate. Hand-drawn napkin sketch of the Deductive home page: left navigation with Home, Issues, Chats, Integrations, Agent, Automations, Teams; centered greeting and a chat input with Ask and Investigate buttons ## Step 1: Try Ask Open your Deductive workspace home (`app.deductive.ai` or your Enterprise `.deductive.ai`). In the chat input, type something narrow and click **Ask**: * "When was the last deploy of `payments-api`?" * "Which dashboards exist for `checkout`?" * "What's the on-call rotation for team Atlas this week?" * "What does the metric `auth.token_verify_p95` actually measure?" ## Step 2: Try Investigate Clear the input. Type something that's actually hard. Click **Investigate**: * "What was the worst-looking thing in production yesterday between 11pm and 2am?" * "Has anything weird happened with `[your service]` in the past 24 hours?" * "Why did `payments-api` p99 latency spike at 14:30?" * "Summarize this week's incidents and group them by likely cause." This kicks off a full reasoning run. Deductive forms multiple hypotheses, fans out tool calls across your connectors in parallel, scores the evidence, and consolidates the strongest branch into an answer. It usually takes 2–5 minutes. ## Step 3: Read the answer When the run finishes you get three things: * **An answer with citations.** Every claim has a citation chip. Click one to jump straight to the log line, metric query, commit, or dashboard panel it came from. Nothing is unsourced. * **A canvas.** Every Investigate run produces one by default, docked alongside the chat. The canvas is a structured document with sections for root cause, timeline, evidence, and recommended actions. Edit it freely. Deductive treats your edits as ground truth and won't overwrite them. The canvas is what most teams paste into a postmortem or share to Slack. * **A decision tree.** Open it from the right-side panel if you want to see Deductive's reasoning step by step. Reading the tree is a skill of its own and is covered on [Continuous learning](/users/continuous-learning). For now, just know it's there. If anything in the answer looks wrong, leave a one-line comment right there. That feedback feeds the training pipeline (full guide: [Teach Deductive](/users/teach)). ## Step 4: Follow up Don't end the investigation. Try one of these as a reply in the same thread: * "Why did you rule out a config change?" * "What if the regression actually started 24 hours earlier? Does the evidence still hold?" * "Show me every PR that touched this code path in the last month." Follow-ups extend the same investigation rather than starting a new one. The right mental model: an **investigation** is a long-lived conversation Deductive remembers all of, not a one-shot Q\&A. You can come back to a thread tomorrow and continue exactly where you left off. ## When to use which | You want | Reach for | | ---------------------------------------------------------------------- | ----------- | | A fact ("when was the last deploy?") | Ask | | A definition ("what does this metric mean?") | Ask | | A pointer ("which dashboard for X?") | Ask | | A status check ("is service Y healthy right now?") | Ask | | A diagnosis ("why is X slow?") | Investigate | | A timeline ("what changed before incident Y?") | Investigate | | A comparison ("is it the deploy or the dependency?") | Investigate | | A summary across many sources ("group this week's incidents by cause") | Investigate | ## What just happened You exercised the two primary modes Deductive ships with. Most day-to-day work stays in Ask. The wins your team will talk about (the 2am incident solved in three minutes, the postmortem-ready canvas) come from Investigate. Knowing which to reach for is the difference between a tool that's quick and a tool that's transformative. ## Try this next Open the decision tree from the Investigate you just ran. See exactly how Deductive reasoned, click into any node, replay it. Every alert that fires in your channels can trigger an Investigate automatically. The result lands in the alert thread. # Use Deductive in Slack Source: https://docs.deductive.ai/users/in-slack Talk to Deductive in any thread. Continue alert investigations cleanly, keep teammates in the loop, never leave the channel. Slack is where on-call life actually happens. Deductive lives there as a first-class participant. It answers in threads, it auto-investigates alerts, and every Slack thread is bidirectionally linked to the investigation in the web app. By the end of this page you'll know how to talk to Deductive from any thread, how to continue an alert investigation without losing context, and how to share an investigation across channels. ## What this page assumes The Deductive Slack app is already installed in your workspace (admin one-time work. See [Admin setup → Connect Slack](/admins/slack) if it isn't), and the bot is invited to the channels where you want to use it. This page covers the day-to-day "talk to Deductive in Slack" patterns. Auto-investigation setup is at [Wire alerts to auto-investigate](/users/auto-alerts). ## Talk to Deductive in any thread Two ways to start a conversation: ### Mention the bot `@Deductive` followed by your question. Works in any channel the bot is in, in DMs to the bot, and in threads on existing messages. ``` @Deductive what's the recent latency trend on the payments service? ``` Deductive replies in-thread (or starts a thread on your channel message). The reply includes a **web UI link** that opens the same conversation in the web app. Mentioning Deductive in a Slack channel ### Reply in an alert thread When an alert fires and Deductive auto-investigates, the alert's thread becomes the working surface. Replying with a follow-up. Even without `@Deductive`. Extends the same investigation. ``` [alert post] Deductive: triaged → likely cache eviction storm. Canvas: [link] You: are you sure it's not the new deploy from 14:20? Deductive: re-running with that hypothesis weighted higher… ``` Replying in an alert thread continues the investigation This is the pattern most teams settle into. The thread is the conversation; the canvas is the artifact. ## Keep your team in the loop A few patterns that compound nicely: **Drop a canvas link into your incident channel as the on-call work proceeds.** The canvas keeps updating as Deductive (and you) refine the investigation, so a link posted at minute 2 is still useful at minute 30. It beats pasting findings repeatedly. **Reply to Deductive's investigation reply with a confirmation or correction.** That reply is captured as feedback (see [Teach Deductive](/users/teach)), which means your in-thread "yep, root cause was the deploy, reverting now" makes the next investigation of the same kind sharper. **Reuse a reinforced decision tree.** When a question matches a tree your team has already reinforced, Deductive's reply names it inline ("reusing reinforced path: `payments-deploy-regression`"). Teammates can see exactly which canonical reasoning path is being applied and decide whether it's still the right one. ## Try this next If you skipped this earlier, this is the page that turns Slack from "chat with the bot" into "the bot is doing work for you". Replies in alert threads are feedback. Make them count. # Teach Deductive Source: https://docs.deductive.ai/users/teach How Deductive learns from your team. Implicit signals from Slack and chat conversations, explicit inline comments, and custom-context snippets you write directly. The default Deductive is good. The Deductive your team has been teaching for two months is the one nobody on your team can imagine working without. The simplest way to teach Deductive is to write standing instructions directly (section 0 below). Beyond that, two feedback modes compound through a training pipeline that produces reinforced decision trees and memories. ```mermaid theme={null} flowchart LR I[Implicit learning
Slack threads + chat follow-ups
frictionless] --> T[Training pipeline] E[Explicit learning
inline comments on messages
deliberate] --> T T --> R[Reinforced decision trees] T --> M[Memories feeding the
knowledge graph] ``` ## 0. Custom context: just tell it directly Sometimes the fastest way to teach Deductive is to write the instruction down once and have it apply everywhere. Click your avatar in the bottom-left of the workspace, open **Settings**, and pick **Custom context**. Custom context modal listing snippets like service ownership, naming conventions, and triage preferences Good things to put here: * **Conventions.** "We always run `kubectl describe` before blaming a node", "treat anything in the `legacy-*` namespace as deprecated, don't surface it as a primary cause". * **Owned-system facts.** "The payments service uses `pgbouncer`, not direct connections. A connection-count alert is almost always the bouncer", "auth tokens are issued by `auth-edge`, not the user service". * **Style preferences.** "Always include the offending PR if a code change is implicated", "default to one-line summaries unless I ask for detail". * **Things to avoid.** "Don't recommend reverts as a first step. We deploy forward.", "Never page the on-call from an investigation summary." Custom context is shared across the workspace and applies to every investigation the agent runs from that point forward. Edit anytime; updates take effect on the next run. Unlike the two modes below, custom context isn't *training*. It doesn't reinforce decision trees or produce memories. Think of it as a standing instruction sheet the agent reads before every investigation. Use it for the things you'd want the agent to know on day one, before there's enough conversation history for it to figure them out on its own. ## 1. Implicit learning: your team is already doing it When your team talks about an alert in a Slack thread, or follows up on an investigation, Deductive reads the conversation and picks up signals from it. You don't have to do anything special. The act of working the problem with teammates *is* the training data. What gets picked up: * **Confirmations.** "Yep, this was the deploy", "good catch", "agreed, restart fixed it". Treated as positive signal on the agent's diagnosis. * **Corrections.** "Actually it was the cache eviction storm", "the metric was wrong, it under-counts cache hits", "we ruled that out, look at the upstream gateway". Treated as negative signal on the path the agent took, plus a captured correction. * **Resolutions.** "We rolled back, problem solved", "Atlas is on it, ETA 30 min". Treated as outcome data. What fixed the issue, who owned it. * **Conventions and gotchas.** "Don't trust the staging error rate, it's noisy below 0.05", "ignore `legacy-*` namespaces, they're being deprecated". Treated as durable team knowledge. This is the easiest mode because it's invisible. You're already replying in the alert thread; the agent is reading along. Most of the memories your knowledge graph will accumulate come from this mode, not from anyone sitting down to "train" it. For Deductive to learn implicitly from a thread, the bot has to be in the channel. See [Use Deductive in Slack](/users/in-slack) for the day-to-day patterns. ## 2. Explicit learning: when you want to be deliberate Every Deductive message (chat reply, alert investigation, canvas draft) has a comment box. Use it when you want to be precise about *what* worked or *what* went wrong. Inline comment box on a Deductive message What to write: * **When the answer is right.** A short confirmation is enough. "Good", "this is the right call", "spot on". The decision tree that produced the answer gets reinforced, and the supporting evidence gets distilled into a memory the agent can draw on later. * **When the answer is wrong.** Write one line saying *what* went sideways. "Ruled out the deploy too early", "missed the parallel job", "answered confidently with stale data". The decision-tree branch that took the agent there gets penalized for similar future questions, and the correction itself becomes a memory. * **When the answer is right but the path was wasteful.** Say so. "Right answer, wrong tool, should have used `kubectl describe` instead." Useful for nudging the agent toward better-shaped reasoning even when the conclusion is correct. The more specific your comment, the stronger the signal in both directions. ## What modes 1 and 2 compound into Whether the signal comes from a Slack thread or an inline comment, it lands in the same place and produces the same two effects: ### Decision trees get reinforced or penalized Every signal is recorded alongside the decision tree that produced the answer. Positive signals mark the sequence of steps that led to the correct conclusion as **canonical** for that class of question: the next time a similar question shows up, Deductive will reuse that exact path. Negative signals mark the missteps as branches to avoid. You can see this happen on the [Decision Trees page](/users/continuous-learning#part-2-decision-trees): each node carries a `reinforced_count` and `last_reinforced_at` in its metadata. ### Memories feed the knowledge graph Signals also get distilled into **memories**, short structured records of what your team confirmed or corrected. Memories are the source material that knowledge entries are built from (each entry on the [Knowledge Archive](/users/continuous-learning#part-1-the-knowledge-graph) has a "X source memories" link back to the threads and comments it came from). When a future investigation touches a similar topic, those memories surface as grounding context. ## Do this now (5 min) One quick win in each mode: 1. **Custom context.** Open **Settings → Custom context** and add two snippets: one convention your team follows that an outsider wouldn't know, and one anti-pattern the agent has gotten wrong before. Two minutes; payoff is permanent. 2. **Implicit.** Find the most recent alert thread in Slack where Deductive auto-investigated. Reply with one sentence summarizing what *actually* fixed it (or what the real cause turned out to be). The agent learns from that reply as if you'd written it as feedback. 3. **Explicit.** Open one of yesterday's investigations in the web app. Find an answer that was right and leave a one-line confirmation. Find one place the agent took an unnecessary step and leave a one-line comment saying exactly what should have happened instead. ## The compounding effect A team that does this naturally (talking to each other in alert threads, leaving the occasional comment when something is clearly wrong, dropping a snippet into custom context when a wrong assumption keeps surfacing) has a meaningfully different agent within a quarter than the team that just uses Deductive out of the box. The mechanism is invisible until you see it: a question you asked last month gets answered faster and better today because of conversations and comments your teammates left in between. ## Try this next Implicit learning is mostly Slack-driven. The patterns that feed the loop best. See where both feedback modes show up: reinforced decision trees and a growing knowledge graph. # Welcome Source: https://docs.deductive.ai/users/welcome Your team has Deductive set up. Here's how to use it, and feel why it's different, in the next ten minutes. You're here because someone added you to a Deductive workspace. The connectors are wired up, the bot is in your channels, and every piece of feedback your team has left so far is already nudging the agent's reasoning. This page is the fast lane to *using* the thing. If you're an admin and the workspace **isn't** set up yet, jump to [Admin setup → Overview](/admins/overview). That's the one-time work that produces the workspace you're about to use. Hand-drawn napkin sketch of a Deductive investigation page: alert summary, TL;DR with metric cards, narrative findings, evidence chart, and a side panel showing reinforced learnings and decision tree ## What Deductive actually is Deductive is a production engineering agent that reads your code, telemetry, and incidents, reasons across all of it in parallel, and shows you its work. Not a chatbot wrapped around a search index. Not a summarizer. A reasoning engine you can argue with, watch think, and teach. When you ask it a question, it: * Forms multiple **hypotheses** about what could be happening * Spawns tools in parallel to gather evidence for each one (log queries, metric pulls, code reads, deploy diffs, dashboard fetches) * Builds a **decision tree** as it goes (you can open it, click any node, replay the thought) * Lands on an answer with **citations** you can click through to the raw source * Drops the conclusion into a **canvas** you can keep editing, share, or paste into Slack If it's wrong, you tell it. If it's right but verbose, you tell it. That feedback **reinforces successful reasoning paths and penalizes the bad ones**: the decision-tree branches that produced a correct answer get reused on similar future questions, and the missteps get avoided. The longer your team uses it, the sharper it gets, and you can read every step of why. ## What makes this different from "an AI chatbot for ops" * **It plans, not predicts.** Every investigation produces a decision tree of branching hypotheses. You can read it. You can fork from any node. * **It reasons in parallel.** The slow path of a tired engineer at 2am (check dashboard, then logs, then deploys, then config) happens concurrently. Minutes, not an hour. * **Evidence is clickable.** Every claim links back to the log line, metric, trace span, or commit it came from. If a citation is wrong, you'll see immediately. * **You teach it explicitly.** Inline comments are the floor. The ceiling is **reinforced decision trees**: a correct outcome reinforces the exact sequence of steps that produced it; a wrong outcome penalizes the missteps. * **It lives where you work.** The web app, Slack threads, Cursor, Claude Code, and PagerDuty alerts all hit the same agent and the same memory. ## Get going Ask vs Investigate: the two ways to talk to Deductive and when to reach for which. The knowledge graph and the decision trees: the two surfaces that make Deductive auditable instead of mysterious. How conversation and comments compound into reinforced decision trees and a sharper knowledge graph. Talk to Deductive in any thread. Replies in alert threads continue the same investigation. Make Deductive react when an alert fires. Investigation is in the thread before you finish reading the page. Prompt patterns that work, plus role-based examples for on-call, dev, and platform. If your workspace isn't set up yet (no green connectors, bot not in your alert channel), that's [Admin setup](/admins/overview).