Skip to main content
Swarm is Propolis’s AI exploration engine that autonomously discovers features in your application and generates complete test suites.

​
What Is the Swarm?

Instead of manually creating tests one by one, Swarm:
  • Intelligently crawls your application like a human would
  • Discovers user flows and features automatically
  • Generates test cases with complete step definitions
  • Creates assertions for expected behaviors
  • Proposes a comprehensive test suite for your review
Think of it as hiring an expert QA engineer who explores your entire app and documents everything they find as automated tests.

​
Starting a Swarm Run

1

Navigate to Swarm

Go to Swarm → Create Run
2

Enter starting URL

Where the Swarm begins exploring (e.g., https://app.yoursite.com)
3

Add guidance (optional but recommended)

Focus Area - Describe what to test
  • “Focus on checkout and payment flows”
  • “Test admin dashboard features”
Guidelines - Tell the Swarm what to avoid
  • “Don’t delete any data”
  • “Avoid logout button”
Documentation URLs - Provide links to docs or API specs for better context
4

Configure authentication

Option 1: Credentials
  • Provide login email and password
  • The Swarm logs in automatically
Option 2: Browser Profile (recommended for SSO/2FA)
  • Select a saved logged-in browser profile
  • More reliable for complex auth
5

Set target test count

We recommend starting with 15 tests for your first run.
Advanced settings (concurrency, branching factor) are already set to optimal defaults - no need to adjust them.
6

Start the run

Click Create Run and the Swarm will begin exploring

​
Monitoring Progress

Once started, Swarm runs autonomously. You’ll see: Status - Running, Completed, or Failed Progress Indicators:
  • Number of tests generated
  • Pages explored
  • Time elapsed
  • Current exploration paths
Live Updates - Tests appear in real-time as they’re generated
Swarm runs can take 10 minutes to several hours depending on application complexity and configuration.

​
Reviewing Generated Tests

Once complete, Swarm creates a new test suite with all generated tests marked as “Proposed”.
1

Navigate to Manage Suites

Find your new suite (named after your Swarm run)
2

Expand the suite

Click to view all proposed tests
3

Review each test

Click individual tests to see:
  • Test name describing the flow
  • Complete list of test steps
  • Assertions and expected outcomes
Look for tests that validate critical user journeys and business logic
4

Accept or reject with feedback

For each test:
  • ✅ Accept if it tests important behavior
  • ❌ Reject if it’s redundant, trivial, or incorrect
Provide feedback when accepting/rejecting. This helps future Swarm runs learn what makes a good test for your application.
5

Run accepted tests

Once you’ve accepted tests, run them to verify they work correctly
Always review generated tests. Swarm is intelligent but not perfect - some tests may need editing or removal.

​
Best Practices

Don’t try to test everything at once. Start focused:First run: “Test user authentication and profile management”
Second run: “Test checkout and payment flows”
Third run: “Test admin dashboard features”This gives you control and makes review manageable.
Tell the Swarm what to avoid:
  • Destructive actions (delete, cancel)
  • External integrations
  • Premium features (if testing free tier)
  • Known broken features
This prevents generating tests that fail or cause issues.
If your app has:
  • SSO/OAuth
  • 2FA
  • Custom auth flows
  • Session complexity
Use a browser profile instead of credentials. It’s more reliable.
Batch review tests by category:
  1. Accept obviously good tests (critical paths)
  2. Review edge cases carefully
  3. Reject redundant or trivial tests
  4. Edit tests that are almost right
Aim for quality over quantity.
After accepting tests:
  1. Run them individually first
  2. Fix any that fail
  3. Add to schedules once stable
Don’t accept all tests then schedule them - validate first.

​
Troubleshooting

Possible causes:
  • Authentication failed
  • Starting URL inaccessible
  • Application requires specific setup
Solutions:
  • Verify credentials work manually
  • Check starting URL is correct
  • Use browser profile for complex auth
  • Add focus area description
Possible causes:
  • Insufficient guidance
  • Branching factor too high (exploring too randomly)
  • Application has confusing UX
Solutions:
  • Add detailed focus area description
  • Provide guidelines for what to avoid
  • Include documentation URLs
  • Lower branching factor for more focused exploration
Possible causes:
  • Target test count too high
  • Branching factor too high
  • Application is very large
Solutions:
  • Lower target test count
  • Reduce branching factor
  • Add specific focus area (don’t test everything)
  • Increase max concurrency for parallel exploration
Possible causes:
  • Infinite loop in application
  • Modal or popup blocking navigation
  • Session expired during exploration
Solutions:
  • Add guidelines to avoid problem areas
  • Use browser profile with longer session
  • Manually test the path Swarm was exploring
  • Report issue to support with run ID

​
When to Use the Swarm

Perfect For

  • Initial test coverage generation
  • Discovering features in complex apps
  • Regression testing after refactors
  • Testing areas you don’t fully understand
  • Exploring competitor apps (if accessible)

Not Ideal For

  • Simple, well-understood flows (faster to create manually)
  • Highly dynamic SPAs with heavy client-side logic
  • Apps requiring complex multi-step setup
  • Critical paths needing exact specifications
Use the Swarm to bootstrap your test suite, then supplement with manually created tests for critical paths that need precise control.