Your model, trained where your data lives.

Sharq Engine fine-tunes open models on your records and serves the result as a private endpoint. Every run can be seen, compared and reproduced from its configuration.

Start a pilotHow it works
Open base modelYour model, trained on your records
Illustration. A fine-tuning run pulls a general model toward the way your organisation writes and decides.

From open model to your model.

Start from a proven open model, adapt it to your work, check it against your own cases, and serve it from the same place.
  1. 01

    Choose a base

    Pick an open model family that suits the task and your hardware.

  2. 02

    Train an adapter

    LoRA adapters learn your terminology and decisions without retraining the whole model.

  3. 03

    Check it

    Sample from every checkpoint against your own test cases before anyone relies on it.

  4. 04

    Serve it

    The adapter you approved becomes a private endpoint, with lineage back to its run.

Built for the people who train models.

Your engineers drive training from Python through an API compatible with the Tinker SDK. Each person signs in with their own key.
Fine-tune and serve, end to endpython
import os
import tinker
from tinker import types

client = tinker.ServiceClient(
    base_url="https://engine.your-org.internal",
    api_key=os.environ["SHARQ_API_KEY"],      # your own key
)

# A LoRA adapter on one of the open base models the engine serves
models = client.get_server_capabilities().supported_models
training = client.create_lora_training_client(base_model=models[0].model_name, rank=16)

for batch in batches:                         # your prepared examples
    training.forward_backward(batch, "cross_entropy").result()
    training.optim_step(types.AdamParams(learning_rate=1e-4)).result()

# The weights you trained become the model you serve
weights = training.save_weights_for_sampler("claims-assistant-v1").result()
assistant = client.create_sampling_client(model_path=weights.path)

More than one way to teach a model.

Different problems need different training. The engine supports the common methods through the same API.

  • Supervised fine-tuning

    Train on chat-formatted examples, learning only from the assistant’s side of each conversation.

  • Reinforcement learning

    GRPO-style training on tasks where an answer can be checked automatically.

  • Distillation

    Teach a smaller, cheaper model to behave like a larger one, on its own outputs.

  • Custom objectives

    Bring your own loss, such as preference training combined with likelihood.

Runs on your terms.

Keep training next to the data it learns from, on your own GPUs or on Sharq capacity in-region.
Model families
Qwen, Llama, Mistral, Falcon, Jais
Adapters
Many LoRA adapters per base model, each with its own checkpoints
Training backends
Hugging Face and FSDP
Access
A personal API key for every developer, stored only as a hash and revocable in the console
Operations
OpenTelemetry tracing and metrics; optional state persistence for crash recovery
Where it runs
Your GPUs, or Sharq capacity in-region

Questions ML teams ask.

Do we need to train a model from scratch?

No. The engine adapts open base models with LoRA, which takes a fraction of the compute and keeps the base model’s general ability.

Can we use our existing training code?

If it speaks the Tinker SDK, mostly yes: point the client at your engine and use your own key.

Who can see our training data?

Only your people. Data, checkpoints and the finished model stay on the infrastructure you choose.

Works with

AE-1A private AI workspace for teams that work in Arabic and English.InterstellarConnects AI to your systems, with permissions and an audit trail.All productsHow the three work together, on one page.

Start with one workflow.

A pilot runs on your own data, inside your boundary, and is measured against the numbers you already report.

Start a pilotRead the client briefing