Skip to main content

DevAssure's O2 Agent is Now Available on GitHub Marketplace

Divya Manohar
Divya Manohar
Co-Founder and CEO, DevAssure

Every engineering team knows the tension. You ship fast, but testing can't keep up. Regression suites grow exponentially. Manual QA becomes a bottleneck. And somewhere between the PR and production, confidence starts to erode.

That's the problem we built O2 to solve. And today, we're making it even easier to adopt -

O2 is now available as a GitHub Action on the GitHub Marketplace.

What is O2?​

O2 is DevAssure's invisible AI testing agent. It doesn't just run tests - it understands your code changes, reasons about what's affected, and acts on it.

Here's what happens when O2 enters your workflow:

  1. It reads the diff. O2 analyzes the code delta from a branch comparison or a specific commit.
  2. It maps the impact. Instead of guessing, O2 traces changes to the exact user journeys and components they affect.
  3. It discovers existing coverage. O2 checks what's already tested and identifies the gaps.
  4. It generates missing tests. New or updated flows get end-to-end test coverage automatically.
  5. It executes and archives. The full session runs autonomously, and results are zipped with session IDs for traceability.

No scripts to write. No suites to maintain. No manual triage.

Why a GitHub Action?​

We've always believed that testing should live where code lives. O2 was already available through our CLI, VS Code extension, and as a Claude Skill. But CI/CD is where the rubber meets the road - it's where every team needs automated quality gates that actually work.

With the new GitHub Action, O2 plugs directly into your pipeline. You can trigger it on every push, every pull request, or on a schedule. The agent scopes its run to what actually changed, so you're not burning time on broad regression passes that test things nobody touched.

Here's what a basic workflow looks like:

- name: Run DevAssure O2
  uses: devassure/devassure-action@v1
  with:
    head: feature/checkout-refactor
    base: main
    environment: staging
    headless: true

That's it. O2 takes over from there.

The Problem With Traditional Test Automation in CI/CD​

Most teams add testing into their pipelines as an afterthought. The typical setup looks something like this: a growing suite of Selenium or Cypress tests that run on every build, take 30-45 minutes, flake out regularly, and require constant maintenance as the UI evolves.

The result? Teams either skip tests to ship faster, or they slow down to babysit flaky pipelines. Neither option is good.

O2 approaches this differently. It doesn't maintain a static suite. It reasons about each change dynamically - understanding the blast radius, generating targeted tests, and adapting when the UI shifts. If a selector drifts or a flow changes, the agent adjusts in real time instead of failing with a cryptic error.

What Makes O2 Different​

Change-aware, not suite-dependent​

O2 doesn't run everything every time. It scopes execution to the impact radius of the actual code change. If you refactored the checkout flow, O2 tests checkout - not the settings page.

Plain English test definitions​

You define behavior in natural language. O2 translates intent into executable test flows. Your QA team doesn't need to learn a framework or maintain page objects.

Self-healing execution​

When the UI evolves, O2 adapts its execution path. No more broken tests because someone changed a button's class name.

Zero-config reporting​

Results are automatically archived with session IDs. Plug them into your existing reporting tools or review them directly.

Who Is This For?​

If your team ships frequently and struggles with any of the following, O2 was built for you:

  • QA is a bottleneck. Your developers ship PRs faster than QA can validate them.
  • Regression suites are unreliable. Flaky tests erode trust and slow down merges.
  • Test maintenance is a tax. Every UI change means updating dozens of test scripts.
  • You want CI/CD quality gates that actually catch things. Not just green checkmarks that give false confidence.

We've seen this work across teams of all sizes - from startups shipping daily to enterprises managing complex release trains. Companies like Nokia, Coverfox, Attentive, BankBazaar, and many others already trust DevAssure to power their QA workflows.

Getting Started​

Getting O2 into your GitHub workflow takes minutes. Here's a step-by-step walkthrough.

Prerequisites​

Before you begin, you'll need:

  • A DevAssure account. You can sign up for a free trial at app.devassure.io/sign_up.
  • A DevAssure auth token for CI/CD use. Once logged in, generate a token from DevAssure web portal.
  • A GitHub repository with your application code.
  • A DevAssure project initialized in your repo. If you haven't done this yet, install the CLI globally with npm install -g @devassure/cli, then run devassure init in your project root. This creates a .devassure/ folder containing your app config, test data, preferences, and test cases.

Step 1: Store Your Token as a GitHub Secret​

Your DevAssure auth token should never be hardcoded. Add it as a repository secret:

  1. Go to your GitHub repo -> Settings -> Secrets and variables -> Actions.
  2. Click New repository secret.
  3. Name it DEVASSURE_TOKEN and paste your token as the value.

Step 2: Create the Workflow File​

In your repository, create a new file at .github/workflows/devassure.yml. Here's a workflow that runs O2 on every pull request:

name: DevAssure O2 Testing

on:
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
          ref: ${{ github.head_ref || github.ref_name }}
      - uses: actions/setup-node@v4
        with:
          node-version: "24"
      - name: Run DevAssure O2
        uses: devassure/devassure-action@v1
        env:
          DEVASSURE_TOKEN: ${{ secrets.DEVASSURE_TOKEN }}

Let's break down what's happening:

  • fetch-depth: 0 ensures the full git history is available so O2 can compute accurate diffs between branches.
  • head and base tell O2 which branches to compare. On a pull request, github.head_ref automatically resolves to the feature branch.
  • environment maps to the environment key in your .devassure/test_data.yaml - this is where O2 picks up the target URL, credentials, and test data.
  • headless: true runs the browser in headless mode, which is what you want in CI.
  • archive tells O2 to zip and save session results to a directory, which you can then upload as a build artifact.

Step 3: (Optional) Upload Test Reports as Artifacts​

To make test reports downloadable from your GitHub Actions run, add a step after the O2 action:

      - name: Upload test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: devassure-reports
          path: ./test-reports

Using if: always() ensures the reports are uploaded even if tests fail - which is exactly when you need them most.

Step 4: Test a Specific Commit (Alternative Trigger)​

If you prefer to run O2 against a specific commit instead of a branch comparison, you can configure it like this:

      - name: Run DevAssure O2 on commit
        uses: devassure/devassure-action@v1
        with:
          token: ${{ secrets.DEVASSURE_TOKEN }}
          commit: ${{ github.sha }}
          environment: staging
          headless: true

This is useful for post-merge validation on your main branch or for nightly runs against the latest commit.

Step 5: Push and Watch It Work​

Commit your workflow file, open a pull request, and head to the Actions tab in your GitHub repo. You'll see O2 pick up the diff, map the impact, generate tests, and execute them - all within the run logs.

Beyond GitHub Actions​

The GitHub Action is the fastest way to get O2 into your pipeline, but it's not the only option. You can also run O2 through:

  • CLI: devassure test --head feature/checkout --base main - great for local testing before you push.
  • VS Code Extension: Test a branch or commit directly from the editor's Tests view, without leaving your IDE.
  • Claude Skill: Use O2 as part of an AI-assisted development workflow.

All paths lead to the same agent intelligence - pick whatever fits your team's workflow best.

What's Next​

This GitHub Marketplace launch is a milestone, but it's just the beginning. We're continuing to deepen O2's reasoning capabilities, expand integration points, and make autonomous testing the default - not the exception.

If you've been looking for a way to make your CI/CD pipeline genuinely intelligent about quality, give O2 a try. We'd love to hear what you think.

Links​