TypeScript framework for fine-tuning open-weight models.

Write training jobs as code. Run them on managed GPUs. Ship custom-model endpoints from the same TypeScript that runs the rest of your product.

Alpha · Open source · No signup to try

Start for free Documentation

A TypeScript framework for custom model development.

The Framework exposes the model-improvement loop as TypeScript APIs: fine-tuning, deployment, evaluation, app integration. You compose them like any other piece of your product.

It is built for one user and one workflow: TypeScript-first product teams improving and shipping a custom open-weight model for their own application. The Framework is the product. Cloud and Studio just make it frictionless to use.

Framework

arkor

The TypeScript SDK and CLI. Where you write your training runs and deployments.

Read docs

Runtime

Arkor Cloud

Managed GPUs and hosted endpoints. The runtime your Framework code calls into.

Learn more

Dev UI

Arkor Studio

A local UI for jobs, metrics, and a playground. Drive it from your coding agent too.

Learn more

Framework primitives

Model improvement,
as TypeScript APIs.#

Arkor isn't config-as-code. If it were, YAML would be enough.

The framework: What you write: a TypeScript program that defines your fine-tuning and deployment.
The APIs: Functions you call inside it that expand what your code can do: createTrainer, onLog, onCheckpoint, infer, and more.

// src/arkor/index.ts (run with `arkor start`)
import { createArkor, createTrainer } from "arkor";

const trainer = createTrainer({
  name: "support-triage",
  model: "unsloth/gemma-4-E4B-it",
  dataset: {
    type: "huggingface",
    name: "your-org/support-tickets",
    split: "train",
  },
  datasetFormat: { type: "alpaca" },
  maxSteps: 200,
  lora: { r: 16, alpha: 16 },
  callbacks: {
    // Watch loss as it trains.
    onLog: ({ step, loss }) => {
      console.log(`step=${step} loss=${loss}`);
    },

    // Call the in-progress adapter from your own code.
    onCheckpoint: async ({ step, infer }) => {
      const res = await infer({
        messages: [{ role: "user", content: "Refund: order #4821" }],
        stream: false,
      });
      console.log(`ckpt ${step}:`, await res.text());
    },
  },
});

export const arkor = createArkor({ trainer });

Define

A training run is a TypeScript file that exports createTrainer(...).

Hook in

onLog, onCheckpoint, and onCompleted callbacks fire as the run progresses.

Test mid-training

onCheckpoint gives you infer() bound to the live adapter. Call it from your own code.

Run on managed GPUs

arkor start submits the run, streams events back, and stores every checkpoint.

Inspect in Studio

arkor dev opens a local UI for jobs, metrics, and a playground.

Iterate

Branch from a checkpoint, re-train, and ship the next version.

From npm install to a deployed model.

No infrastructure to provision. Three calls to the Framework, run from your own TypeScript.

Step 01

Define the workflow

Pick a base model and describe the task in TypeScript. Point at training data: your blob, your dataset, or a Hugging Face split.

Step 02

Train on managed GPUs

Arkor Cloud allocates GPUs, runs the fine-tune, streams metrics back into your callbacks, and stores every checkpoint.

Step 03

Deploy and use

Promote any checkpoint to a production endpoint. Call it from the same TypeScript that runs the rest of your product.

Because product teams build in TypeScript.

TypeScript is where you already build the rest of your product:

Product logicBackendsInternal toolsCI / deployIntegrations

The Framework lives in the same stack. Customizing a model becomes a normal piece of software.

Not a GUI. Not YAML.
Not a CLI. Not a Python wrapper.

Not a GUI fine-tuner

A dashboard makes one fine-tune easy. Code lets you version, compose, and automate the workflow you actually need to ship.

Not a YAML pipeline

Static config can describe a job. It can't branch, evaluate, or feed results back into your app. TypeScript can.

Not a CLI tool

CLIs run scripts. Frameworks build software. The Arkor Framework is the second one.

Not a Python wrapper

The Framework is designed for TypeScript developers from day one: APIs, types, docs, and defaults shaped around how product teams build, not how ML teams research.

See cookbook examples

Docs bundled with the package.

Reference docs ship inside the arkor npm package. Your coding agent reads them without fetching external context, so it can write training code and explain APIs right away.

Build models the way
you build products.

When a functionality is missing, you write it yourself.
That's what frameworks are.

Tasks where open-weight models
are already production-ready.

Routing, classification, extraction, normalization, redaction: backend tasks where the model reads meaning and returns a structured result. Open-weight models often match frontier quality here. When they don't, an Arkor fine-tune closes the gap, and a few lines of TypeScript ship it.

Semantic routing

Classify an incoming message, event, or request into the right queue, handler, or team. No keyword rules. The model reads intent.

Classification

Label content by type, topic, sentiment, or policy category. Works on free-form text, support tickets, user feedback, anything without a fixed schema.

Extraction

Pull specific fields out of unstructured text: names, dates, amounts, product identifiers. Returns data your backend can act on directly.

Normalization

Take free-form or multilingual input and resolve it to a canonical backend representation. Handles variation, language differences, and format inconsistency.

Redaction

Identify and suppress sensitive, regulated, or policy-violating content before it is stored, logged, or passed downstream. The model understands what to remove based on meaning, not just patterns.

What to know before you start.

Who is the Framework for?

TypeScript-first product teams building AI features without dedicated ML teams. Especially useful for teams that need custom model behavior but do not want to build ML infrastructure.

Do I need an ML team to use it?

No. The Framework is designed for product engineers. You write TypeScript, and Arkor handles the GPUs, fine-tuning infrastructure, model serving, and deployment underneath.

Why TypeScript instead of Python?

The Framework is not just config-as-code. If all we needed was static configuration, YAML would be enough. TypeScript lets developers build programmable model workflows: preparing data, running fine-tunes, testing checkpoints, deploying models, and integrating them into their apps.

Is the Framework just a fine-tuning tool?

No. Fine-tuning is one step. The Framework is built around the model improvement workflow: customize the model, test it, deploy it, and keep improving it from code.

How is this different from a GUI or YAML-based tool?

GUI tools are useful for fixed paths and one-off jobs. YAML is useful for static configuration. The Framework is for developers who want programmable, versioned, and extensible workflows in their codebase.

When should I use Arkor instead of OpenAI, Anthropic, prompting, or RAG?

Start with APIs, prompting, and RAG. Use Arkor when you need more control over model behavior, cost, latency, privacy, or deployment, and want to customize open-weight models for your own product.