Deterministic
Verification Engine
for ML Execution

Glyphser provides a reproducible execution framework that produces verifiable artifacts for machine learning runs. Instead of relying on informal logs, Glyphser records structured execution traces, checkpoints, and certificates.

The Problem with
ML Reproducibility

Machine learning systems often suffer from weak reproducibility. Glyphser addresses this with cryptographically bound artifacts that allow independent verification.

Non-Deterministic Results

Training runs cannot be reproduced exactly due to floating-point differences, random initialization, and environment variations.

Informal Logs

Logs are often incomplete, unstructured, or lost, making it impossible to verify what actually happened during execution.

Trust Over Evidence

Verification currently requires trusting the reporting party rather than providing cryptographic proof of execution integrity.

How Glyphser Works

Glyphser introduces several core concepts that enable deterministic, verifiable ML execution.

Run Manifest

A formal declaration defining operators, parameters, inputs, and environment constraints. Acts as the contract for execution.

Deterministic Execution

Stable serialization and hashing ensure identical runs produce identical commitments. No more "works on my machine."

Execution Artifacts

Structured traces, checkpoints, and certificates that encode the complete history and state of the execution.

Independent Verification

Third parties can replay or inspect artifacts to confirm the run matches its declaration. No trust required.

Runs
Evidence

High-Level System
Design

Glyphser operates as a deterministic execution and verification layer with several key components.

Manifest
Operator Registry
Runtime
Artifacts
Verification

Run Manifest

Formal declaration of operators, parameters, and environment constraints.

Operator Registry

Manages available operators and their deterministic implementations.

Serialization Layer

Canonical CBOR encoding with strict ordering and explicit replay tokens.

Verification Tools

Independent tools to replay and verify execution artifacts.

Where Glyphser
Excels

Glyphser is designed for environments where reproducibility and verification are critical.

Reproducible Research

Enable truly reproducible ML research with cryptographic verification of experimental results.

Regulated AI Workflows

Meet compliance requirements with audit-ready ML pipelines and verifiable outputs.

Audit-Ready Pipelines

Generate certificates and traces that can be independently verified for any audit.

Experiment Tracking

Replace informal logging with deterministic, inspectable experiment records.

CI Reproducibility

Validate that CI runs produce consistent results across any environment.

Incident Forensics

Reconstruct exactly what happened in production runs with verifiable artifacts and deterministic replay.

Certification-ready evidence

Bundle artifacts, attestations, and pass/fail gates into a shareable certificate for audits and regulated workflows.

Certification Builder

Simple YAML Manifest

Define your execution with a declarative YAML manifest. Glyphser handles the rest.

manifest.yaml
run:
  name: "example_run"

operators:
  - id: "preprocess"
    type: "preprocessing_step"

  - id: "train"
    type: "training_step"
    params:
      epochs: 100
      lr: "0.001"

environment:
  python: ">=3.9"
  deterministic: true

Install & Run

Get Glyphser up and running in minutes.

Install from Source

git clone https://github.com/Astrocytech/Glyphser.git
cd Glyphser
pip install -e .

Run with FastAPI

pip install -e ".[api]"
glyphser-api
# Default: 127.0.0.1:8000

React Frontend

cd apps/web
npm install
npm run dev
# Open: http://localhost:5173

Ready to verify your ML?

Start with Glyphser today and make your machine learning runs deterministic and verifiable.

Get in touch

Have questions about Glyphser? Want to contribute? We'd love to hear from you.