Applied Engineering

Use when Local model access for a developer or small team, with no setup.

Skip when You need production throughput or a stable server API.

Use when A desktop GUI for running and serving local models, aimed at one operator.

Skip when You need headless, multi-tenant deployment.

Use when Cutting cost by matching query difficulty to model size, with a learned router.

Skip when You cannot evaluate the quality you would be trading away.

Use when Routing and prompt optimisation tuned on your own traffic.

Skip when Self-hosting or auditability is a requirement.

Use when Getting a prototype working in an afternoon.

Skip when You need durability, scaling or concurrent writes.

Use when Document loaders and splitters, if you are already in that ecosystem.

Skip when Structure matters — fixed-size splitting is rarely the right boundary.

Use when LoRA fine-tuning on a single GPU, with memory and time roughly halved.

Skip when You need a training stack you can audit line by line.

Use when Configuration-driven fine-tuning across many architectures.

Skip when You need to hand-tune the training loop itself.

Use when One interface for SFT, DPO and RLHF across open models.

Skip when You want a minimal, readable training script.

Use when Parameter-efficient fine-tuning — LoRA and variants — on limited hardware.

Skip when You need to change the model's capabilities, not bolt on an adapter.

Use when Post-training trainers for SFT, DPO and GRPO on top of any PEFT setup.

Skip when You are training from scratch rather than aligning an existing model.

Use when ZeRO sharding and pipeline parallelism across many GPUs.

Skip when The model fits on one device — the complexity buys nothing.

Use when PyTorch-native recipes that you can read and modify.

Skip when You want the breadth of a config-driven stack.

Use when Preference and reward optimisation hosted, without a cluster.

Skip when Training data cannot be uploaded to a third party.

Use when A disposable GPU for a quick experiment, with no setup.

Skip when Anything reproducible — a notebook is not a training pipeline.

Use when Hosted fine-tuning and deployment of an open model, billed per run.

Skip when You need custom training code or strict residency.

Use when Managed training runs with sweeps and artifact tracking wired up.

Skip when You want training infrastructure you run yourself.

Use when Tool use and state, in an ecosystem where the answers already exist.

Skip when You want a thin, legible core — this is a large surface.

Use when Data-centric work where retrieval is the centre of the problem.

Skip when You need agent orchestration more than data access.

Use when Type-safe agents where schema correctness is the priority.

Skip when You want a batteries-included ecosystem.

Use when Research into conversable multi-agent systems.

Skip when You need something stable and documented for production.

Use when Role-based orchestration where agents are framed as a team.

Skip when You want direct control over the loop itself.

Use when Embedding AI steps into an existing .NET estate.

Skip when Your stack is not .NET.

Use when TypeScript agents with typed workflows and evals built in.

Skip when You are working in Python.

Use when A small, legible set of primitives for handoffs and guardrails.

Skip when You need multi-provider abstraction at every layer.

Use when A minimal agent runtime with model-agnostic tool interfaces.

Skip when You need the wider ecosystem around it.

Use when Building agents against Anthropic models, with tool use and hooks.

Skip when You need provider independence at the framework layer.

Use when Agents whose memory is a first-class, inspectable and editable state.

Skip when You want memory to be a detail the framework handles for you.

Use when Reading the whole agent loop in a page — it is deliberately tiny.

Skip when You need a rich tool ecosystem around it.

Use when Streaming model calls in a TypeScript app, provider-agnostically.

Skip when You need agent orchestration rather than model calls.

Use when Compiling prompts into optimised programs from labelled examples.

Skip when You have no examples and no way to score them.

Use when Schema-validated extraction with typed retry and partial streaming.

Skip when You need a hard token-level guarantee rather than validation.

Use when Prompt versioning and evaluation run by a product team.

Skip when Prompts or data cannot be sent to a vendor.

Use when Constrained decoding with control flow interleaved into generation.

Skip when You need better ergonomics for plain extraction.

Use when A prompt registry with request logging and regression tests.

Skip when You need self-hosting.

Use when Open-source prompt management with a playground and versioning.

Skip when You need eval depth rather than prompt ergonomics.

Use when Automatic prompt optimisation via textual feedback loops.

Skip when Optimising without an eval set is guessing.

Use when Token-level constrained generation from a JSON schema or grammar.

Skip when Post-hoc validation is enough for your use case.

Use when The model hub, the datasets and the open-source library ecosystem.

Skip when You need a self-hosted artefact registry.

Use when The practical side of shipping LLM systems, taught end to end.

Skip when You want an API reference.

Use when Essays and books that distil research into working knowledge.

Skip when You need primary sources.

Use when The primary preprint record for machine learning research.

Skip when You need a curated and explained version.

Use when Linking papers to their reference implementations.

Skip when You are offline — it is a live index.

Use when Visual explanations of transformers, RAG and model internals.

Skip when You want depth beyond the intuition.

Use when A community and conference focused on shipping LLM products.

Skip when You need technical reference rather than practice.

Use when Task-oriented notebooks for fine-tuning, serving and RAG.

Skip when You need maintained library documentation.