Skip to main content

Wrekenfile

A unified, LLM-ready specification to define APIs & SDKs

Wrekenfile lets you describe API contracts and SDK behavior in a single, structured specification - designed to be deterministic, and safe for LLM-driven tooling. Build APIs, generate SDKs, and power AI workflows from one source of truth.

Try NowGitLab
Read the specification
wrekenfile.yaml
VERSION: "2.0.2"
TITLE: "E-commerce API"
DESCRIPTION: "Complete e-commerce API with payments"

HTTP:
  base_url: "https://api.store.com"

METHODS:
  create_payment:
    DESCRIPTION: "Process a payment for an order"
    HTTP:
      METHOD: "POST"
      ENDPOINT: "/payments"
      STATUS: "201"
    INPUTS:
      order_id:
        TYPE: "STRING"
        LOCATION: "body"
        REQUIRED: true
      amount:
        TYPE: "NUMBER"
        LOCATION: "body"
        REQUIRED: true
      currency:
        TYPE: "STRING"
        LOCATION: "body"
        REQUIRED: true
    RETURNS:
      TYPE: "STRUCT(Payment)"

  get_order:
    DESCRIPTION: "Retrieve order details"
    HTTP:
      METHOD: "GET"
      ENDPOINT: "/orders/:id"
      STATUS: "200"
    INPUTS:
      id:
        TYPE: "STRING"
        LOCATION: "path"
        REQUIRED: true
    RETURNS:
      TYPE: "STRUCT(Order)"

STRUCTS:
  Payment:
    DESCRIPTION: "Payment transaction record"
    id:
      TYPE: "STRING"
      REQUIRED: true
    status:
      TYPE: "STRING"
      REQUIRED: true
    amount:
      TYPE: "NUMBER"
      REQUIRED: true
      
  Order:
    DESCRIPTION: "Order information"
    id:
      TYPE: "STRING"
      REQUIRED: true
    total:
      TYPE: "NUMBER"
      REQUIRED: true
    items:
      TYPE: '"array[STRUCT(Item)]"'
      REQUIRED: true
THE PROBLEM

Why existing tools fall short

Specs describe shape, not behavior

Most API specs define endpoints and schemas, but not how clients should behave. Pagination, retries, auth flows, and error semantics live outside the spec.

SDKs encode knowledge that specs can't

Critical decisions about naming, defaults, orchestration, and response handling are encoded in SDKs - not in API specifications.

Machines can't reliably reason about today's specs

Ambiguity and implicit behavior make existing specs unreliable inputs for automation, code generation, and LLM-driven tooling.

THE SOLUTION

Meet the Wreken specification

Wrekenfile is a semantic specification that captures API structure and SDK intent in a single, machine-readable format.

Explicit semantics

Wrekenfile defines not just endpoints and schemas, but client behavior, execution semantics, and constraints — explicitly and unambiguously.

API + SDK unified

The same specification describes transport-level APIs and the SDK methods that consume them, keeping both in sync by design.

Deterministic structure

The spec is strict, structured, and free of implicit behavior, making it safe for generators, automation, and LLM-driven tooling.

Language neutral

Wrekenfile expresses intent independently of programming languages, enabling consistent APIs and SDKs across ecosystems.

WHAT THE SPECIFICATION ENABLES

One specification, many uses

HTTP / REST APIs

Derive API implementations with routing, request/response handling, validation, and error contracts from the specification.

SDKs in multiple languages

Derive SDKs with consistent method signatures, behavior, and ergonomics across TypeScript, Python, Go, Rust, and more.

Schema & data contracts

Define strongly typed data models, request/response schemas, and validation logic shared across APIs and SDKs.

Documentation artifacts

Derive API docs, SDK references, usage examples, and interactive documentation from the same source of truth.

HOW IT WORKS

From existing specs to LLM-ready knowledge

01

Convert specs

Start with OpenAPI files, Postman collections, or existing SDKs. Convert them to a Wrekenfile using the converters.

02

Structure intent

Break the Wrekenfile into method-level semantic units that explicitly capture behavior, inputs, outputs, and constraints.

03

Store knowledge

Persist these method-level specs in any database or vector store of your choice.

04

Query safely

Provide exact method context to an LLM to generate code, explanations, or derived specs sans hallucination

Specification status

Open Source
Community driven
Business-backed development

Wrekenfile is an open-source specification under active development. The project is shaped by real-world SDK and API design challenges, and community feedback plays a key role in its evolution.