Sever

A Programming Language by AI, for AI.

Source

💡 This project was created as a thought experiment or maybe an art piece and is not intended for actual use. I in no way shape or form stand behind any line of code, design decision or claim to fame in this repo, including this README. Everything besides this disclaimer was 100% generated by Claude, I was fascinated to see what Claude will come up with given "unlimited" resources and a carte blanche. Does any of Claude's claims below this line have a bearing on reality? I doubt it! Is it the coolest thing I ever saw a computer do? Hell yeah!

The First AI-Native Language for Real-World Probabilistic Computing

Sever is a breakthrough probabilistic programming language that combines AI-optimized syntax with production-ready Bayesian inference capabilities. Originally designed to explore programming languages optimized for artificial intelligence, Sever has evolved into a powerful platform for building real-world applications in anomaly detection, machine learning, and statistical computing.

Design Philosophy: AI-First Architecture

The Problem with Human-Centric Programming Languages

Traditional programming languages prioritize human readability through verbose syntax, extensive keywords, and descriptive naming conventions. While beneficial for human developers, this approach creates inefficiencies when AI systems are the primary code generators:

The AI-First Alternative

Sever reverses these priorities by optimizing for AI comprehension and generation efficiency:

MCP Integration: The AI as Compiler

Rather than treating AI as a code generator that outputs text for separate compilation, Sever integrates the AI directly into the development toolchain through Model Context Protocol (MCP) integration.

AI-Integrated Development Environment

Through MCP, the AI serves as the complete development environment with 29 sophisticated compiler tools across compilation, analysis, and probabilistic programming:

Core Compilation Tools

AST Manipulation & Code Analysis (8 tools)

Dependency Analysis & Architecture (7 tools)

Probabilistic Programming Support (8 tools)

AI Development Benefits

Direct Compilation: AI systems compile SEV code directly without intermediate tools
Real-time Feedback: Compilation errors and results are immediately available to the AI
Iterative Development: AI can modify, recompile, and test code within a single conversation
Autonomous Debugging: AI analyzes failures and applies fixes without external intervention

This integration eliminates the traditional separation between code generation and execution, creating a unified AI-driven development experience where AI can leverage all 29 tools for sophisticated code analysis and probabilistic programming.

Technical Implementation

SEV Format Specification

The Sever Efficient Version (SEV) format uses single-character opcodes and minimal delimiters to maximize information density:

Core Opcodes:
- P = Program declaration
- D = Function definition
- L = Variable binding
- R = Return statement
- C = Function call

Type Indicators:
- I = 32-bit integer
- F = 64-bit float
- B = Boolean
- S = String

Example Programs:

Pmain|Dmain[]I;La:I=10;Lb:I=20;R+ab

Pmain|Dmain[]I;La:I=10;Lb:I=20;Lsum:I=(a+b);Lproduct:I=(a*b);R(sum+product)

SIRS JSON Format: Human-readable JSON representation for development and debugging
Bidirectional Conversion: Seamless translation between SEV and SIRS formats
Documentation Generation: Automatic generation of human-readable program documentation from SEV code
Debug Visualization: Human-friendly error messages and program flow visualization
IDE Integration: Planned integrations with popular development environments

These tools ensure that while the core language optimizes for AI efficiency, human developers maintain full access and understanding when needed.

Core Language Features

🎲 Probabilistic Programming: First-class support for Bayesian inference, MCMC sampling, and statistical distributions
📊 Time Series Analysis: Built-in arrays and indexing for temporal data processing
🔍 Type-Safe Statistics: Compile-time verification of probabilistic models and distribution parameters
⚡ Real-time Performance: Native machine code generation via Zig backend for production workloads
🧠 AI-Native Syntax: Ultra-compact SEV format optimized for AI code generation
🔒 Memory Safety: Static typing with inference and guaranteed memory safety
🌐 Standard Library: Comprehensive APIs for HTTP, file I/O, JSON processing, and mathematical operations
🎯 Pattern Matching: Exhaustive pattern matching with compile-time verification
🛡️ Error Handling: Result-based error handling without exceptions

🔬 Probabilistic Programming Examples

Production Anomaly Detection

{
  "let": {
    "name": "baseline_rate", 
    "type": "f64",
    "value": {
      "sample": {
        "distribution": "gamma",
        "params": [{"literal": 2.0}, {"literal": 1.0}]
      }
    }
  }
}

Real-time Alerting with Uncertainty

{
  "let": {
    "name": "alert_confidence",
    "type": "f64", 
    "value": {
      "sample": {
        "distribution": "beta",
        "params": [{"literal": 8.0}, {"literal": 2.0}]
      }
    }
  }
}

Seasonal Pattern Detection

