Integrations

Slack

Get notified about agent lifecycle events in your Slack channels. No bot installation needed, just a webhook URL.

• Event notifications. Choose which events trigger notifications: started, completed, failed, or stopped. Most teams only care about failures.
• Per-project routing. Route different projects to different channels. Send production alerts to #production-alerts and staging results to #qa.
• Incoming Webhooks. Uses Slack Incoming Webhooks so there is no bot to install. Just create a webhook in Slack and paste the URL.

GitHub

Create GitHub issues from Aiqaramba findings. Connect GitHub by installing the Aiqaramba GitHub App on your organization.

• Finding triage. Open a finding, choose a repository, and create a one-time GitHub issue with the finding details and evidence links.
• Repository choice. Pick the target repository when creating the issue, so repository access never depends on stale tenant-level settings.

Linear

Sync issues as test journeys and report results back. Connect your Linear workspace with your Aiqaramba tenant to get started.

• Two-way sync. Import Linear issues as test journeys filtered by label and state. Results are posted back to the linked Linear issue as comments with pass/fail status, duration, and a link to the full agent detail page.
• Auto-create issues. When agents find failures, Aiqaramba can automatically create Linear issues with all the details.
• Workflow states. Move issues between workflow states based on pass/fail results. Your issue tracker stays in sync with reality.

CI / GitHub Actions

Run an LLM-matched regression suite against your deployed app from your CI pipeline. The regression endpoint takes commits + a deployed version, picks the journeys most relevant to the changed files, and returns the agent IDs you can poll for results — designed to slot into a GitHub Actions workflow that runs after every deploy (or only on minor-version bumps if you want to keep CI quota tight).

• LLM-matched suite. The endpoint reads your commit messages and changed files, matches them against your project's journey catalog, and runs at most 5 of the most-relevant journeys. Patches that only touch unrelated code result in zero matched journeys and zero CI cost.
• Auto-generates journeys for new surfaces. When the matcher finds zero coverage for a change (e.g. you shipped /admin/billing and no journey reaches it), the endpoint asks the LLM to generate a fresh exploratory journey for the inferred surface and runs it. Works either with a completed discovery's app map (precise) or with just the project's entry URL (exploratory). Either way you don't have to maintain a perfect journey catalog by hand. The response's auto_journey_status field surfaces what the step did — surface it in your CI summary so empty regression runs come with a meaningful explanation rather than a blank panel.
• Two secrets to configure. A scoped API key for the project and the project's UUID (visible on the project settings page next to its name). Drop them into your repo's secrets store as AIQARAMBA_API_KEY and AIQARAMBA_PROJECT_ID.
• Block deploys on regressions. Poll GET /api/v1/agents/<id> until each triggered agent reaches completed / failed / stopped, then fail the workflow on any non-completed terminal state. The full agent run, screenshots, and findings stay one click away in the dashboard.

Reference workflow

Add this as a job to your existing deploy workflow. It runs after a successful deploy, gates on v*.*.0 minor-bump tags, builds a payload of every commit since the previous tag, triggers regression, and writes a Step Summary with deep links into aiqaramba — so a red check on GitHub is one click away from the failing agent's trace.

regression-gate:
  needs: deploy
  runs-on: ubuntu-latest
  outputs:
    run: ${{ steps.check.outputs.run }}
  steps:
    - id: check
      run: |
        if [[ "${GITHUB_REF_NAME}" =~ ^v[0-9]+\.[0-9]+\.0$ ]]; then
          echo "run=true" >> "$GITHUB_OUTPUT"
        else
          echo "run=false" >> "$GITHUB_OUTPUT"
        fi

