Latest Agent Skills

Detect prompt injections and jailbreak attempts in LLM applications using Meta's 86M parameter classifier. Filter user inputs, third-party data, and RAG documents with low latency and multilingual support.

Fine-tune and align language models using reinforcement learning with TRL, including SFT, DPO, PPO, GRPO, and reward model training.

Pretrains large language models from scratch using PyTorch-native distributed training with 4D parallelism (FSDP2, TP, PP, CP) and Float8 support on H100 GPUs.

Optimizes transformer attention with Flash Attention for 2-4x speedup and 10-20x memory reduction. Supports PyTorch native SDPA, flash-attn library, H100 FP8, and sliding window attention.

GPU-accelerated data curation for LLM training, supporting text, image, video, and audio with fuzzy deduplication, quality filtering, semantic deduplication, PII redaction, and NSFW detection.

Generate images from text prompts, perform image-to-image translation, inpainting, and build custom diffusion pipelines using Stable Diffusion models via HuggingFace Diffusers.

Segment any object in images using points, boxes, or masks as prompts, or automatically generate all object masks with zero-shot transfer.

Guarantee valid JSON, XML, or code structure during text generation using Pydantic models for type-safe outputs, supporting local models (Transformers, vLLM, llama.cpp) and maximizing inference speed with structured generation.

Control LLM output with regex and grammars to guarantee valid JSON, XML, or code generation, enforce structured formats, and build multi-step workflows using Microsoft Research's Guidance framework.

Run LLM inference on CPU, Apple Silicon, and consumer GPUs without NVIDIA hardware. Use for edge deployment, M1/M2/M3 Macs, AMD/Intel GPUs, or when CUDA is unavailable. Supports GGUF quantization (1.5-8 bit) for reduced memory and 4-10× speedup vs PyTorch on CPU.

Deploy Meta's LlamaGuard moderation model to filter LLM inputs and outputs across 6 safety categories using HuggingFace, vLLM, or FastAPI.

Manage and use Lambda Labs GPU cloud instances for ML training and inference with SSH access, persistent filesystems, and multi-node clusters.

Train and use SentencePiece tokenizers for multilingual NLP, supporting BPE and Unigram algorithms with raw Unicode text.

Train and experiment with a minimal GPT implementation in ~300 lines of PyTorch, from character-level Shakespeare to GPT-2 scale.

Generate high-quality sentence and text embeddings for semantic similarity, clustering, and retrieval using 5000+ pre-trained models. Supports multilingual and domain-specific embeddings for RAG and semantic search.

Evaluates LLMs across 100+ benchmarks from 18+ harnesses (MMLU, HumanEval, GSM8K, safety, VLM) with multi-backend execution on local Docker, Slurm HPC, or cloud platforms.

Quantize LLMs to 8-bit or 4-bit for 50-75% memory reduction with minimal accuracy loss using bitsandbytes. Supports INT8, NF4, FP4 formats, QLoRA training, and 8-bit optimizers.

Provides expert guidance for fine-tuning LLMs with LLaMA-Factory, covering WebUI no-code, 100+ models, 2/3/4/5/6/8-bit QLoRA, and multimodal support.

Train, fine-tune, and deploy LLMs using LitGPT's clean implementations of 20+ architectures like Llama, Gemma, and Phi.

Evaluate NVIDIA Cosmos Policy on LIBERO and RoboCasa simulation environments with headless GPU evaluation and inference profiling.

Track ML experiments with automatic logging, visualize training in real-time, optimize hyperparameters with sweeps, and manage model registry with W&B.

Serve LLMs and VLMs with structured outputs, prefix caching, and high throughput using RadixAttention.

Train reinforcement learning models using torchforge, Meta's PyTorch-native RL library for scalable, algorithm-focused experimentation with GRPO, DAPO, and custom loss functions.

Process large-scale ML datasets with distributed streaming execution across CPU/GPU, supporting Parquet, CSV, JSON, images, and integration with PyTorch, TensorFlow, and Ray Train.

Train and run Mamba state-space models with O(n) complexity, achieving faster inference and longer context than Transformers.

Debug, evaluate, and monitor LLM applications with tracing, datasets, and built-in evaluators.

Build complex AI systems with declarative programming, optimize prompts automatically, and create modular RAG systems and agents using Stanford NLP's DSPy framework.

Run ML training and batch jobs across multiple clouds with automatic cost optimization, spot instance recovery, and unified orchestration.

