Agentic-first Model Training Platform

Bud Model Foundry

Build, fine-tune, post-train and agentic-train open models on your own infrastructure — with research-grade control, production-grade operations, and zero hardware tax.

Bud Model Foundry at a glance

Designed for sovereign deployment. Built for agentic-AI workloads. Engineered to perform on commodity hardware.

Supported open models

Inter-node bandwidth reduction

Platform REST APIs

GPU vendors supported

Training stages

Quantization formats

Built-in graders

Data operators

What is Bud Model Foundry

A sovereign-grade, multi-vendor, agentic-first training platform built for the enterprise reality.

Five non-negotiable design commitments — each a structural answer to a specific failure of the existing market, built into the foundation, not bolted on.

Sovereign by deployment

One-command on-prem install. No outbound dependency. Air-gapped as a first-class pattern. AES-256-GCM encryption at rest and a full audit trail across every call.

Multi-vendor by design

NVIDIA, AMD, Qualcomm and Intel. PCIe cards as first-class hardware. Mixed fleets in a single job. Bud DiLoCo trains over commodity Ethernet — no InfiniBand.

Agentic-first by purpose

Three RL modes, four environments, ten graders, five recipes — and a teaching-metaphor API that opens agentic training to subject-matter experts, not just researchers.

End-to-end by scope

Data prep through 260+ operators, six training stages, step-level control, the RL engine, serving, registry with lineage, and drift detection — one auth surface, one audit log.

Production-grade from day one

bcrypt-hashed API keys, OAuth/OIDC, model-level RBAC, atomic quotas, four rate-limiting algorithms, structured audit, graceful shutdown, Prometheus metrics.

Run on the GPUs you actually own. Train inside the perimeter your governance team requires. Build agentic systems with research-grade primitives — because all of it is in the box.

Full-spectrum training core, as a single platform.

Most platforms cover a slice. Bud Model Foundry covers the whole spectrum — all configurable, all validated.

Training stages

Continued pre-trainingSupervised fine-tuningReward modellingPPO — online RLHFDPO — offline preferenceKTO — asymmetric

Fine-tuning methods

Full FTLoRAQLoRADoRALoRA+OFTLayer freeze

Quantization formats

BNBGPTQAWQAQLMQuantoEETQHQQMXFP4FP8

Optimizer families

AdamWAdamW 8-bitLionSophiaAdaLoMoAdEMAMixGaLoreApolloBAdamAdafactor

Explore the training core in depth

The product surface

What your team actually works in.

Research-grade depth underneath, an operator-friendly surface on top — the same platform, one auth, one audit log.

Training

Launch any training job — without the guesswork.

Configure full fine-tuning down to QLoRA from one surface, with progressive disclosure for every skill level.

Six stages, seven methods, one form

Continued pre-training through preference optimization, all configurable.

Know the cost before you commit

Pre-flight memory, time and cost estimates per GPU — no OOM-then-restart.

Watch it train, live

Loss, learning rate and GPU metrics stream in over WebSocket.

foundry.bud.studio/training/new

Foundry · Training

RL training

Train agents against your own tools and rewards.

The full agentic-RL substrate as a first-class workflow — not a generic toolkit you have to assemble.

Three RL modes, four environments

Sync, async and streaming rollouts against real or simulated tools.

Ten graders, including tool-call

Partial-credit rewards that teach an agent to refine, not just pass or fail.

Five recipes to start from

Reasoning, Code, Support, Tool Use and Safety — with sensible defaults.

foundry.bud.studio/rl-training

Foundry · RL

Data pipelines

Curate training data with a visual pipeline.

Quality is bounded by data quality — so the pipeline is a first-class subsystem, not a preliminary step.

260+ operators, drag-and-drop DAG

Filter, dedupe, transform and balance across text, image, audio, video and code.

Distributed by default

Local, multiprocess or Ray cluster — the same pipeline scales to TB-scale corpora.

