PaperlayerView exact revision on arXiv

Source-linked AI summary

Qualixar OS: A Universal Operating System for AI Agent Orchestration

Varun Pratap Bhardwaj

arXiv:2604.06392v1cs.AIcs.MAcs.SE

TL;DR

Existing LLM-agent frameworks are fragmented and incompatible, lacking a universal runtime for orchestration and production management. Qualixar OS provides such a runtime through automated team design, multi-agent execution, routing, quality assessment, and compatibility mechanisms; it reports 2,821 tests and 100% accuracy on a curated 20-task suite, with a mean cost of $0.000039 per task.

  • Problem

    Existing LLM-agent frameworks use incompatible agent definitions, execution models, and tooling, limiting interoperability and leaving cost tracking, quality assurance, and management dashboards unavailable.

  • Method

    Qualixar OS combines a 12-step orchestration pipeline with Forge team design, topology-specific execution, cost-aware routing, consensus-based judging, and universal framework compatibility.

  • Results

    2,821 tests supported the system, while a curated 20-task suite achieved 100% accuracy at a mean cost of $0.000039 per task.

  • Takeaways & Limitations

    Qualixar OS provides a universal runtime intended to bridge AI-agent frameworks and production systems for developers and non-technical users.

  • Takeaways & Limitations

    The 100% accuracy result comes from a curated 20-task suite excluding web browsing, file manipulation, and multi-tool orchestration, while standard-benchmark results remain future work.

Abstract

from arXiv · show

We present Qualixar OS, the first application-layer operating system for universal AI agent orchestration. Unlike kernel-level approaches (AIOS) or single-framework tools (AutoGen, CrewAI), Qualixar OS provides a complete runtime for heterogeneous multi-agent systems spanning 10 LLM providers, 8+ agent frameworks, and 7 transports. We contribute: (1) execution semantics for 12 multi-agent topologies including grid, forest, mesh, and maker patterns; (2) Forge, an LLM-driven team design engine with historical strategy memory; (3) three-layer model routing combining Q-learning, five strategies, and Bayesian POMDP with dynamic multi-provider discovery; (4) a consensus-based judge pipeline with Goodhart detection, JSD drift monitoring, and alignment trilemma navigation; (5) four-layer content attribution with HMAC signing and steganographic watermarks; (6) universal compatibility via the Claw Bridge supporting MCP and A2A protocols with a 25-command Universal Command Protocol; (7) a 24-tab production dashboard with visual workflow builder and skill marketplace. Qualixar OS is validated by 2,821 test cases across 217 event types and 8 quality modules. On a custom 20-task evaluation suite, the system achieves 100% accuracy at a mean cost of $0.000039 per task. Source-available under the Elastic License 2.0.

1 Introduction

Qualixar OS addresses fragmentation among incompatible agent frameworks by proposing a universal application-layer runtime for orchestration. It combines topology execution, automatic team design, adaptive routing, quality assurance, attribution, compatibility, and unified interfaces.

  • Framework fragmentation prevents agents built in one ecosystem from running in another without rewriting, while lacking integrated cost tracking, quality assurance, and management dashboards.
  • Qualixar OS frames an agent operating system as a universal runtime that orchestrates agents regardless of their underlying framework.
  • 12 topology execution semantics formalize multi-agent patterns with termination conditions, message passing, and aggregation strategies.
  • Forge translates natural-language tasks into complete teams with role assignments, topology selection, tool attachment, and model allocation.
  • A three-layer routing architecture combines strategy selection, model selection, Bayesian updates, and live discovery across 10 provider APIs.
  • The system adds an 8-module quality stack, four-layer attribution, Claw Bridge compatibility, and a 24-tab dashboard with a 25-command universal protocol.

2 Related Work

