Software that is tested by software.
intelliqx is a network of 28 specialised agents that plan, generate, execute, and govern your test suite — running anywhere Python runs, with no managed services required.
- 01 P planner emit DAG ✓
- 02 R risk_assessment score ✓
- 03 T test_design 12 cases ✓
- 04 C code_intel analysing
- 05 E environment queued
- 06 X execution queued
- 07 G release_readiness queued
12:04:18 planner plan.dag v3 emitted
12:04:19 risk_assessment high → auth.ts:74
12:04:21 test_design 12 cases · 3 negative
12:04:23 code_intel 28 modules indexed
12:04:24 code_intel paths: src/auth/**
12:04:25 environment spinning up container…
Powered by a transparent stack
The platform
A platform, not a patchwork of scripts.
intelliqx replaces ad-hoc test tooling with one runtime, one contract, and one set of agents — so every signal flows through the same path.
Plans are first-class artifacts.
The Planner emits a DAG, the Orchestrator walks it. Every plan is inspectable, replayable, and durable across runs.
Intelligence agents close the loop.
Requirements, code, risk, design, and coverage flow through Pydantic AI agents that produce structured plans — not vibes.
Real tests against real systems.
Environments spin up. Tests run. Selectors heal. Failures are analysed. Nothing ships without evidence.
Every signal is auditable.
Observability, reporting, compliance, and release readiness agents turn raw activity into decisions you can defend.
“ Tests are not artifacts. They are decisions — and every decision should be inspectable, replayable, and worth defending. ”
intelliqx · design principle
The agent catalog
28 specialised agents.
One runtime. One contract.
Each agent is a single Pydantic AI role. Compose them, swap them, run them in any boundary — they all speak the same protocol.
Stateless, single-purpose agents that emit plans, dispatch DAGs across the platform, and surface the right knowledge at the right time.
LLM-using agents that turn requirements, code, and history into structured inputs — risks, designs, data, coverage, and prompts.
Side-effecting agents that prepare environments, execute tests, self-heal selectors, measure performance and security, and recover fast.
Cross-cutting agents that observe the rest of the platform and produce reports, audits, compliance signals, and release decisions.
Architecture
One runtime. Four layers. Zero lock-in.
The same agent code runs in any boundary. Choose where each piece lives — and change your mind without rewriting logic.
Plan → Reason → Execute → Govern
A DAG flows top-down. Every node emits events. Every event is queryable. Every decision is logged.
Contract-tested adapters
Object store, state store, event bus, and vector index all satisfy the same interface. Swap backends without rewrites.
Zero-cost local dev
In-memory adapters make the entire pipeline runnable on a laptop with no external credentials.
Capabilities
Every primitive a serious test platform needs.
Graph storage, vector search, hybrid retrieval, polymorphic memory, contract tests, RBAC, audit — built in, not bolted on.
Knowledge graph on Parquet + DuckDB
Every node, edge, and traversal is queryable through SQL — no managed graph database required, runs anywhere object storage runs.
Vector search via zvec
Embedded vector store persisted to object storage. Tenant-scoped embeddings with no external services in the loop.
OKF catalog with hybrid retrieval
SQLite + FTS5 + sqlite-vec combine full-text and vector search over structured documentation, scoped per tenant.
Polymorphic memory manager
One agent entry-point handles working, episodic, semantic, and code memories — backed by in-process stores.
Contract-tested adapters
Every object-store, state-store, and event-bus implementation is asserted against the same interface — swap backends freely.
RBAC + ABAC + audit trail
Tenant-scoped permissions, dead-letter queues, human approval workflows, and tamper-evident audit records out of the box.
Zero-cost local dev
In-memory adapters for events, storage, state, vectors, and the LLM client make the entire pipeline runnable on a laptop.
Portable across process and container
The same agent code runs in-process, as a service, or in containers — choose boundaries without rewriting logic.
For developers
One API. One runtime. Any boundary.
The same call dispatches in-process, as a service, or in a container. Swap boundaries without changing your code.
# 1. Register the entire agent catalog.
from agents import register_all
from intelliqx_compute.runtime import (
InvocationRequest,
get_compute_runtime,
)
# Idempotent. Safe to call from anywhere.
register_all()
import asyncio
async def main() -> None:
runtime = get_compute_runtime()
# 2. Describe the intent. The Planner emits a DAG.
request = InvocationRequest(
agent_name="orchestrator",
input={
"goal": "Verify checkout for new EU tenants.",
"scope": ["auth", "payments", "checkout"],
"tenant_id": "tenant-eu-01",
},
tenant_id="tenant-eu-01",
)
# 3. Invoke. The Orchestrator walks the plan.
result = await runtime.invoke(request)
print(result.output)
asyncio.run(main())→ plan.dag v3 emitted (7 nodes)
→ risk_assessment medium
→ test_design 12 cases
→ environment up (2.1s)
→ execution 11/12 pass
→ self_healing 3 selectors
→ release_readiness green
PlanResult(status=passed, coverage=94%)
How a plan flows
From intent to release, in four movements.
Every plan walks the same path — observe, understand, execute, decide — and every step produces inspectable signals you can defend.
You describe intent
Pass a goal, scope, and tenant. The Planner emits a DAG.
Intelligence agents reason
Risk, requirements, design, coverage — all in one plan.
Execution runs tests
Real environments. Real checks. Self-healing included.
Governance ships the verdict
Reports, audits, and a green-or-red release decision.
Get started
Install once.
Run anywhere Python runs.
No accounts. No managed services. No cloud lock-in. Get a working pipeline on your laptop in under two minutes.
$ curl -LsSf https://astral.sh/uv/install.sh | sh $ git clone https://github.com/sachncs/intelliqx.git $ cd intelliqx && uv sync --all-packages $ uv run pytest tests/unit tests/contract -q