Skip to main content

ACOS Certification for Hardware Manufacturers

The ACOS-ISA v1.0 (Adaptive Conformance Operating Standard - Instruction Set Architecture) certification program enables quantum hardware manufacturers to integrate their backends with the SoftQCOS ecosystem.

Patent Protected

ACOS is protected under patent registration FR2513440. All rights reserved.

Why Get Certified?​

Business Benefits​

BenefitDescription
Market AccessAccess to QCOS customer base worldwide
CredibilityThird-party validation of your quantum backend
VisibilityListed in the QCOS Compatible Registry
MarketingUse official certification badges
IntegrationSeamless integration with QCOS SDK and CLI

Technical Benefits​

BenefitDescription
StandardizationConsistent API for customers
InteroperabilityWorks with any QCOS-compatible tool
MonitoringBuilt-in telemetry and observability
EvidenceCryptographic proof of execution
FinOpsCost tracking and budget management

Certification Tiers​

🏅 QCOS Compatible (ISA)​

Basic certification for ISA-level conformance.

Required Tests: ACOS-ISA-001 through ACOS-ISA-010
Validity: 90 days
Recertification: On driver/capability changes

Capabilities:

  • ✅ Gate-level circuit execution
  • ✅ Native gate transpilation
  • ✅ Batch execution
  • ✅ Job cancellation
  • ✅ Basic telemetry

🥇 Pulse Certified​

Advanced certification for pulse-level control (requires ISA certification).

Prerequisite: QCOS Compatible (ISA)
Additional Tests: ACOS-PULSE-001 through ACOS-PULSE-005
Validity: 90 days

Additional Capabilities:

  • ✅ Pulse-level circuit submission
  • ✅ Custom gate calibrations
  • ✅ Real-time pulse shaping
  • ✅ Advanced error mitigation

🏆 QCOS Pro​

Enterprise certification with SLA guarantees and priority support.

Prerequisite: Pulse Certified
Additional Requirements: SLA agreement, 99.5% uptime
Validity: 365 days

Additional Capabilities:

  • ✅ Priority queue access
  • ✅ Dedicated support channel
  • ✅ Custom integrations
  • ✅ Enterprise telemetry

ACOS-ISA v1.0 Test Suite​

The certification process validates your backend against 10 mandatory tests:

ACOS-ISA-001: Capabilities Contract​

Validates that your backend returns a conforming capabilities.json.

Required Fields:

{
  "backend": {
    "id": "your-backend-id",
    "provider": "your-company"
  },
  "execution_modes": {
    "isa_mode": {
      "enabled": true
    }
  },
  "limits": {
    "max_shots": 10000,
    "max_qubits_per_circuit": 100,
    "max_circuit_depth": 1000
  },
  "gates": {
    "native_gates": ["rx", "ry", "rz", "cx", "cz"]
  },
  "operations": {
    "batch_execution": true,
    "job_cancellation": true
  },
  "telemetry": {
    "provides_execution_time": true
  }
}

ACOS-ISA-002: Native Gate Transpilation​

Verifies correct transpilation of arbitrary circuits to native gate set.

ACOS-ISA-003: Bell State Execution​

Tests entanglement generation with statistically valid results.

Pass Criteria:

  • Bell state fidelity > 0.85 (simulator) or > 0.70 (hardware)
  • Correct correlation between qubits

ACOS-ISA-004: GHZ Correlation​

Tests multi-qubit entanglement with GHZ state preparation.

Pass Criteria:

  • GHZ state fidelity appropriate for qubit count
  • All-zeros and all-ones correlations preserved

ACOS-ISA-005: Batch Execution​

Validates correct handling of multiple circuits in a single request.

Pass Criteria:

  • All circuits executed
  • Results correctly associated with each circuit
  • Execution time within limits

ACOS-ISA-006: Limits Enforcement​

Tests enforcement of declared resource limits.

Pass Criteria:

  • Requests exceeding limits are rejected
  • Error messages are informative
  • No silent failures

ACOS-ISA-007: Job Cancellation​

Validates job cancellation functionality.

Pass Criteria:

  • Running jobs can be cancelled
  • Cancelled jobs stop execution
  • Resources are released

ACOS-ISA-008: Error Taxonomy​

Tests conformance to standard error classification.

Pass Criteria:

  • Errors include standard error codes
  • Error messages are actionable
  • Error categories are correct

ACOS-ISA-009: Telemetry Minimum Fields​

Validates required telemetry in job responses.

Required Fields:

{
  "telemetry": {
    "queue_time_ms": 150,
    "compile_time_ms": 45,
    "execution_time_ms": 1200,
    "total_time_ms": 1395
  }
}