Prior systems address selected communication, execution, routing, evaluation, or operating-system concerns, but Qualixar OS combines these concerns in an application-layer orchestration runtime. Its architecture unifies multiple layers, transports, quality mechanisms, and compatibility protocols.

  • A systematic study covers 40+ open-source agent systems across five tiers of GitHub adoption.
  • AutoGen, CrewAI, MetaGPT, CAMEL, and LangGraph provide narrower topology, role, SOP, communication, or graph capabilities without the full combination of routing, team design, quality assurance, and dashboard features.
  • Agent Operating Systems: AIOS provides kernel-level scheduling, context, and memory management, whereas Qualixar OS operates at the application layer for orchestration concerns.
  • AgentAssert, AgentAssay, and SkillFortify inform Qualixar OS’s drift monitoring, judge-pipeline testing, and skill-ecosystem security integration.
  • Qualixar OS extends prior routing work toward multi-objective optimization across cost, quality, and latency using a three-layer meta-learning architecture.
  • Self-Improving Agent Systems: Its Goodhart module monitors cross-model entropy, calibration drift, and score inflation, while its trilemma approach bounds capability gains and preserves safety through architectural firewalls.
  • The six-layer architecture spans presentation, transport, orchestration, execution, infrastructure, and persistence, with the orchestrator coordinating Forge, Judge, Router, and Cost Tracker.
  • Protocol-Unified Agent Teams: A canonical A2A message format and transport selection unify local, remote, and tool communication, enabling agent hot-swapping without code changes.

4 Forge: Automatic Team Composition

Forge is an LLM-driven team designer that converts a natural-language task and budget into a complete multi-agent team, using historical performance data to guide composition. Rejected designs enter bounded redesign loops that can refine or replace the topology before human escalation.

  • Forge uses an LLM and historical performance data to compose multi-LLM agent teams.It is presented as a meta-cognitive team designer rather than an optimization-based team-composition approach.
  • Given task description T and budget B, Forge produces agent roles, a topology, tool assignments, and model allocations.The resulting design is D = (A, τ, T, M).
  • The design algorithm classifies the task, generates a design from recommendations and available resources, then validates tools and structure.The algorithm includes task classification, LLM generation, and validation steps.
  • After a rejected output, Forge refines the existing topology, forces a different topology after three redesigns, and escalates after five iterations or 3× budget.Radical redesign queries stored designs to avoid repeating failed patterns.

5 12-Topology Execution Taxonomy

Qualixar OS defines 12 multi-agent execution topologies with formal termination conditions, centralized message-passing semantics, and explicit aggregation strategies. Its highlighted novel patterns include grid refinement, parallel forests, and majority-based maker deliberation.

  • 12 execution topologies provide formal termination conditions, message-passing protocols, and aggregation strategies.The paper describes this as a comprehensive topology taxonomy for an open agent system.
  • All topologies share a context that delegates prompt injection, model routing, tool calling, and cost tracking while topology code orchestrates message flow.Tool calling is supported for up to 10 iterations.
  • Novel Topologies: Grid agents iteratively refine outputs using four-neighbor context and converge when no cell changes between rounds.The grid applies 2D local-update dynamics to LLM reasoning.
  • Novel Topologies: Forest topology runs multiple independent tree hierarchies in parallel, with leaves executing first and parents synthesizing child outputs.This provides ensemble-style parallel hierarchies without a single root bottleneck.
  • Novel Topologies: Maker topology iterates proposer solutions and voter evaluations until a configurable majority threshold, default 66%, is reached.Voters return structured approved-or-rejected feedback with explanatory text.

6 Three-Layer Model Routing

Qualixar OS routes model selection through three layers: a contextual bandit chooses among routing strategies, strategies select candidates, and a Bayesian POMDP evaluates hidden quality states against cost. The model-call layer supports 10 providers with resilience controls.

  • Three routing layers combine contextual bandit learning, five selection strategies, and Bayesian POMDP model selection.The architecture separates strategy choice from belief-state model selection.
  • Meta-Layer: The meta-layer uses an epsilon-greedy contextual bandit with persistent Q-tables to learn the best routing strategy for each task context.The Q-table persists to SQLite every 10 episodes, with state encoding based on task type, model count, and budget class.
  • Strategy Layer: The strategy layer offers Cascade, Cheapest, Quality, Balanced, and POMDP routing strategies.These strategies trade off success order, cost, quality, combined quality-cost weighting, and Bayesian selection.
  • Belief Layer: The belief layer maintains three hidden quality states and selects the model maximizing expected reward minus a cost penalty weighted at 30%.Belief floor and ceiling guards prevent degenerate distributions.
  • 10 model providers are supported with per-provider circuit breakers and exponential-backoff retries.Circuit breakers reset after 60 seconds following five failures; retries allow three attempts with 100ms–5s backoff and 25% jitter.

