The stack, explained.

Numerata is a full stack for training and running your own private AI models: GPU compute, training, and inference, engineered end to end to run on infrastructure you control. You install it in your own environment, private cloud, on-premises, or fully air-gapped, and your team runs it. It is not a hosted API and there is nothing to subscribe to, so your code and data never reach a third party. Numerata will also build custom models and applications on the same stack as scoped, fixed-price projects.

Three products, one pipeline. Lupine handles compute: on-demand GPUs that scale to zero. P95 handles training: experiment tracking, sweeps, and cloud jobs. NinetyFive handles deployment: low-latency inference. Each is usable on its own, but they're built to work together as a single pipeline from raw compute to a deployed model.

No. Lupine's compute layer is entirely optional. Bring your own GPUs, whether existing cloud infrastructure or a fully air-gapped cluster, and plug them into the same P95 → NinetyFive pipeline. The value is in training and deployment, not in tying you to one source of GPUs.

A generic model was never trained on your proprietary code, data, or internal tools, so it structurally underperforms on anything domain-specific, and every request you send it hands your data to someone else's system. Numerata trains a model on your own data and deploys it inside your own environment, so the resulting edge stays yours.

No. You install Numerata inside your own environment and your team runs it. There is nothing hosted on our side holding your data, nothing billed per token, and no request that has to reach us for your models to work. You pay one yearly price, sized to what you actually run.

In one of three places, all of them yours: a private cloud account you own, your own on-premises hardware, or a fully air-gapped environment with no outbound network path at all. The software is the same in every case; what changes is how isolated the deployment is.

One yearly price, sized to what you actually run: environments, GPUs served, and seats. Nothing is charged per token, per API call, or per model, so your costs do not climb every time someone uses it. We quote after an architecture review, because sizing depends on your infrastructure.

You do. Models are trained on your data, on your infrastructure, and the weights are written to storage you control. Numerata holds no copy and there is no escrow arrangement. Your training data never reaches us, so it cannot be used to improve anything of ours.

Not by default. There is no standing access to your infrastructure, your data, or your models. Support access is granted by you per incident and revoked afterward. Telemetry is opt-in, and in an air-gapped install it is unavailable by construction rather than by policy.

The install itself takes days. Getting to a working deployment typically takes two to four weeks in a private cloud and four to eight weeks on-premises, with most of that time spent on architecture review, your security review, and training the first real model. Air-gapped timelines we work out case by case.

NVIDIA GPUs on CUDA 12.x or 13.x, a container runtime with GPU passthrough, HTTP/2 between client and GPU hosts, storage you control for datasets and checkpoints, and your existing SSO for identity. A single GPU host is enough to start. No outbound internet access is required.

Yes, as a scoped, fixed-price project on the same stack. We define one task with a measurable outcome, agree what we are building and what it costs before starting, build it inside your environment, and hand over the source, weights, training pipeline, and evaluation harness. It is not staff augmentation and not an ongoing retainer, and what we build keeps running without us.

Your models, weights, and data are yours and stay exactly where they already are, inside your environment. The software itself stops when the agreement does, so carrying on with the compute, training, and inference layers means renewing.

P95 is Numerata's agentic training platform: an experiment-tracking and orchestration layer that lets you, or your coding agent, log metrics, run hyperparameter sweeps, and submit training jobs to workers anywhere, from a single script to hundreds of parallel runs.

Install the Python SDK with pip install p95 or uv add p95, which also installs the pnf CLI. To use P95 as a Claude Code agent skill instead, run npx skills add numerataz/instrument-experiment.

Local mode needs no authentication: set a P95_LOGDIR environment variable and results are written to a local SQLite file. Cloud mode sends results to the hosted P95 API instead, authenticated via a P95_API_KEY or pnf cloud login, so runs are visible in a dashboard and shareable across a team.

Yes. Add it as an agent skill with npx skills add numerataz/instrument-experiment, and your agent can instrument your training code, launch sweeps, and report results back automatically, without you writing tracking code by hand.

A sweep is a defined hyperparameter search space, grid, random, or Bayesian, that P95 schedules and runs as a batch of trials automatically, streaming results back as each one completes.

Workers are registered servers that can execute training runs. Jobs are the scheduled training scripts submitted to those workers. Submit a job from the CLI or SDK, and any available worker, yours, or one running on Lupine, picks it up and runs it.

Lupine is Numerata's compute layer: on-demand GPUs that scale to zero, so you only pay for compute while a job is actually running, with no idle cost and no manual provisioning. “GPU over TCP” describes how it aggregates GPU capacity over the network rather than requiring you to own physical hardware.

Lupine is entirely optional. Air-gapped teams, or anyone with existing GPU infrastructure, can plug their own compute directly into the same P95 training and NinetyFive deployment pipeline.

NinetyFive is Numerata's deployment layer: an optimized inference engine built for low-latency serving, with a 50ms median latency for autocomplete-style completions.

Private AI infrastructure is any setup where a company's own data trains and runs its AI models inside an environment it controls, private cloud or on-premises, rather than sending that data to a third-party model provider's shared infrastructure.

Owning your model means the weights, the training data, and the resulting capability all belong to you, not a vendor. If your proprietary code or data trains someone else's shared model, the resulting edge accrues to them; training your own model keeps that value on your side.

Training from scratch builds a model's weights from nothing on your own data. Fine-tuning takes an existing pretrained model and adjusts it further on additional data. Fine-tuning is cheaper and faster, but the base model's original training data and biases still shape the result; training from scratch gives full control at a higher compute cost.

Air-gapped deployment means an AI system runs entirely on infrastructure that is physically or logically isolated from the public internet, so no training data, prompts, or outputs ever leave the environment. It is the strictest way to run an AI system, and it is what organizations choose when a code or data leak would be an existential problem rather than a compliance checkbox.

Private cloud still runs on shared infrastructure, yours or a provider's, isolated by account and network boundaries but reachable over the internet. Air-gapped removes network connectivity entirely. Private cloud is the more accessible default; air-gapping is reserved for teams that need or can justify the highest level of isolation.

Every time proprietary code, customer data, or internal documentation is sent to a third-party model, that data can be used to improve someone else's product, not just yours. For companies whose code or data is their actual competitive advantage, that's a structural risk, not just a compliance checkbox.

An agentic training platform is a training and experiment-tracking system built to be operated by an AI agent as well as a human: an agent can launch training runs, log metrics, run sweeps, and report results back, without a person writing the instrumentation code by hand.