ACOS-ISA-010: Evidence Bundle Generation​

Tests cryptographic evidence bundle creation.

Pass Criteria:

  • Evidence bundle is generated
  • Signatures are valid
  • Hashes are correct
  • Bundle is tamper-evident

Certification Process​

Step 1: Register as Vendor​

Create a vendor account at portal.softquantus.com:

  1. Sign up with company email
  2. Complete vendor profile
  3. Sign ACOS License Agreement
  4. Receive unique vendor_id

Step 2: Implement BackendProtocol​

Your backend must implement the BackendProtocol interface:

from typing import Dict, Any, List

class YourBackend:
    """Your quantum backend implementation."""

    def get_capabilities(self) -> Dict[str, Any]:
        """Return capabilities.json structure."""
        return {
            "backend": {
                "id": "your-backend-id",
                "provider": "your-company",
            },
            "execution_modes": {
                "isa_mode": {"enabled": True}
            },
            # ... full capabilities
        }

    def transpile_to_native(self, circuit: Any) -> Any:
        """Transpile circuit to native ISA gates."""
        # Your transpilation logic
        return native_circuit

    def execute(self, circuit: Any, shots: int) -> Dict[str, Any]:
        """Execute a circuit and return results."""
        return {
            "job_id": "job-123",
            "status": "completed",
            "counts": {"00": 512, "11": 512},
            "telemetry": {
                "queue_time_ms": 100,
                "compile_time_ms": 50,
                "execution_time_ms": 1000,
                "total_time_ms": 1150,
            }
        }

    def execute_batch(
        self, circuits: List[Any], shots: int
    ) -> List[Dict[str, Any]]:
        """Execute a batch of circuits."""
        return [self.execute(c, shots) for c in circuits]

    def cancel_job(self, job_id: str) -> bool:
        """Cancel a running job."""
        # Your cancellation logic
        return True

    def get_job_status(self, job_id: str) -> Dict[str, Any]:
        """Get job status and metadata."""
        return {
            "job_id": job_id,
            "status": "completed",
            # ... full status
        }

Step 3: Run Conformance Tests​

Use the ACOS CLI to run the test suite:

# Install CLI
pip install softqcos-cli

# Run conformance tests
softqcos acos run \
    --backend your-backend-id \
    --config your-backend-config.yaml \
    --output report.json

# View results
softqcos acos report --input report.json

Step 4: Generate Evidence Bundle​

Create a cryptographically signed evidence bundle:

# Generate evidence bundle
softqcos acos evidence create \
    --report report.json \
    --output evidence-bundle.json \
    --sign

Step 5: Submit for Review​

Upload the evidence bundle through the certification portal:

  1. Go to portal.softquantus.com/certification
  2. Upload evidence-bundle.json
  3. Provide additional documentation
  4. Submit for review

Step 6: Receive Certificate​

After successful review:

  1. Receive certification certificate
  2. Download official badges
  3. Get listed in public registry
  4. Receive cert_id for verification

Vendor Pack​

We provide a complete onboarding toolkit:

# Generate vendor pack
softqcos acos vendor-pack create \
    --vendor-id your-vendor-id \
    --output ./vendor-pack

Contents:

vendor-pack/
├── README.md                  # Quick start guide
├── capabilities-template.json # Capabilities template
├── checklist.md               # Onboarding checklist
├── examples/
│   ├── backend_stub.py        # Backend implementation example
│   └── test_runner.py         # Local test runner
├── schemas/
│   └── capabilities.schema.json
└── badges/
    ├── compatible-isa.svg
    ├── pulse-certified.svg
    └── pro.svg

Certification Badges​

After certification, use official badges in your marketing:

QCOS Compatible (ISA)​

<img
  src="https://registry.softquantus.com/badges/compatible-isa.svg"
  alt="QCOS Compatible"
/>
<a href="https://registry.softquantus.com/verify/CERT-2026-001234">
  <img
    src="https://registry.softquantus.com/badges/compatible-isa-verified.svg"
    alt="QCOS Compatible - Verified"
  />
</a>

Recertification​

Certification requires renewal under these conditions:

TriggerAction Required
90-day expiryRe-run full test suite
Driver updateRe-run affected tests
Capability changeUpdate capabilities.json + test
API version changeFull recertification
# Check certification status
softqcos acos status --backend your-backend-id

# Renew certification
softqcos acos renew \
    --backend your-backend-id \
    --evidence-bundle evidence-bundle.json

Support​

Documentation​

Contact​

Community​