Reproducible & audited

Every dataset version is rebuildable from its source and processing config.

foundry.bud.studio/datasets/pipelines

Foundry · Data

Bud DiLoCo · the capability that breaks the SXM dependency

Train across nodes over commodity Ethernet — not InfiniBand.

Standard distributed training syncs gradients every step, demanding 100+ Gbit/s InfiniBand. Bud DiLoCo runs an inner AdamW loop per node, then syncs a pseudo-gradient through an outer Nesterov optimizer — cutting inter-node bandwidth by orders of magnitude.

Conventional · sync every step

GPU node

Gradients exchanged at every optimization step — requires InfiniBand > 100 Gbit/s, locking you to SXM HGX hardware.

Bud DiLoCo · sync every ~100 steps

island

A single pseudo-gradient summarises hundreds of micro-updates — runs fine over standard Ethernet < 100 Mbit/s.

100×

minimum reduction (conservative)

500×

typical multi-node case

4,800×

with int4 + adapter sync (roadmap)

<100

Mbit/s sufficient bandwidth

01 · Inner loop

Each island runs standard AdamW on its local shard for ~100 steps. No inter-node traffic.

02 · Pseudo-gradient

Each island computes the delta between current and starting parameters.

03 · Outer loop

Pseudo-gradients sync over Gloo/Ethernet via an outer Nesterov SGD optimizer.

04 · Repeat

Same total step count; inter-node bandwidth reduced 100×–500×.

Bud Tinker · step-level training control

Control the training loop one operation at a time.

Most platforms only let you submit-and-wait. Bud Tinker exposes the eight primitive operations of a training loop as REST endpoints and SDK methods — each call preserving full training state with bit-exact reproducibility, wrapped in the same auth, audit and encryption as a production pipeline.

Custom RL algorithmsStep-level debuggingMulti-turn agentic RLBit-identical pause / resume

Bud Tinker

8 primitives

forward backward step zero-grad generate logprobs save load

Agentic RL & Simplified ART

Train agents with reinforcement learning — built into the platform.

Reinforcement learning is the dominant technique for agentic systems. Bud Model Foundry ships the entire substrate — not a generic RL toolkit.

RL training modes

built-in environments

loss functions

graders

pre-built recipes

teaching-metaphor API

Simplified ART

Agentic training as a teaching metaphor — for subject-matter experts, not just researchers.

Student

The model + skill module that gets trained

→

Coach

Runs eval cycles, trains weaknesses, auto-stops on plateau

→

Curriculum

The training set, from JSONL, CSV, HF or inline

→

Grader

Converts each rollout into a reward signal

→

Improvement

Compiles to a full RL run — capability ceiling unchanged

Explore the agentic-RL stack

The continuous-improvement flywheel

Models that keep improving after they ship.

Most AI initiatives stall because training and deployment are separate concerns. Bud closes the loop — inside the perimeter, with full audit trail at every step.

Dataset

Pipeline

Training

Checkpoint

Registry

Inference

Drift

Feedback

Bud Ecosystem

Models that compound

Developer experience

Five interfaces to the same platform — use whichever fits your team.

From researchers writing Python, to operators in the dashboard, to autonomous agents calling Model Foundry as MCP tools.

Python SDK

Sync + async, fluent builders, pre-flight estimates

REST API

350+ endpoints, OpenAPI, webhooks, idempotency

Web dashboard

35-page GUI, progressive disclosure, 11 chart types

Server TUI

Runs in any SSH session, air-gapped friendly

MCP server

Training as tools any LLM agent can call

A job submitted through the SDK can be paused from the dashboard, monitored from the TUI, and registered by an MCP-driven agent — all on the same job, all with the same lineage.

Architecture

Seven layers, each independently scalable.

Engineered for graceful degradation — core training and RL run on pure PyTorch and stay available even when optional high-level components are not.

Consumption