7 Quality Assurance Pipeline

Qualixar OS combines consensus judging with safeguards for metric integrity, distributional drift, behavioral contracts, catastrophic forgetting, and bounded self-improvement. Rejected outputs enter redesign, while safety and alignment constraints limit autonomous evolution.

  • Quality stack: The 8-module quality stack combines consensus judging with safeguards for metric integrity, distributional drift, self-improvement bounds, behavioral contracts, and catastrophic forgetting.The pipeline builds on AgentAssert and AgentAssay foundations.
  • Consensus judging: The 14-step judge pipeline uses configurable profiles, three consensus algorithms, drift checks, anti-fabrication checks, and persistent verdicts.Rejected outputs trigger the Forge redesign loop.
  • Judge integrity: Goodhart detection monitors cross-model entropy, calibration delta, score inflation, and diversity collapse, rotating judges at medium risk and rerunning rounds at high risk.Default thresholds are configurable and selected conservatively to minimize false positives.
  • Distributional stability: Jensen–Shannon drift monitoring compares each judge’s score distribution P_t with reference P_0 and intervenes when JSD exceeds Θ = 0.877.Drifting judges are suspended, and simultaneous drift by at least 50% of judges triggers recalibration.
  • Self-evolution trilemma: The Forge→Judge→RL loop addresses the alignment trilemma with bounded rewards, an external safety firewall, frozen judge profiles, and human escalation.The loop terminates after 5 iterations or 3× budget, and the design explicitly trades unbounded capability improvement for safety and alignment.
  • Behavioral contracts: Behavioral contracts enforce budget, response validity, safety, and quality invariants, aborting precondition failures and returning postcondition failures to redesign.The Forge Memory Guard preserves topology diversity by preventing eviction when fewer than two designs of a topology remain.

8 Four-Layer Attribution System

Qualixar OS uses four independent attribution layers to address distinct provenance threats, combining human-readable credits, tamper detection, format-resilient metadata, and temporal proof. Its local-first memory system separately organizes volatile, episodic, semantic, and procedural information.

  • Attribution layers: The four-layer attribution system combines visible credits, HMAC signing, steganographic watermarks, and blockchain timestamping.Each layer targets a different threat model.
  • Threat coverage: Visible credits are human-auditable, HMAC detects modification, steganography survives format transformation, and blockchain supplies temporal proof.
  • Memory system: SLM-Lite provides four local-first memory layers: volatile working memory, searchable episodic memory, trust-scored semantic memory, and procedural strategies.Promotion rules move entries upward based on access, session count, trust, and cross-validation.

9 Universal Compatibility

Qualixar OS broadens agent interoperability through the Claw Bridge and native MCP and A2A support. The bridge imports agents from four external formats while preserving relevant configuration and security information.

  • Claw Bridge: The Claw Bridge imports agents from OpenClaw, NemoClaw, DeerFlow, and GitAgent formats.The parsers convert external definitions into Qualixar OS-compatible representations, preserving NemoClaw security rules.
  • Claw Bridge: The four compatibility parsers have 2,604 lines of combined test coverage across 9 test files.
  • Protocols: Qualixar OS natively supports both MCP and A2A v0.3 for bidirectional tool use, agent discovery, task delegation, and status polling.It operates as both an MCP server and client, while A2A support includes client and server implementations.

10 Dashboard and Marketplace

