HalTest: My PoC to End the 'Framework Expert' Dictatorship

Beyond Frameworks: Building a Visual Automation Engine for the Modern QA

For years, the QA industry has lived under a silent dictatorship: the dictatorship of tools.

As a QA engineer, I have lost job opportunities, not because I lacked logical thinking or a vision for quality, but because I didn't master the specific syntax of the framework a company required.

The question that has kept me awake on late nights while fixing broken tests is: Why are we still building automation as if we were writing system software instead of designing quality strategies?

The Birth of HalTest

After years of frustration with the high barriers to entry of traditional frameworks, I decided to stop complaining and start building.

HalTest is a visual automation framework running on top of Playwright, where business logic prevails over syntax.
My inspiration didn't come from the testing world, but from tools that changed the rules: Figma democratized design, and N8N democratized system integration. Why should test automation remain an illegible block of text in an IDE?

What it actually does: Architecture, not PowerPoint

I’m not showing mockups. This is what is already working today:

🧠 Graph-Based Execution Engine

The canvas isn't just pretty UI. Under the hood, there is a graph engine that solves:

• Dead Path Elimination (DPE): When a conditional resolves a branch, dead paths are recursively eliminated — they don't execute, they don't waste time, and they are visually marked as skipped.

• Pre-execution Validation: A GraphValidator analyzes the flow structure before launching the browser, detecting orphaned nodes or cycles. If your flow has a structural error, you know it before wasting time waiting for a runtime failure.

• Formal Variable Scoping: A VariableManager with 3 levels of scope (node → flow → global) and a sandboxed ExpressionEngine that ensures execution safety.

🔧 3-Layer Self-Healing

Test maintenance is resolved through intelligent layers, as seen in real-time execution:

1. Experience Vault (Layer 0): Queries a local database of previous successful repairs. If the selector was repaired before, it is reused instantly without spending tokens.

2. DOM Compression + AI Diagnosis (Layers 1-3): If there is no previous memory, the system compresses the DOM and sends only what is necessary to the AI for diagnosis.

3. Real Browser Verification: Each candidate is verified in the live page before being accepted.

📤 Native Code Export

There is no vendor lock-in. The PlaywrightGenerator translates your visual flow into a .spec.js file executable by pure Playwright.
Your flow lives as a visual graph but materializes as standard, native code.

Deterministic AI: The Shared Responsibility Model

Many autonomous agents try to build tests from start to finish, but this is a mistake. If you replace me with an AI, remember that you are the one who assumes the consequences when the AI fails.

In HalTest, the AI doesn't have total autonomy. The model is explicit: You (the QA) decide the flow, the AI is the assistant that diagnoses and repairs under your confirmation.
Everything runs under a white-list ontology that prevents the AI from inventing node types, ensuring the system remains stable and deterministic.

Privacy and Local-first

Thanks to the integration with Ollama, all AI can run locally. Your test data, selectors, and business logic never leave your infrastructure.

A Project in Motion

HalTest is a work in progress.
It was born from the personal need to solve the maintenance headaches we all face.

You can try it out now by running:

npx haltest@latest

Explore the ecosystem:

*Documentation & Landing: *
Visit haltest.com to see the full vision and upcoming roadmap.

*Source Code: *
The project is open-source.
You can inspect, fork, or contribute on GitHub at hal-test.

Your feedback and contributions are more than welcome.