SDK, 350+ REST endpoints, 35-page dashboard, server TUI, OpenAI-compatible clients, MCP server.

Gateway

FastAPI with ordered middleware: request-ID, idempotency, size limits, rate limiting, auth, RBAC, CORS.

Execution

Celery workers (training, pipelines, imports) and in-process pipelines (Tinker, RL, fast inference).

Core engines

Bud Tinker, Training Pipelines, Bud RL Engine, Simplified ART, DiLoCo Orchestrator — all pure PyTorch.

Platform subsystems

Data pipeline, inference engine, model registry, drift detection, feedback collector.

Cross-cutting services

Auth, AES-256-GCM encryption, audit logging, cost tracking, notifications, idempotency.

Persistence

PostgreSQL for state + registry, Redis for cache/queues, MinIO/S3 for artifacts.

Deployment & sovereignty

One command. Inside your perimeter.

No hosted dependency. No required outbound connection. No telemetry leaving your environment. bud-install detects the host, installs the correct PyTorch wheel, starts every service, and verifies the install.

Single-node Docker ComposePilot & single-team production — deploy in 30 minutes

Kubernetes via HelmMulti-team production with horizontal scaling

Air-gapped on-premiseMaximum sovereignty, defence & classified workloads

bud-install

[01/07] Detecting host environment

OS: Ubuntu 22.04 · GPU: NVIDIA H100 PCIe 80GB × 4

[02/07] Installing PyTorch with CUDA 12.6 wheel

[03/07] Installing platform components

[04/07] Starting services · PostgreSQL · Redis · MinIO

[05/07] Running database migrations

[06/07] Verifying installation

✓ All services healthy · API on :8000 · Dashboard on :3000

✓ AES-256-GCM at rest ✓ Full audit trail ✓ OAuth / OIDC SSO ✓ Model-level RBAC ✓ Atomic quotas ✓ Key rotation (90-day TTL) ✓ Customer-controlled storage

How it compares

The same capability surface — on your hardware, inside your perimeter.

Capability	Hosted services	Hyperscaler	DIY open-source	Bud Model Foundry
Sovereign / air-gapped	Fails	Partial	Pass	Pass
Predictable cost at scale	Per-token	GPU-hour + egress	CapEx + ops	License-based
Multi-vendor GPU support	Limited	Catalogue only	DIY	NVIDIA·AMD·Qualcomm·Intel
Agentic-RL stack built-in	No	Partial	DIY	Full stack
Commodity-Ethernet training	No	No	Rare	Bud DiLoCo
Time to first production job	Days	Weeks	6–12 months	30 min – days
Lifecycle scope (registry · drift)	Training only	Limited	DIY each	End-to-end

Use cases by industry

Where Bud Model Foundry creates value.

The capability surface translates into concrete value across regulated and sovereignty-bound sectors.

Banking & insurance

Compliance copilots with refusal training
Audit-grade fraud-detection reasoning
Loan-origination assistants on internal policy

Healthcare & life sciences

Clinical reasoning on de-identified notes
Vision-language radiology assistants
Federated training across hospital consortia

Defence & government

Intelligence-analysis agents, fully air-gapped
Citizen-service multilingual agents
Cyber-defence reasoning models

Tier-2 / 3 cloud providers

Sovereign AI Platform-as-a-Service, white-label
Multi-tenant LoRA serving at scale
Cost-leadership via commodity-Ethernet training

Enterprises with GPU CapEx

Production training on PCIe-cluster fleets
Multi-node training over commodity Ethernet
Mixed NVIDIA + AMD scheduling

Sovereign-AI initiatives

National AI capability on national infrastructure
EU AI Act / DPDP provenance & lineage
Reproducible datasets, complete audit trail

The sovereign training platform for the agentic enterprise.

Schedule a discovery call, request a technical deep-dive, or get a pilot deployed in your infrastructure within two weeks.

Get a demo Talk to our team

Bud Model Foundry