regression:
  needs: [deploy, regression-gate]
  if: needs.regression-gate.outputs.run == 'true'
  runs-on: ubuntu-latest
  environment: production
  timeout-minutes: 45
  steps:
    - uses: actions/checkout@v6
      with: { fetch-depth: 0 }

    - name: Build payload
      run: |
        # Diff against the previous *minor* bump, not the previous
        # tag of any kind — a minor bump rolls up every patch that
        # shipped during the previous minor cycle, so the regression
        # has to span all of those commits, not just the empty gap
        # between the latest patch and this minor.
        PREV=$(git tag --list "v*.*.0" --sort=-creatordate | grep -v "^${GITHUB_REF_NAME}$" | head -1)
        RANGE="${PREV:+$PREV..}HEAD"
        : > commits.ndjson
        for sha in $(git rev-list "$RANGE"); do
          msg=$(git log -1 --pretty=format:'%s' "$sha")
          files=$(git show --pretty='' --name-only "$sha" | jq -R . | jq -cs 'map(select(length > 0))')
          jq -nc --arg m "$msg" --argjson f "$files" '{message:$m, files_changed:$f}' >> commits.ndjson
        done
        jq -cs . commits.ndjson > commits.json
        jq -nc --slurpfile c commits.json --arg sha "$GITHUB_SHA" \
               --arg ver "$GITHUB_REF_NAME" \
               '{commits:$c[0], commit_sha:$sha, version:$ver}' > payload.json

    - name: Trigger regression
      env:
        API_KEY:    ${{ secrets.AIQARAMBA_API_KEY }}
        PROJECT_ID: ${{ secrets.AIQARAMBA_PROJECT_ID }}
      run: |
        response=$(curl -fsS -X POST -H "Authorization: Bearer $API_KEY" \
          -H "Content-Type: application/json" --data @payload.json \
          "https://app.aiqaramba.com/api/v1/projects/$PROJECT_ID/regression")
        echo "$response" > response.json
        echo "$response" | jq -r '.agents[]?.id' > agent_ids.txt
        run_id=$(jq -r '.regression_run_id // "n/a"' response.json)
        matched=$(jq '.matched_journeys | length' response.json)
        {
          echo "## Aiqaramba regression — ${GITHUB_REF_NAME}"
          echo "**Run ID:** ${run_id}"
          echo "**Project:** [open in aiqaramba](https://app.aiqaramba.com/projects/${PROJECT_ID})"
          if [ "$matched" -eq 0 ]; then
            echo "_No journeys matched._"
          else
            echo "### Agents"
            echo "| Status | Journey | Trace |"
            echo "|---|---|---|"
          fi
        } >> "$GITHUB_STEP_SUMMARY"

    - name: Wait for agents
      env:
        API_KEY: ${{ secrets.AIQARAMBA_API_KEY }}
      run: |
        [ -s agent_ids.txt ] || exit 0
        fail=0
        while read -r id; do
          name=$(jq -r --arg id "$id" '.agents[]|select(.id==$id)|.name' response.json)
          for i in $(seq 1 60); do
            s=$(curl -fsS -H "Authorization: Bearer $API_KEY" \
              "https://app.aiqaramba.com/api/v1/agents/$id" | jq -r .status)
            case "$s" in
              completed)        final=completed; break ;;
              failed|stopped)   final="$s"; fail=1; break ;;
            esac
            sleep 30
          done
          icon=$([ "$final" = completed ] && echo ✅ || echo ❌)
          echo "| $icon $final | $name | [view](https://app.aiqaramba.com/agents/$id) |" \
            >> "$GITHUB_STEP_SUMMARY"
        done < agent_ids.txt
        exit $fail

Two repository secrets are scoped to a production environment so PR-triggered workflows can't read them: AIQARAMBA_API_KEY (generate one in aiqaramba, scoped to this project) and AIQARAMBA_PROJECT_ID (visible on the project settings page next to the project name; click the Copy button next to it). For other CI systems the shape stays the same — POST commits + version → poll GET /api/v1/agents/<id> until each agent reaches a terminal status.

Setting up integrations

Integrations are configured at the organization level by admin users. Go to Admin > Integrations in the sidebar to connect your services. Each integration has its own setup flow, but they all follow the same pattern: click connect, authorize, and configure the details.

• Go to Integrations Connect Slack, GitHub, and Linear from your organization settings.