AlgoQX. Intelligence, engineered.

// we test agents, train open models with RLHF and RLVR, and build the verifiers that keep both honest.

  • RLHF
  • task
  • RLVR
  • feedback
  • verifiers
  • training
  • held-out tasks
  • evaluation
  • rollouts
  • inference
/ we test
agents and models
/ we train
RLHF / RLVR
/ we build
verifiers
/ we check
held-out tasks

/ what we do

Test it. Train it. Know it works.

Most work starts with evaluation: you cannot improve what you cannot measure honestly.

  • 01 / test your agent

    Agent and model evaluation

    Find out whether your agent or model actually does the job, on the tasks your users bring, not just on a demo.
    • Task suites built from your real workflows
    • Executable checks where they fit, rubric-based human review where they do not
    • Held-out sets kept apart from anything you tune on
    • A failure report with concrete examples, not a single score
    details
  • 02 / train it

    Post-training

    Improve an open model on your task with human feedback (RLHF), verifiable rewards (RLVR) or preference optimization, with evaluation built in from the start.
    • Feedback and data design for your task
    • Reward and verifier design, and audits for loopholes
    • Training runs on open-weight models
    • Before and after comparison on held-out tasks, with the conditions stated
    details
  • 03 / environments

    Learning environments and verifiers

    Executable tasks with controlled state and repeatable checks, for coding, SQL and bounded tool use.
    • Sandboxed environments your training and evaluation can share
    • Verifier reviews: what passes that should not, and why
    • Versioned tasks so results stay comparable
    details
  • 04 / collaborate

    Research collaboration

    Work with us on an open question in post-training or evaluation, from a shared problem statement to a write-up.
    • A scoped question and a plan to test it
    • Shared code and data where you allow it
    • Results written up with their limits
    details

/ who we work with

Built for teams that need to know.

  • product teams

    Teams shipping agents

    Your agent demos well, but you are not sure how it behaves on the long tail of real requests, or whether last week's change made it better.
    • Evaluation suites from your real traffic and workflows
    • Regression checks before each release
    • Failure analysis you can act on
    evaluation
  • startups

    Founders building on LLMs

    You need to know whether fine-tuning is worth it, which model to bet on, and how to prove quality to customers without a research team.
    • A quick, honest read on feasibility
    • Evaluation you can show to customers
    • Post-training when it is justified
    founders hub
  • research

    Research groups and labs

    You have a question about rewards, verifiers or evaluation and want a partner who cares about method and limitations as much as results.
    • Joint problem statements
    • Reproducible setups
    • Write-ups that state their conditions
    collaborate
  • enterprise

    Companies adapting open models

    You want an open-weight model to handle your domain on your infrastructure, with evidence that it improved and stays inside clear boundaries.
    • Post-training with RLHF, RLVR or preference methods
    • Held-out evaluation on your tasks
    • Controlled execution and clear resource limits
    post-training

/ the learning loop

The learning loop matters.

A model’s progress depends on the tasks it attempts, the feedback it receives and the way improvement is measured. We are interested in the connections between those pieces, and in the engineering that makes them practical to study.

  1. Task

    Define a problem and the conditions for success.

  2. Feedback

    Use human judgment or executable verification where each fits the task.

  3. Training

    Study how the chosen feedback changes model behavior.

  4. Evaluation

    Test beyond the training signal and examine the failures that remain.

explanatoryA diagram of how we think about the loop. Not a live system or a measured result.

/ focus

Where we focus.

/01

Human feedback

Preference data, reward signals and post-training approaches that connect model behavior to informed human judgment.

[ read the approach -> ] for human feedback

explanatory Pairwise preferences, and the disagreement between raters, become the signal.

/02

Verifiable rewards

Tasks and execution environments that let us check outcomes, inspect failures and study the limits of a verifier.

[ read the approach -> ] for verifiable rewards

explanatory A verifier is a component to question, not an oracle.

/03

Independent evaluation

Held-out tasks, counterexamples and reproducible comparisons that help distinguish useful improvement from a misleading score.