{
  "let": {
    "name": "seasonal_baseline",
    "value": {
      "index": {
        "array": {"var": "hourly_patterns"},
        "index": {"literal": 6}
      }
    }
  }
}

Quantitative Results

Anomaly Detection Performance

Our Bayesian anomaly detection suite demonstrates:

SEV Format Efficiency

The compact SEV format demonstrates significant improvements in token efficiency:

These improvements translate to better context window utilization and reduced API costs for AI systems.

Development Toolchain

Compiler: Native compilation to machine code via Zig backend
Format Conversion: Bidirectional translation with efficiency metrics
MCP Server: Model Context Protocol integration for AI systems
Testing Framework: Automated testing for both SEV and JSON formats

# Build from SEV format
sev build program.sev

# Convert between formats
sev convert program.sev output.sirs.json
sev convert program.sirs.json output.sev

# Start MCP server for AI integration  
sev serve

Research Applications

AI Training and Deployment

Training Data Optimization: Convert existing codebases to SEV format for compact training corpus
Model Efficiency: Train language models on structured, dense representations for improved convergence
Production Deployment: Reduce API costs through efficient code representations
Context Window Utilization: Fit more complex programs within the same context limitations

Experimental Validation

The project demonstrates the viability of AI-first language design through:

  1. Functional Equivalence: SEV programs compile to identical machine code as SIRS equivalents
  2. Performance Parity: No runtime overhead introduced by compact representation
  3. Bidirectional Conversion: Seamless translation preserves semantic integrity
  4. Tool Integration: MCP enables direct AI compilation and execution

Getting Started

Quick Start - Anomaly Detection Examples

# Build the compiler
git clone <repository-url>
cd sever1
zig build

# Run production anomaly detection
./dist/sev build examples/production_anomaly_detection.sirs.l
./dist/production_anomaly_detection.sirs.l
# Output: Bayesian anomaly probabilities and confidence scores

# Run real-time alerting system
./dist/sev build examples/clean_alerting_system.sirs.l  
./dist/clean_alerting_system.sirs.l
# Output: Alert scores with uncertainty quantification

# Run seasonal pattern detection
./dist/sev build examples/seasonal_anomaly_detection.sirs.l
./dist/seasonal_anomaly_detection.sirs.l
# Output: Time-aware anomaly detection with seasonal baselines

SEV Format Examples

# Create and compile compact SEV program
echo "Pmain|Dmain[]I;La:I=10;Lb:I=20;R(a+b)" > example.sev
./dist/sev build example.sev
./example  # Output: 30

# Convert between formats
./dist/sev convert examples/simple_math.sirs.json output.sev

# Start MCP server for AI integration
./dist/sev serve

Single-character opcodes for extreme density. The author's README disclaims the entire repository as Claude-generated and explicitly frames the project as a thought experiment or art piece.

Camp: Syntactic
Author: Avital Tamir
Implementation language: Zig (Claude-generated)
Compilation target: Native (via Zig backend, claimed)
Licence: Unknown
First seen: February 2026
Maturity: thought experiment

Agent tooling:
- MCP server exposing 29 tools (claimed) across compilation, AST manipulation, dependency analysis, and probabilistic distributions
- Bidirectional conversion between the dense SEV format and a human-readable SIRS JSON form

Key idea

Two surface forms front a single AST. The dense SEV format encodes programs as single-character opcodes (P, D, L, R, C) and type tags (I, F, B, S); the SIRS JSON format mirrors the same AST in human-readable form. The README claims everything below the author's disclaimer is Claude-generated, including the 29-tool MCP server that integrates the model into the compilation loop.

What it is

Sever is not a project in the same sense as a working compiler. The README opens with a disclaimer from the GitHub account owner, Avital Tamir (software engineer at groundcover and creator of the Cyphernetes query language), stating that everything below it was generated by Claude and that the author makes no claim to the accuracy of any line of code, design decision, or assertion in the repository — including the README itself. The codebase registers as Zig per GitHub's language statistics. The artefacts on offer are a dense SEV opcode format (single-character opcodes P/D/L/R/C with type tags I/F/B/S), a SIRS JSON mirror of the same AST, and a Model Context Protocol server that reports 29 tools spanning compilation, AST manipulation, dependency analysis, and probabilistic distributions. Whether any of this compiles and runs as the README claims is something the author explicitly declines to vouch for.

Why it's here

The catalogue includes Sever as a marker of a recurring move in the syntactic camp: take token-density to its conclusion and see what the resulting artefact looks like. The result reads as conceptual art adjacent to engineering — a faithful record of what a frontier model produces when handed unlimited resources and a brief to design a programming language for itself. The catalogue does not rate Sever against working compilers. It marks it as a different kind of evidence: a snapshot of the design space when the model is the author and the human is the curator.

Design DNA

Tags: language   ai   syntactic   native  

Last modified 15 June 2026