diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5a0c10ef..446e1cf1 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,266 +2,13 @@
 
 Thank you for choosing to contribute to AgML!
 
-## Contributing Data
-
-If you've found (or already have) a new dataset and you want to contribute the dataset to AgML,
-then the instructions below will help you format and the data to the AgML standard.
-
-### Dataset Formats
-
-Currently, we have image classification, object detection, and semantic segmentation datasets available
-in AgML. These sources are synthesized to standard annotation formats, namely the following:
-
-- **Image Classification**: Image-To-Label-Number
-- **Object Detection**: [COCO JSON](https://cocodataset.org/#format-data)
-- **Semantic Segmentation**: Dense Pixel-Wise
-
-#### Image Classification
-
-Image classification datasets are organized in the following directory tree:
-
-```
-<dataset name>
-    ├── <label 1>
-    │   ├── image1.png
-    │   ├── image2.png
-    │   └── image3.png
-    └── <label 2>
-        ├── image1.png
-        ├── image2.png
-        └── image3.png
-```
-
-The `AgMLDataLoader` generates a mapping between each of the label names "label 1", "label 2", etc.,
-and a numerical value.
-
-#### Object Detection
-
-Object detection datasets are constructed using COCO JSON formatting. For a general overview, see
-[https://cocodataset.org/#format-data](https://cocodataset.org/#format-data).
-Another good resource is [https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/cd-transform-coco.html](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/cd-transform-coco.html).
-Once you have the images and the bounding box annotations, this involves generating a dictionary with four keys:
-
-1. `images`: A list of dictionaries with the following items:
-    - The image file name (without the parent directory!) in `file_name`
-    - The ID (a unique number, usually from 1 to num_images) in `id`,
-    - The height/width of the image in `height` and `width`, respectively.
-2. `annotations`: A list of dictionaries with each dictionary representing a _unique_ bounding box (do not stack multiple bounding boxes into a single dictionary, even if they are for the same image!), and containing:
-    - The area of the bounding box in `area`.
-    - The bounding box itself in `bbox`. **Note**: The bounding box should have four coordinates. The first two are the x, y of the top-left corner of the bounding box, the other two are its height and width.
-    - The class label (numerical) of the image in `category_id`.
-    - The **ID** (NOT the filename) of the image it corresponds to in `image_id`.
-    - The ID of the bounding box in `id`. For instance, if a unique image has six corresponding bounding boxes, then each of them would be given an `id` from 1-6.
-    - `iscrowd` should be set to 0 by default, unless the dataset explicitly comes with `iscrowd` as 1.
-    - `ignore` should be 0 by default.
-    - `segmentation` only applies for instance segmentation datasets. If converting an instance segmentation dataset to object detection, you can leave the polygonal segmentation as is. Otherwise, put this as an empty list.
-3. `category`: A list of dictionaries with each category, where each of these dictionaries contains:
-    - The human-readable name of the class (e.g., "strawberry") in `name`.
-    - The supercategory of the class, if there are nested classes, in `supercategory`. Otherwise, just leave this as the string `"none"`.
-    - The numerical ID of the class in `id`.
-4. `info`: A single dictionary with metadata and information about the dataset:
-    - `description`: A basic description of the dataset.
-    - `url`: The URL from which the dataset was acquired.
-    - `version`: The dataset version. Set to `1.0` if unknown.
-    - `year`: The year in which the dataset was released.
-    - `contributor`: The author(s) of the dataset.
-    - `date_created`: The date when the dataset was published. Give an approximate year if unknown.
-
-The dictionary containing this information should be written to a file called `annotations.json`, and the file structure will be:
-
-```
-<dataset name>
-    ├── annotations.json
-    └── images
-        ├── image1.png
-        ├── image2.png
-        └── image3.png
-```
-
-#### Semantic Segmentation
-
-Semantic segmentation datasets are constructed using pixel-wise annotation masks. Each image in the dataset has a corresponding
-annotation mask. These masks have the following properties:
-
-1. Two-dimensional, so no channel shape. Their complete shape will be `(image_height, image_width)`.
-2. Each of the pixels will be a numerical class label or `0` for background.
-
-The directory tree should look like follows:
-
-```
-<dataset name>
-    ├── annotations
-    │   ├── mask1.png
-    │   ├── mask2.png
-    │   └── mask3.png
-    └── images
-        ├── image1.png
-        ├── image2.png
-        └── image3.png
-```
-
-
-## Contributing a Dataset
-
-If you've found a new dataset that *isn't already being used* in AgML and you want to add it, there's a few things you
-need to do.
-
-Any preprocessing code being used for the dataset can be kept in `agml/_internal/preprocess.py`, by adding an `elif` statement
-to the `preprocess()` method with the dataset name. If there is no preprocessing code, then just put a `pass` statement in the block.
-
-### Some Things to Check
-
-- Make sure each image is in the range of 0-255 in integers as opposed to 0-1 as floats. This will prevent any loss of data that
-  could adversely affect training.
-- For a semantic segmentation dataset, put the masks in a `png` format as opposed to `jpg` or other.
-
-### Compiling the Dataset
-
-After processing and standardizing the dataset, make sure that the dataset is organized in one of the formats above, and then go to the parent directory
-of the directory of the dataset (for example, if the dataset is in `/root/my_new_dataset`, go to `/root`). Then run the following command:
-
-```shell
-zip -r my_new_dataset.zip my_new_dataset -x ".*"
-```
-
-**If running on MacOS**, use the following command:
-
-```shell
-zip -r my_new_dataset.zip my_new_dataset -x ".*"  -x "__MACOSX"
-```
-
-### Updating the Source Files
-
-Next, you need to update the `public_datasources.json` and `source_citations.json` files. These two can be found
-in the `agml/_assets` folder. You will need to update the `public_datasources.json` file in the following way:
-
-```json
-    "my_new_dataset": {
-        "classes": {
-            "1": "class_1",
-            "2": "class_2",
-            "3": "class_3"
-        },
-        "ml_task": "See the table for the different dataset types.",
-        "ag_task": "The agricultural task that is associated with the dataset.",
-        "location": {
-            "continent": "The continent the dataset was collected on.",
-            "country": "The country the dataset was collected in."
-        },
-        "sensor_modality": "Usually rgb, but can include other image modalities.",
-        "real_synthetic": "Are the images real or synthetically generated?",
-        "platform": "handheld or ground",
-        "input_data_format": "See the table for the different dataset types.",
-        "annotation_format": "See the table for the different dataset types.",
-        "n_images": "The total number of images in the dataset.",
-        "docs_url": "Where can the user find the most clear information about the dataset?"
-    }
-```
-
-**Note**: If the dataset is captured in multiple countries or you don't know where it is from,
-then put "worldwide" for both "continent" and "country".
-
-**Note**: If there is no explicit documentation for the dataset, then reach out to the AgML team
-regarding what you should put. It is important that we have references to as many datasets as possible,
-to allow users to acquire raw data as they desire.
+Our updated contributing guidelines are located under the docs tab of the updated (project-agml.github.io)[https://project-agml.github.io/] website. 
 
+## Contributing Data
 
-#### `ml_task` and `ag_task`
-
-The ML task can be quickly defined from the following table:
-
-| Dataset Format | `ml_task` | `annotation_format` |
-| :------------: | :-------: | :-----------------: |
-| Image Classification | `image_classification` | `directory_names` |
-| Object Detection | `object_detection` | `coco_json` |
-| Semantic Segmentation | `semantic_segmentation` | `image` |
-
-
-The `ag_task` field is more broadly defined - it should be the main task that the dataset is associated with.
-For instance, any of the `*_leaf_disease_classification` datasets, alongside `bean_disease_uganda`, are all 
-associated with the `disease_classification` task. The `apple_segmentation_minnesota` dataset has the label
-`fruit_segmentation`. See `agml/_assets/public_datasources.json` for various examples of valid `ag_tasks`.
-Generally, you should keep this field broad enough that it encompasses the dataset (e.g., instead of a specific
-fruit, just put 'fruit' in general), but not as broad as the `ml_task`: it should have an agricultural component.
-
-The `source_citations.json` file should be updated this way:
-
-```json
-    "my_new_dataset": {
-        "license": "The license being used by the dataset.",
-        "citation": "The paper/library to cite for the dataset."
-    }
-```
-
-If the dataset has no license or has no citation, leave the corresponding lines blank.
-
-### Uploading the Dataset
-
-Once you've readied the dataset, create a new pull request on the AgML repository.
-We will then review the changes and review next steps for adding the dataset into AgML's public data storage.
-
-
-
-## Quality Checks
-
-When contributing a dataset, you should abide by the following guidelines to ensure compatibility with AgML and ensure that there are no problems for users who are working with the datasets:
-
-- Check that the dataset can be properly downloaded and loaded. It is best to instantiate an `AgMLDataLoader` and call `loader.show_sample()` in order to validate that the images and annotations are in the right format.
-- Make sure you have run `python3 scripts/generate_normalization_info.py --dataset <name>` and `python3 scripts/generate_shape_info.py --dataset <name>` to generate the dataset normalization and shape information.
-- Make sure that there is an entry in `agml/_internal/preprocess.py` for the dataset. Specifically, you should have a method in the class that makes up the file with the name of the method being the dataset, and the preprocessing code being that of the dataset.
-  
-
-## Development Guidelines
-
-
-### Installing uv
-Dependencies and admin actions are done using `uv`. To Install uv follow the guidelines in  https://docs.astral.sh/uv/getting-started/installation/, it is recommended to use the standalone installation.
-
-
-### Building Project
-
-To sync the dependencies and create a local env that fits the requirements, simply run:
-
-
-```bash
-make install
-```
-
-This will install both requirements and necessary development dependencies, such as `dev` and `docs` dependency groups. To build the wheels:
-
-
-```bash
-make build
-```
-
-### Running tests
-
-To run all the tests with associated coverage:
-
-```bash
-make test
-```
-
-
-### Running scripts
-
-For running scripts or one-offs using the project's installed enviroment
-The build the associated wheels simply run:
-
-```
-uv build
-```
-
-To sync the dependencies simply run:
-
-```
-uv sync
-```
+To contribute a new dataset, please follow the guidelines listed under the (development)[https://project-agml.github.io/docs/development] tab. 
 
-### Running scripts
+## Contributing Leaderboard Results
 
-For running scripts or one using the project's environment:
+To add a model's benchmarking results to the leaderboard, please follow the guidelines listed under the (contributing leaderboard results)[https://project-agml.github.io/docs/contributing-results] tab. 
 
-```
-uv run python <script>
-```
diff --git a/README.md b/README.md
index c744daeb..91fb4a70 100644
--- a/README.md
+++ b/README.md
@@ -12,14 +12,12 @@ We're looking to hire a postdoc with both Python library development and ML expe
 
 ## Overview
 AgML is a comprehensive library for agricultural machine learning. Currently, AgML provides
-access to a wealth of public agricultural datasets for common agricultural deep learning tasks. In the future, AgML will provide ag-specific ML functionality related to data, training, and evaluation. Here's a conceptual diagram of the overall framework.
-
-<p align="center">
-<img src="docs/assets/agml-framework.png" alt="agml framework" width="350" height="291">
-</p>
+access to a wealth of public agricultural datasets for common agricultural deep learning tasks. 
 
 AgML supports both the [TensorFlow](https://www.tensorflow.org/) and [PyTorch](https://pytorch.org/) machine learning frameworks.
 
+To browse our latest datasets, view our full set of documentation, and compare model performance on your crops / tasks of interest, please visit [project-agml.github.io](https://project-agml.github.io/).
+
 ## Installation
 
 To install the latest release of AgML, run the following command:
@@ -28,112 +26,71 @@ To install the latest release of AgML, run the following command:
 pip install agml
 ```
 
-**_NOTE:_** Some features of AgML, such as synthetic data generation, require GUI applications. When running AgML through
-Windows Subsystem for Linux (WSL), it may be necessary to configure your WSL environment to utilize these features. Please
-follow the [Microsoft documentation](https://learn.microsoft.com/en-us/windows/wsl/tutorials/gui-apps) to install all
-necessary prerequisites and update WSL. The latest version of WSL includes built-in support for running Linux GUI applications.
-
 ## Quick Start
 
-AgML is designed for easy usage of agricultural data in a variety of formats. You can start off by using the `AgMLDataLoader` to
-download and load a dataset into a container:
-
-```python
-import agml
-
-loader = agml.data.AgMLDataLoader('apple_flower_segmentation')
-```
-
-You can then use the in-built processing methods to get the loader ready for your training and evaluation pipelines. This includes, but
-is not limited to, batching data, shuffling data, splitting data into training, validation, and test sets, and applying transforms.
+AgML datasets are hosted on the [Hugging Face Hub](https://huggingface.co/Project-AgML) under the `Project-AgML`
+organization. You can start off by using the `HuggingFaceDataLoader` to download and load a dataset directly into a
+native Hugging Face `DatasetDict`:
 
 ```python
-import albumentations as A
-
-# Batch the dataset into collections of 8 pieces of data:
-loader.batch(8)
+from agml.data import HuggingFaceDataLoader
 
-# Shuffle the data:
-loader.shuffle()
+# Load a dataset from the Hub
+loader = HuggingFaceDataLoader("Project-AgML/apple_flower_segmentation")
 
-# Apply transforms to the input images and output annotation masks:
-loader.mask_to_channel_basis()
-loader.transform(
-    transform = A.RandomContrast(),
-    dual_transform = A.Compose([A.RandomRotate90()])
-)
-
-# Split the data into train/val/test sets.
-loader.split(train = 0.8, val = 0.1, test = 0.1)
+# Load a specific config/subset (e.g. an augmented variant)
+loader = HuggingFaceDataLoader("Project-AgML/apple_flower_segmentation", config="augmented")
 ```
 
-The split datasets can be accessed using `loader.train_data`, `loader.val_data`, and `loader.test_data`. Any further processing applied to the
-main loader will be applied to the split datasets, until the split attributes are accessed, at which point you need to apply processing independently
-to each of the loaders. You can also turn toggle processing on and off using the `loader.eval()`, `loader.reset_preprocessing()`, and `loader.disable_preprocessing()`
-methods.
+`HuggingFaceDataLoader` automatically casts image-like columns (`image`, `mask`, and image-typed `label` columns) to
+the Hugging Face `Image` type for decoded pixel access.
 
-You can visualize data using the `agml.viz` module, which supports multiple different types of visualization for different data types:
+You can split the dataset into train/val/test sets, with optional stratification across one or more columns:
 
 ```python
-# Disable processing and batching for the test data:
-test_ds = loader.test_data
-test_ds.batch(None)
-test_ds.reset_prepreprocessing()
-
-# Visualize the image and mask side-by-side:
-agml.viz.visualize_image_and_mask(test_ds[0])
+dataset = loader.split(val_size=0.1, test_size=0.1, stratify_cols="label")
+# Returns a DatasetDict with 'train', 'val', and 'test' splits
 
-# Visualize the mask overlaid onto the image:
-agml.viz.visualize_overlaid_masks(test_ds[0])
+# Access the underlying DatasetDict at any time
+dataset = loader.dataset
 ```
 
-AgML supports both the TensorFlow and PyTorch libraries as backends, and provides functionality to export your loaders to native TensorFlow and PyTorch
-formats when you want to use them in a training pipeline. This includes both exporting the `AgMLDataLoader` to a `tf.data.Dataset` or `torch.utils.data.DataLoader`,
-but also internally converting data within the `AgMLDataLoader` itself, enabling access to its core functionality.
-
+**For any preprocessing, inference, or training beyond loading and splitting, use the
+[`datasets`](https://huggingface.co/docs/datasets) and [`transformers`](https://huggingface.co/docs/transformers)
+libraries directly.** Since `loader.dataset` is a native Hugging Face `DatasetDict`, it works out of the box with
+`datasets`' `map`, `filter`, and `with_transform` methods for preprocessing, and with `transformers`' `Trainer`,
+`Pipeline`, and model classes for training and inference — there's no separate AgML-specific processing API to learn.
 
 ```python
-# Export the loader as a `tf.data.Dataset`:
-train_ds = loader.train_data.export_tensorflow()
-
-# Convert to PyTorch tensors without exporting.
-train_ds = loader.train_data
-train_ds.as_torch_dataset()
-```
-
-You're now ready to use AgML for training your own models! Luckily, AgML comes with a training module that enables quick-start training of standard deep learning models on agricultural datasets. Training a grape detection model is as simple as the following code:
-
-```python
-import agml
-import agml.models
-
-import albumentations as A
+from transformers import AutoImageProcessor, AutoModelForImageClassification, Trainer
 
-loader = agml.data.AgMLDataLoader('grape_detection_californiaday')
-loader.split(train = 0.8, val = 0.1, test = 0.1)
-processor = agml.models.preprocessing.EfficientDetPreprocessor(
-    image_size = 512, augmentation = [A.HorizontalFlip(p=0.5)]
+processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
+model = AutoModelForImageClassification.from_pretrained(
+    "google/vit-base-patch16-224",
+    num_labels=dataset["train"].features["label"].num_classes,
 )
-loader.transform(processor)
 
-model = agml.models.DetectionModel(num_classes=loader.num_classes)
+def preprocess(batch):
+    batch["pixel_values"] = processor(batch["image"], return_tensors="pt")["pixel_values"]
+    return batch
 
-model.run_training(loader)
+dataset = dataset.with_transform(preprocess)
+
+trainer = Trainer(model=model, train_dataset=dataset["train"], eval_dataset=dataset["val"])
+trainer.train()
 ```
 
-## Public Dataset Listing
+## Public Datasets
 
 AgML contains a wide variety of public datasets from various locations across the world:
 
 ![AgML Dataset World Map](/docs/assets/agml_dataset_world_map.png)
 
-
-To browse existing AgML datasets, please visit https://project-agml.github.io/datasets, where you can search the datasets that we have collected by a variet of fields.
-
+Use the [Dataset Search](https://project-agml.github.io/datasets) experience for filtering and previews. For programmatic filtering,
+`agml.data.public_data_sources(...)` supports task and modality filters.
 
 ## iNatAg and iNatAg-mini
 
-
 AgML provides an API with direct access to iNatAg (and iNatAg-mini), one of the world's largest collections of agricultural images dedicated for the task of image classification. Collectively, this dataset contains over 4 million images along with detailed species classificaations and enables access to a variety of large-scale agricultural machine learning tasks. You can instantiate the iNatAg (or iNatAg-mini, a smaller variant of iNatAg for smaller-scale applications) dataset as follows:
 
 ```python
@@ -144,35 +101,33 @@ loader = agml.data.AgMLDataLoader.from_parent("iNatAg", filters={"family_name":
 loader = agml.data.AgMLDataLoader.from_parent("iNatAg", filters={"common_name": "..."})
 ```
 
-
 ## Usage Information
 
 ### Using Public Agricultural Data
 
 AgML aims to provide easy access to a range of existing public agricultural datasets The core of AgML's public data pipeline is
-[`AgMLDataLoader`](/agml/data/loader.py). You can use the `AgMLDataLoader` or `agml.data.download_public_dataset()` to download
+[`AgMLDataLoader`](https://github.com/Project-AgML/AgML/blob/main/agml/data/loader.py). You can use the `AgMLDataLoader` or `agml.data.download_public_dataset()` to download
 the dataset locally from which point it will be automatically loaded from the disk on future runs.
 From this point, the data within the loader can be split into train/val/test sets, batched, have augmentations and transforms
 applied, and be converted into a training-ready dataset (including batching, tensor conversion, and image formatting).
 
-To see the various ways in which you can use AgML datasets in your training pipelines, check out
-the [example notebook](/examples/AgML-Data.ipynb).
-
 ## Annotation Formats
 
 A core aim of AgML is to provide datasets in a standardized format, enabling the synthesizing of multiple datasets
-into a single training pipeline. To this end, we provide annotations in the following formats:
+into a single training pipeline. Datasets on the Hugging Face Hub encode annotations as columns on the underlying
+`Dataset`/`DatasetDict`:
 
-- **Image Classification**: Image-To-Label-Number
-- **Object Detection**: [COCO JSON](https://cocodataset.org/#format-data)
-- **Semantic Segmentation**: Dense Pixel-Wise
+- **Image Classification**: a `label` column of type `ClassLabel`.
+- **Object Detection**: an `objects` column, holding COCO-style bounding boxes (un-normlized [x_min, y_min, width, height]) and corresponding category IDs as a ClassLabel per image.
+- **Semantic Segmentation**: a `mask` column, a single-channel (`L`-mode) image the same size as the corresponding image.
 
 ## Contributions
 
 We welcome contributions! If you would like to contribute a new feature, fix an issue that you've noticed, or even just mention
 a bug or feature that you would like to see implemented, please don't hesitate to use the *Issues* tab to bring it to our attention.
 
-See the [contributing guidelines](/CONTRIBUTING.md) for more information.
+See the [contributing guidelines]([https://project-agml.github.io/docs/development) for more information, or the
+[guide to contributing leaderboard results](https://project-agml.github.io/docs/contributing-results) if you have benchmark results to add.
 
 ## Funding
-This project is partly funded by the [National AI Institute for Food Systems](https://aifs.ucdavis.ed
\ No newline at end of file
+This project is partly funded by the [National AI Institute for Food Systems](https://aifs.ucdavis.edu).