[ read the approach -> ] for independent evaluation

explanatory Held-out tasks answer a different question than the training reward.

/04

Systems behind learning

Inference, rollout execution and controlled infrastructure that make experiments easier to run and understand.

[ read the approach -> ] for systems behind learning

explanatory Rollouts run side by side, each inside explicit resource bounds.

/ try it

Reward is not the task.

A small, honest demonstration of why we test beyond the training signal. Pick a candidate, run the weak verifier, then run the held-out tests and compare.

task Return the largest number in a list.

pick a candidate
sort.js
function largest(xs) {  const s = [...xs].sort()  return s[s.length - 1]}
weak verifier, then held-out tests
  1. Weak verifier runs one test, [2, 5, 9]. Pass it and the reward is 1.0.
  2. Held-out tests run five inputs the candidate was never checked on.
  3. Compare the two. A high reward is a reason to look closer, not proof.

toy example Runs in your browser. Every result is computed from the code shown, not from a model.

/ how it works

From first message to hand-over.

  1. Conversation

    You describe the task, the model or agent, and what is not working. No confidential data needed yet.

  2. Scope

    We agree what success means, which data and access are involved, and what you receive at the end.

  3. Pilot

    A small first slice, usually an evaluation, so both sides see real results before going further.

  4. Build or train

    The main work, with regular check-ins and the evaluation running alongside it.

  5. Hand over

    Code, data, evaluation suites and a report you can rerun without us.

/ pricing

Scoped per project. Agreed up front. Most teams start with a fixed-scope evaluation sprint.

How pricing works

/ founders hub

Building on language models?

Shipping a product on a model or an agent, usually without a research team? These are the moments we see most.

  • 01

    The demo works. Production does not.

    Real users ask things the demo never covered. Without a task suite you find out from support tickets.
  • 02

    You changed the prompt. Is it better?

    Without a held-out evaluation, every change is a guess, and regressions ship quietly.
  • 03

    Fine-tune or not?

    Training costs time and compute. Sometimes it is the right call; sometimes evaluation and tooling get you further for less.
  • 04

    Customers ask for proof.

    Enterprise buyers want evidence of quality. A score with no stated conditions does not convince anyone.

/ how we work

Evidence before broad claims.

We want the assumptions behind an experiment to be visible: the task, model, feedback, evaluation conditions and limitations. Our engineering interests support that goal through explicit boundaries, observable execution and repeatable workflows.

what we want every write-up to make visible
  • task
  • model
  • feedback
  • evaluation conditions
  • limitations

/ open questions

What we want to find out.

A program can pass inadequate tests, and a query can match one example database without being semantically correct. We want to find those gaps before a training run learns to exploit them.

A rising reward curve says the optimized signal went up. Comparing it with held-out task success, under stated conditions, is how we want to judge whether training actually helped.

Disagreement can come from an unclear rubric, a genuinely hard case or a real difference in judgment. Each means something different for how the feedback is used in post-training.

Some tasks admit executable checks, such as running SQL against a database or tests against code. Others depend on informed judgment. A training workflow should keep that difference visible instead of treating subjective ratings as objective correctness.

The task, base model, feedback, evaluation conditions and limitations, written down where a reader can check them. Results without that context are hard to assess.

/ faq

Common questions.

What does AlgoQX do?
We help teams test and improve language models and agents: evaluation, post-training with human feedback (RLHF) and verifiable rewards (RLVR), and the verifiers and environments behind them.
Can you test an agent we already built?
Yes. That is the most common starting point: an evaluation on tasks that reflect how your users actually use it.
Can you train a model for our task?
Yes, on open-weight models, with evaluation built in so you can see whether training helped.
How is it priced?
Per project, agreed before work starts. Most teams begin with a fixed-scope evaluation sprint.

/ contact

Bring a concrete problem.

Working on model post-training, verification or evaluation? We are interested in conversations grounded in real tasks, practical constraints and questions that can be investigated.

Please share a short description first. Avoid sending confidential data in an initial enquiry.

What you are working on, in 20 to 4,000 characters