Use RWKV, a linear-time RNN-Transformer hybrid, for efficient long-context inference and training with constant memory usage.

Fine-tunes and evaluates OpenVLA-OFT and OpenVLA-OFT+ policies for robot action generation with continuous action heads, LoRA adaptation, and FiLM conditioning on LIBERO simulation and ALOHA real-world setups.

Deploy and serve LLMs with high throughput using vLLM's PagedAttention and continuous batching. Supports OpenAI-compatible endpoints, quantization (GPTQ/AWQ/FP8), and tensor parallelism for production inference.

Train large language models (7B-70B+) with RLHF using PPO, GRPO, DPO, and other algorithms, accelerated by Ray and vLLM for distributed multi-GPU setups.

Generate music and sound effects from text descriptions using Meta's AudioCraft library, with support for melody conditioning, stereo output, and style transfer.

Trace, evaluate, and monitor LLM applications with an open-source observability platform.

Run ML workloads on Modal's serverless GPU cloud platform with auto-scaling, pay-per-second pricing, and Python-native infrastructure.

Post-train LLMs with reinforcement learning using the slime framework, which integrates Megatron-LM for training and SGLang for rollout generation.

Train language models with SimPO, a reference-free preference optimization method that outperforms DPO without needing a reference model.

Train large-scale MoE models with FP8/INT4 low-precision RL, speculative decoding, and train-inference alignment using the miles framework.

Provides expert guidance for fast fine-tuning with Unsloth, including LoRA/QLoRA optimization, with 2-5x faster training and 50-80% less memory usage.

Provides expert guidance for fine-tuning LLMs with Axolotl, covering YAML configs, LoRA/QLoRA, DPO/KTO/ORPO/GRPO, and multimodal support.

Transcribe and translate speech across 99 languages using OpenAI's Whisper model, with support for multiple model sizes, batch processing, and subtitle generation.

Train LLMs with reinforcement learning using verl (Volcano Engine RL), supporting RLHF, GRPO, PPO, and other algorithms for scalable post-training with flexible infrastructure backends.

Fine-tune and serve Physical Intelligence OpenPI models (pi0, pi0-fast, pi0.5) using JAX or PyTorch backends for robot policy inference across ALOHA, DROID, and LIBERO environments.

Generate image captions, answer visual questions, and perform image-text retrieval using BLIP-2's Q-Former architecture with frozen vision encoders and LLMs.

Connects LLMs with user data for RAG applications, document Q&A, and knowledge retrieval using 300+ data connectors and vector indices.

Visualize training metrics, debug models with histograms, compare experiments, visualize model graphs, and profile performance using TensorBoard.

Quantize large language models to 4-bit with minimal accuracy loss using GPTQ, enabling deployment of 70B+ models on consumer GPUs with 4× memory reduction and 3-4× faster inference.

Convert and quantize models to GGUF format for efficient CPU/GPU inference with llama.cpp, supporting 2-8 bit quantization and Apple Silicon acceleration.

Orchestrates end-to-end autonomous AI research projects using a two-loop architecture for rapid experimentation and synthesis, producing papers and presentations.

Enables visual instruction tuning and image-based conversations using open-source vision-language models. Supports multi-turn image chat, visual question answering, and image understanding tasks.

Build LLM-powered applications with agents, chains, and RAG using a framework that supports multiple providers and 500+ integrations.

Quantize large language models to 8/4/3/2/1-bit precision without calibration data, using multiple optimized backends for deployment with vLLM or HuggingFace Transformers.

Quantize large language models to 4-bit using activation-aware weight quantization, achieving ~3x speedup with minimal accuracy loss for deployment on limited GPU memory.

Fine-tune large language models by training less than 1% of parameters using LoRA, QLoRA, and 25+ adapter methods, enabling efficient adaptation on consumer GPUs.

Enables zero-shot image classification, image-text matching, and cross-modal retrieval using OpenAI's CLIP model.

Optimize AI agents through automated evolution cycles using LLM-driven mutation of prompts, skills, and memory against measurable benchmarks.

Build, deploy, and manage continuous AI agents using a visual workflow editor or development toolkit.

Build teams of autonomous AI agents that collaborate to solve complex tasks using role-based delegation, memory, and sequential or hierarchical execution.

Track ML experiments with open-source run logging, local or self-hosted dashboards, and media visualization using SwanLab.

Provides code examples and best practices for using Pinecone, a managed vector database for production RAG, recommendation, and semantic search applications.