The production dashboard combines persona-specific monitoring, visual workflow construction, marketplace functionality, and real-time telemetry. Evaluation reports strong results on a curated suite, alongside unresolved scope limitations and a nonsignificant preliminary self-improvement result.

  • Dashboard: The dashboard serves developers, technical leads, and executives through 24 interactive tabs spanning operations, intelligence, observability, data, and platform domains.Tabs beyond the core 10 are lazy-loaded, with WebSocket updates and REST polling fallback.
  • Workflow builder: The Builder offers drag-and-drop workflows with 9 node types and 7 structural validation checks, converting designs into Forge-compatible TeamDesign objects.
  • Marketplace: The marketplace contains 25 official entries, comprising 10 plugins with 35 tools and 15 skill templates defining 47 agents.Entries are scanned with SkillFortify techniques, reported at 100% precision with zero false positives.
  • Validation: The UAT resolved 22 defects across component, integration, persona, error-path, and security testing, achieving a 100/100 quality score; a subsequent audit found 36 additional findings.All Critical and High audit findings were resolved immediately, while Medium and Low items remained tracked.
  • Evaluation: 19 of 20 evaluation-suite answers achieved exact match and one achieved fuzzy match, with mean task duration 3,996 ms and mean cost $0.000039 per task.The suite covered 20 curated tasks across three difficulty levels using the full pipeline with GPT-5.4-mini.
  • Evaluation caveat: The evaluation excludes web browsing, file manipulation, and multi-tool orchestration, and standard benchmarks are deferred to a future revision.
  • Self-improvement evaluation: The preliminary self-improvement simulation found no statistically significant convergence, with p = 0.578 and scores declining from 0.564 to 0.519 across 3 iterations.The paper calls for full production-pipeline runs to validate the self-improvement claim.
  • Model discovery: Live discovery against Azure AI Foundry returned 236 available models and confirmed an end-to-end GPT-5.4-mini call.

12 Limitations and Future Work

The paper identifies limitations in evaluation validity, formal verification, deployment scale, adaptive topology selection, startup latency, monitoring windows, drift assumptions, and enterprise authentication. Future work targets standard benchmarks, distributed execution, stronger verification, improved selection, lower latency, and more robust monitoring and SSO.

  • Evaluation scope: 100% accuracy was achieved on a curated 20-task suite, but the tasks exclude web browsing, file manipulation, and multi-tool orchestration.Performance on established benchmarks may be substantially lower; SWE-Bench, HumanEval, and MINT evaluation is planned.
  • Verification and deployment: The current architecture runs on a single node with SQLite storage; multi-machine execution using PostgreSQL or CockroachDB is planned.This limits the present deployment architecture to single-node operation.
  • System improvements: Forge currently selects topologies through LLM reasoning and historical data, while reinforcement-learning-based selection is proposed for future improvement.The proposed reward signal would come from judge verdicts.
  • System improvements: Startup model discovery queries 10 provider APIs and adds 2–8 seconds of initialization latency depending on network conditions.Background refresh is proposed to reduce perceived latency.
  • Monitoring and enterprise integration: The Goodhart detector requires at least 50 evaluations for reliable entropy and calibration signals, potentially delaying detection in infrequent deployments.The detection window may be too large to catch early metric gaming.
  • Monitoring and enterprise integration: The JSD drift monitor assumes the reference distribution P0 represents a valid steady state, so anomalous initial calibration can bias it toward false negatives.The limitation concerns the validity of the initial reference distribution.
  • Verification and deployment: The topology execution semantics and behavioral contracts are implemented in code but not formally verified.A TLA+ or similar specification is identified as a strengthening direction.

13 Conclusion

Qualixar OS presents a universal application-layer runtime intended to bridge AI agent frameworks and production systems. It combines broad orchestration, compatibility, and user-facing infrastructure, with validation through 2,821 tests and 25 pre-seeded marketplace entries, while remaining source-available under the Elastic License 2.0.

  • Conclusion: Qualixar OS provides a universal runtime with 12 execution topologies, automatic team design, cost-aware routing, quality assurance, a dashboard, and a marketplace.The stated goal is to make multi-agent orchestration accessible to developers and non-technical users.
  • Conclusion: 2,821 tests and 25 pre-seeded marketplace entries support the paper’s claim that Qualixar OS is ready for community adoption and extension.The application-layer approach complements kernel-level systems such as AIOS.
  • Conclusion: Qualixar OS is available at https://github.com/qualixar/qualixar-os under the Elastic License 2.0.The paper identifies the repository and source-available licensing terms.
  • Conclusion: The paper positions Qualixar OS as unifying prior work on behavioral contracts, agent testing, skill security, and privacy-preserving memory.The cited prior contributions are described as components unified into a production operating system for agent orchestration.
Loading 2604.06392v1…