Beyond Selectors: The Starlight Protocol and the Era of Sovereign Automation

The Problem with Traditional Automation

Every test engineer has experienced the 3 AM page: "Build Failed - Element Not Found."

Traditional browser automation is fragile by design. We bind our tests to the implementation details of the UI—CSS selectors, XPaths, and dynamic IDs that change with every sprint. When a developer renames a button, our tests break. When a modal appears unexpectedly, our scripts crash.

The industry's solution? Add more wait statements. More try-catch blocks. More conditional logic.

Introducing Constellation-Based Automation

What if your automation could handle unexpected obstacles the way a human does—not by predicting every possible state, but by *adapting* to whatever the environment throws at it?

This is the core philosophy behind Constellation-Based Automation (CBA) and its communication protocol, Starlight.

Instead of writing scripts that handle every edge case, CBA introduces a Sovereign Constellation of autonomous agents that:

• Monitor the environment for obstacles (popups, modals, network jitter)
• Clear the path before your intent even knows there was a problem
• Learn from experience to handle similar situations faster next time

The Architecture: A New Paradigm

┌─────────────────────────────────────────────────────────────┐
│                      INTENT LAYER                           │
│         "Login" • "Submit Form" • "Initiate Mission"        │
└─────────────────────────┬───────────────────────────────────┘
                          │ JSON-RPC
                          ▼
┌─────────────────────────────────────────────────────────────┐
│                        CBA HUB                              │
│              Orchestrator • Semantic Resolver               │
│                   Predictive Memory                         │
└───────────┬─────────────┬─────────────┬─────────────────────┘
            │             │             │
            ▼             ▼             ▼
    ┌───────────┐  ┌───────────┐  ┌───────────┐
    │   PULSE   │  │  JANITOR  │  │  VISION   │
    │ Stability │  │ Heuristic │  │  AI-Based │
    │  Monitor  │  │  Healing  │  │ Detection │
    └───────────┘  └───────────┘  └───────────┘
         │              │              │
         └──────────────┴──────────────┘
                        │
                        ▼
              ┌──────────────────┐
              │     BROWSER      │
              │   (Playwright)   │
              └──────────────────┘

The Sentinels

The Starlight Protocol

Communication between the Hub and Sentinels uses JSON-RPC 2.0 with a set of standardized signals:

Predictive Intelligence: The Galaxy Mesh

CBA doesn't just react—it learns.

// First run: User clicks "Submit" → selector fails
// Hub learns: "Submit" goal worked with "#submit-btn" in the past
// Second run: Auto-substitutes and succeeds

The ROI Dashboard: Proving Value

Every mission generates a "Hero Story" report that quantifies the business value:

Real-World Impact

In traditional automation, a single unexpected modal can:

• Crash the test → 30 seconds wasted
• Trigger manual investigation → 5-10 minutes
• Require code changes → 30-60 minutes
• Wait for PR review → hours to days

In CBA, the same modal:

• Detected by Janitor Sentinel → 0.1 seconds
• Cleared automatically → 0.5 seconds
• Test continues successfully
• Event logged for dashboard

Time-Travel Triage: Debugging the Future

When something does go wrong, CBA doesn't leave you guessing. The Time-Travel Triage feature records every handshake, every decision, every DOM state.

Open `triage.html`, load your mission trace, and *rewind* to see exactly what the browser looked like when the failure occurred. No more "works on my machine" debates.

Getting Started

# Clone and setup
git clone https://github.com/starlight-protocol/starlight
cd cba
npm install
pip install -r requirements.txt
npx playwright install chromium

# Run the constellation
run_cba.bat  # Windows

Or build your own Sentinel in minutes:

from sdk.starlight_sdk import SentinelBase
import asyncio

class MySentinel(SentinelBase):
    def __init__(self):
        super().__init__(layer_name="MySentinel", priority=10)
        self.capabilities = ["custom-healing"]

    async def on_pre_check(self, params, msg_id):
        # Your healing logic here
        await self.send_clear()

if __name__ == "__main__":
    asyncio.run(MySentinel().start())

The SDK handles:

• ✅ WebSocket connection management
• ✅ Auto-reconnect on failure
• ✅ Persistent memory (JSON-based)
• ✅ Graceful shutdown (Ctrl+C saves state)
• ✅ Configuration loading

The Technology Stack

The Future: Sovereign Security

Phase 9 is on the horizon, bringing enterprise-grade features:

• Shadow DOM Penetration: Handle modern web components with encapsulated styles
• PII Sentinel: Detect and redact sensitive data before screenshots
• Traffic Sovereign: Network-level chaos engineering and request mocking

Why "Starlight"?

The dung beetle doesn't navigate by watching the ground. It looks up at the Milky Way—a fixed reference point that transcends the chaos below.

Conclusion: A Paradigm Shift

CBA isn't just a framework—it's a philosophical shift in how we think about automation.

The goal is constant. The path is sovereign. The mission will succeed.

Built with ❤️ by Dhiraj Das
Explore the protocol on GitHub