diff --git a/rust/crates/sift_cli/CHANGELOG.md b/rust/crates/sift_cli/CHANGELOG.md
index d8d0acbce..090d08c0f 100644
--- a/rust/crates/sift_cli/CHANGELOG.md
+++ b/rust/crates/sift_cli/CHANGELOG.md
@@ -7,6 +7,32 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ### What's New
 
+## [v0.5.0] - August 26, 2026
+
+### What's New
+
+- Added MCP tools for managing calculated channels: `list_calculated_channels`,
+  `list_calculated_channel_versions`, `create_calculated_channel`,
+  `update_calculated_channel`, `archive_calculated_channel`, and
+  `unarchive_calculated_channel`.
+- `get_data` now serves saved calculated channels. A name in `channel_names`
+  with no raw-channel match resolves as an active saved calculated channel for
+  the asset and run; unresolvable names are reported explicitly.
+- `get_data` now accepts `asset_id` as an alternative to `asset_name`; exactly
+  one must be set.
+- Added `preview_rule`, which dry-runs a saved rule or an ad-hoc draft rule
+  config against a run without persisting anything.
+- Added MCP tools for managing user-defined functions:
+  `list_user_defined_functions`, `list_user_defined_function_versions`,
+  `create_user_defined_function`, `update_user_defined_function`,
+  `archive_user_defined_function`, and `unarchive_user_defined_function`.
+- `update_annotation` now requires `annotation_ids` instead of `annotation_id`,
+  a breaking change for existing callers; pass a one-element list for one
+  annotation. It updates 1 to 1000 annotations per call with per-ID failure
+  reporting, and its new `is_archived` parameter archives or unarchives
+  annotations.
+- Refreshed the bundled Sift agent skill to cover the expanded MCP tool surface.
+
 ## [v0.4.4] - August 24, 2026
 
 ### What's New
diff --git a/rust/crates/sift_cli/Cargo.toml b/rust/crates/sift_cli/Cargo.toml
index 933525bd9..f1b096a04 100644
--- a/rust/crates/sift_cli/Cargo.toml
+++ b/rust/crates/sift_cli/Cargo.toml
@@ -3,7 +3,7 @@ test-reports = ["sift_mcp/test-reports"]
 
 [package]
 name = "sift_cli"
-version = "0.4.4"
+version = "0.5.0"
 authors.workspace = true
 edition.workspace = true
 categories.workspace = true
diff --git a/rust/crates/sift_cli/assets/skills/sift/SKILL.md b/rust/crates/sift_cli/assets/skills/sift/SKILL.md
index de9eab083..47f56b3cb 100644
--- a/rust/crates/sift_cli/assets/skills/sift/SKILL.md
+++ b/rust/crates/sift_cli/assets/skills/sift/SKILL.md
@@ -1,19 +1,21 @@
 ---
 name: sift
 description: >-
-  Use when working with Sift: ingesting or importing time-series data,
-  querying assets/runs/channels/users, exporting data, decimating or running
-  SQL over data, opening a view in the Sift Explore web app, writing code that
-  integrates with Sift, installing, updating, or diagnosing the Sift agent
-  integration, or looking up how Sift works in its product and API
-  documentation. Covers the Sift MCP server (started by `sift-cli mcp`), the
-  `sift-cli` itself, the Sift REST API over cURL, the Sift Python library
-  (`sift_client`), and the Sift Rust streaming library (`sift_stream`).
+  Use for Sift tasks: ingesting or importing time-series data, querying
+  assets/runs/channels/users, managing calculated channels, rules, and
+  user-defined functions, exporting or decimating data, running SQL over data,
+  opening a view in Sift Explore, writing code that integrates with Sift,
+  installing, updating, or diagnosing the Sift agent integration, or looking
+  up how Sift works in its product and API documentation. Covers the Sift MCP
+  server (started by `sift-cli mcp`), `sift-cli`, the Sift REST API over cURL,
+  the Sift Python library (`sift_client`), and the Sift Rust streaming library
+  (`sift_stream`).
   Triggers include phrases like "import this file into Sift", "stream data to
   Sift", "list assets/runs/channels", "runs I created", "runs a teammate
-  created", "export a run", "query Sift", "graph", "plot", "visualize", "open
-  in Explore", "write code to integrate with Sift", "how does X work in Sift",
-  "what does this endpoint do", or "look up the Sift API reference".
+  created", "export a run", "query Sift", "graph", "plot", "visualize", "open in
+  Explore", "write code to integrate with Sift", "how does X work in Sift",
+  "what does this endpoint do", "list calculated channels", "preview a rule",
+  or "look up the Sift API reference".
 ---
 
 <!--
@@ -48,11 +50,18 @@ exists.
 
 - **Setup:** When available, `check_for_updates` reports the installed sift-cli
   version, the latest stable version, and the exact installer command. Servers
-  started with `--disable-update-check` omit this tool.
+  started with `--disable-update-check` omit this tool. `ping` is a
+  connectivity check; when it fails, expect every other Sift tool to fail too.
 - **Discovery:** `list_assets`, `list_runs`, `list_channels`, `list_reports`,
   `list_report_templates`, `list_rules`, `list_rule_versions`, `list_annotations`.
+- **Derived channels:** `list_calculated_channels`,
+  `list_calculated_channel_versions`, `list_user_defined_functions`,
+  `list_user_defined_function_versions`.
 - **People:** `list_users`.
-- **Report detail:** `list_report_rule_summaries`.
+- **Rollups:** `list_report_rule_summaries` for a report's rule progress.
+- **Rule dry runs:** `preview_rule` returns the annotations a rule would create
+  without persisting anything. It is read-only whatever the server's access
+  mode, so it needs no write flag.
 - **Test results:** `list_test_reports`, `list_test_steps`,
   `list_test_measurements`, `count_test_steps`, `count_test_measurements`.
   These, along with the `create_test_report` and `append_test_measurements`
@@ -64,8 +73,13 @@ exists.
 - **Docs:** `search_docs`.
 - **Writes:** `create_rule`, `update_rule`, `archive_rule`, `unarchive_rule`,
   `create_annotation`, `update_annotation`, `create_report`, `update_report`,
-  `create_report_template`, `update_report_template`, `create_test_report`,
-  `append_test_measurements`, `update_asset`, `update_run`.
+  `create_report_template`, `update_report_template`,
+  `create_calculated_channel`, `update_calculated_channel`,
+  `archive_calculated_channel`, `unarchive_calculated_channel`,
+  `create_user_defined_function`, `update_user_defined_function`,
+  `archive_user_defined_function`, `unarchive_user_defined_function`,
+  `create_test_report`, `append_test_measurements`, `update_asset`,
+  `update_run`.
 
 ## Workflows that span tools
 
@@ -81,11 +95,43 @@ exists.
 - **Attribute something to a person.** Resolve the person with `list_users`,
   then filter another list on `created_by_user_id`. For "runs I created", pass
   `me: true`. Never guess which listed user is the caller.
+- **Update annotations.** `update_annotation` takes a required
+  `annotation_ids` list of 1 to 1000 ids and applies the same changes to every
+  target. Set `is_archived: true` to archive or `is_archived: false` to
+  unarchive; there is no separate archive tool. Check its per-id `failures`,
+  `not_attempted` ids, and archive outcome before reporting success; a partial
+  failure sets `isError`.
 - **Produce numbers.** `get_data` writes a Parquet file. `sql` then queries it.
   Add `upload_dataset` when the result belongs back in Sift. A successful
   `get_data` does not mean every requested channel is in the file: check
   `unmatched_channel_names` and `empty_channels` in the result and name any
   missing channel to the user before reporting numbers derived from it.
+- **Query a derived channel.** `get_data` serves saved calculated channels as
+  well as raw ones: name the calculated channel in `channel_names` and it is
+  evaluated for the requested asset and run. Confirm the name with
+  `list_calculated_channels` filtered on the asset first. A raw channel wins a
+  name it shares with a calculated channel, and `channel_regex` matches raw
+  channels only, so name calculated channels explicitly. When the result
+  carries `unresolved_calculated_channels`, the file is missing those columns:
+  tell the user which channels did not resolve rather than reporting the file as
+  complete.
+- **Author or change a calculated channel.** A calculated channel is a CEL
+  expression plus an asset scope. `create_calculated_channel` and
+  `update_calculated_channel` take the expression with `$1`, `$2`, …
+  placeholders plus `expression_channel_references_json`, a JSON string array
+  mapping each placeholder to a channel. Resolve those channel names with
+  `list_channels` first. An update creates a new version and leaves earlier
+  versions intact; `list_calculated_channel_versions` shows that history.
+  Archiving sets an archived state, which `unarchive_calculated_channel` clears;
+  it is not a versioned, history-visible change.
+- **Use or change a user-defined function.** Call
+  `list_user_defined_functions` before writing an expression that calls a UDF:
+  it gives the exact name, input order, and output type the expression must
+  match. An update creates a new version and leaves earlier ones intact, so
+  `list_user_defined_function_versions` gives history and pinned version ids.
+  Send a rename on its own. The API applies a `name` change by itself and
+  ignores every other field, so `update_user_defined_function` rejects `name`
+  combined with anything else.
 - **Produce a chart.** Build a link with `explore_url`. When the user wants a
   chart and numbers, do both and give the user both.
 - **Answer a question about how Sift works.** Call `search_docs`. Do not answer
@@ -99,7 +145,11 @@ exists.
   gated tool and the exact `sift-cli agent update --allow-create` command, and
   wait for the user to widen access.
 - **Evaluate rules against a run.** Find rules with `list_rules` and author rules
-  with `create_rule`. To reuse the same rule set across many runs, bundle
+  with `create_rule`. Dry-run first: `preview_rule` returns the annotations a
+  rule would generate for one run and persists nothing. It takes either a saved
+  rule (`rule_id` or `rule_name`) or a fully ad-hoc `draft_rule_config` JSON
+  string, so a rule need not be saved to be tested. Use `create_report` when the
+  evaluation should persist. To reuse the same rule set across many runs, bundle
   standard rules (`is_external: false`) into a template with `create_report_template`,
   then call `create_report` with `report_template_id`. For a one-off — or for
   ad-hoc rules (`is_external: true`, which the API also calls "external" but
@@ -133,11 +183,12 @@ exists.
   Several creates happen as side effects of other MCP tools — an asset is
   created when `upload_dataset` names one that doesn't exist, a run is
   created when a `create_report`/`create_test_report`/`upload_dataset` names
-  one. When the user asks for a create with no matching `create_*` tool,
-  look for the tool that creates it as a side effect before falling out of
-  MCP. If that side-effect tool is gated and blocked, that IS the block —
-  surface it, do not treat "no `create_asset` tool" as license to shell out
-  to REST/gRPC/`sift-cli import`.
+  one, and a tag is created when `create_annotation` includes a name that
+  doesn't exist (there is no `create_tag` tool). When the user asks for a create
+  with no matching `create_*` tool, look for the tool that creates it as a side
+  effect before falling out of MCP. If that side-effect tool is gated and
+  blocked, that IS the block — surface it, do not treat "no `create_asset` tool"
+  as license to shell out to REST/gRPC/`sift-cli import`.
 - **Choose one profile for the session and keep it.** Never switch profiles to
   recover from a failure. Surface the failure and ask the user.
 
diff --git a/rust/crates/sift_mcp/Cargo.toml b/rust/crates/sift_mcp/Cargo.toml
index be3185cef..172bfc460 100644
--- a/rust/crates/sift_mcp/Cargo.toml
+++ b/rust/crates/sift_mcp/Cargo.toml
@@ -23,6 +23,7 @@ tonic.workspace = true
 anyhow.workspace = true
 chrono.workspace = true
 clap = { workspace = true, features = ["cargo"] }
+futures.workspace = true
 pbjson-types.workspace = true
 percent-encoding.workspace = true
 prost.workspace = true
diff --git a/rust/crates/sift_mcp/src/server/mod.rs b/rust/crates/sift_mcp/src/server/mod.rs
index 81f26bff7..16a2e45a9 100644
--- a/rust/crates/sift_mcp/src/server/mod.rs
+++ b/rust/crates/sift_mcp/src/server/mod.rs
@@ -42,8 +42,9 @@ use crate::service::{
     annotations::AnnotationService, assets::AssetService,
     calculated_channels::CalculatedChannelService, channels::ChannelService, data::DataService,
     docs::DocsService, ingest::IngestService, ping::PingService,
-    report_templates::ReportTemplateService, reports::ReportService, rules::RuleService,
-    runs::RunService, url::UrlService, users::UserService,
+    report_templates::ReportTemplateService, reports::ReportService,
+    rule_evaluation::RuleEvaluationService, rules::RuleService, runs::RunService, url::UrlService,
+    user_defined_functions::UserDefinedFunctionService, users::UserService,
 };
 
 #[derive(Clone)]
@@ -63,9 +64,11 @@ pub struct SiftMcpServer {
     pub report_service: ReportService,
     pub report_template_service: ReportTemplateService,
     pub rule_service: RuleService,
+    pub rule_evaluation_service: RuleEvaluationService,
     #[cfg(feature = "test-reports")]
     pub test_report_service: TestReportService,
     pub docs_service: DocsService,
+    pub user_defined_function_service: UserDefinedFunctionService,
     pub user_service: UserService,
 
     pub allow_create: bool,
@@ -188,10 +191,12 @@ impl SiftMcpServer {
         tool_router.merge(Self::explore_router());
         tool_router.merge(Self::ping_router());
         tool_router.merge(Self::rules_router());
+        tool_router.merge(Self::rule_evaluation_router());
         tool_router.merge(Self::annotations_router());
         #[cfg(feature = "test-reports")]
         tool_router.merge(Self::test_reports_router());
         tool_router.merge(Self::docs_router());
+        tool_router.merge(Self::user_defined_functions_router());
         tool_router.merge(Self::users_router());
         if update_check.is_some() {
             tool_router.merge(Self::update_router());
@@ -215,9 +220,13 @@ impl SiftMcpServer {
         let report_template_service =
             ReportTemplateService::new(channel.clone(), retry_policy.clone());
         let rule_service = RuleService::new(channel.clone(), retry_policy.clone());
+        let rule_evaluation_service =
+            RuleEvaluationService::new(channel.clone(), retry_policy.clone());
         #[cfg(feature = "test-reports")]
         let test_report_service = TestReportService::new(channel.clone(), retry_policy.clone());
         let docs_service = DocsService::new(channel.clone(), retry_policy.clone());
+        let user_defined_function_service =
+            UserDefinedFunctionService::new(channel.clone(), retry_policy.clone());
         let user_service = UserService::new(channel.clone(), retry_policy);
 
         Self {
@@ -233,9 +242,11 @@ impl SiftMcpServer {
             report_service,
             report_template_service,
             rule_service,
+            rule_evaluation_service,
             #[cfg(feature = "test-reports")]
             test_report_service,
             docs_service,
+            user_defined_function_service,
             user_service,
             tool_router,
             prompt_router,
diff --git a/rust/crates/sift_mcp/src/service/annotations/mod.rs b/rust/crates/sift_mcp/src/service/annotations/mod.rs
index 8790a3810..dcf067bfc 100644
--- a/rust/crates/sift_mcp/src/service/annotations/mod.rs
+++ b/rust/crates/sift_mcp/src/service/annotations/mod.rs
@@ -1,21 +1,72 @@
 use crate::policy::{RetryPolicy, with_retry};
 use crate::service::common;
-use anyhow::{Context, Result, anyhow};
+use anyhow::{Context, Error, Result, anyhow};
+use futures::{StreamExt, stream};
 use pbjson_types::{FieldMask, Timestamp};
 use sift_rs::{
     SiftChannel,
     annotations::v1::{
         Annotation, AnnotationLinkedChannel, AnnotationState, AnnotationType,
-        CreateAnnotationRequest, ListAnnotationsRequest, ListAnnotationsResponse,
-        UpdateAnnotationRequest, annotation_linked_channel,
+        BatchArchiveAnnotationsRequest, CreateAnnotationRequest, ListAnnotationsRequest,
+        ListAnnotationsResponse, UpdateAnnotationRequest, annotation_linked_channel,
         annotation_service_client::AnnotationServiceClient,
     },
     metadata::v1::MetadataValue,
 };
+use tonic::Code;
 
 #[cfg(test)]
 mod test;
 
+const MAX_CONCURRENT_ANNOTATION_UPDATES: usize = 50;
+
+#[derive(Debug)]
+pub struct AnnotationUpdateFailure {
+    pub annotation_id: String,
+    pub error: Error,
+}
+
+#[derive(Debug)]
+pub struct UpdateAnnotationsResult {
+    pub annotations: Vec<Annotation>,
+    pub failures: Vec<AnnotationUpdateFailure>,
+    pub not_attempted: Vec<String>,
+    pub batch_archive_error: Option<Error>,
+    pub archive_skipped: bool,
+}
+
+async fn fan_out_bounded<T, R, F, Fut>(items: Vec<T>, concurrency: usize, mut op: F) -> Vec<R>
+where
+    F: FnMut(T) -> Fut,
+    Fut: Future<Output = R>,
+{
+    let mut results = stream::iter(items.into_iter().enumerate())
+        .map(|(index, item)| {
+            let future = op(item);
+            async move { (index, future.await) }
+        })
+        .buffer_unordered(concurrency)
+        .collect::<Vec<_>>()
+        .await;
+    results.sort_unstable_by_key(|(index, _)| *index);
+    results.into_iter().map(|(_, result)| result).collect()
+}
+
+fn is_backend_wide_failure(error: &Error) -> bool {
+    error.downcast_ref::<tonic::Status>().is_some_and(|status| {
+        matches!(
+            status.code(),
+            Code::ResourceExhausted
+                | Code::Unavailable
+                | Code::DeadlineExceeded
+                | Code::Internal
+                | Code::Unauthenticated
+                | Code::PermissionDenied
+                | Code::Cancelled
+        )
+    })
+}
+
 /// Build a protobuf `Timestamp` from Unix nanoseconds via the shared helper.
 fn timestamp_from_unix_nanos(nanos: i64) -> Timestamp {
     let (seconds, nanos) = common::unix_nanos_to_secs_and_subsec_nanos(nanos);
@@ -176,6 +227,185 @@ impl AnnotationService {
             .ok_or_else(|| anyhow!("create_annotation response missing annotation"))
     }
 
+    pub async fn batch_archive_annotations(
+        &self,
+        annotation_ids: Vec<String>,
+    ) -> Result<Vec<Annotation>> {
+        let channel = self.channel.clone();
+        let resp = with_retry(&self.policy, move || {
+            let channel = channel.clone();
+            let annotation_ids = annotation_ids.clone();
+            async move {
+                let mut client = AnnotationServiceClient::new(channel);
+                client
+                    .batch_archive_annotations(BatchArchiveAnnotationsRequest { annotation_ids })
+                    .await
+                    .map(|resp| resp.into_inner())
+            }
+        })
+        .await
+        .context("failed to batch archive annotations")?;
+
+        Ok(resp.annotations)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub async fn update_annotations(
+        &self,
+        annotation_ids: Vec<String>,
+        name: Option<String>,
+        description: Option<String>,
+        start_time_unix_nanos: Option<i64>,
+        end_time_unix_nanos: Option<i64>,
+        assigned_to_user_id: Option<String>,
+        state: Option<AnnotationState>,
+        tags: Option<Vec<String>>,
+        linked_channel_ids: Option<Vec<String>>,
+        metadata: Option<Vec<MetadataValue>>,
+        is_archived: Option<bool>,
+    ) -> Result<UpdateAnnotationsResult> {
+        let has_field_update = name.is_some()
+            || description.is_some()
+            || start_time_unix_nanos.is_some()
+            || end_time_unix_nanos.is_some()
+            || assigned_to_user_id.is_some()
+            || state.is_some()
+            || tags.is_some()
+            || linked_channel_ids.is_some()
+            || metadata.is_some();
+        let mut annotations = Vec::new();
+        let mut failures = Vec::new();
+        let mut not_attempted = Vec::new();
+
+        if has_field_update {
+            annotations.reserve(annotation_ids.len());
+            for chunk_start in (0..annotation_ids.len()).step_by(MAX_CONCURRENT_ANNOTATION_UPDATES)
+            {
+                let chunk_end =
+                    (chunk_start + MAX_CONCURRENT_ANNOTATION_UPDATES).min(annotation_ids.len());
+                let service = self.clone();
+                let name = name.clone();
+                let description = description.clone();
+                let assigned_to_user_id = assigned_to_user_id.clone();
+                let tags = tags.clone();
+                let linked_channel_ids = linked_channel_ids.clone();
+                let metadata = metadata.clone();
+                let updates = fan_out_bounded(
+                    annotation_ids[chunk_start..chunk_end].to_vec(),
+                    MAX_CONCURRENT_ANNOTATION_UPDATES,
+                    move |annotation_id| {
+                        let service = service.clone();
+                        let name = name.clone();
+                        let description = description.clone();
+                        let assigned_to_user_id = assigned_to_user_id.clone();
+                        let tags = tags.clone();
+                        let linked_channel_ids = linked_channel_ids.clone();
+                        let metadata = metadata.clone();
+                        async move {
+                            let result = service
+                                .update_annotation(
+                                    annotation_id.clone(),
+                                    name,
+                                    description,
+                                    start_time_unix_nanos,
+                                    end_time_unix_nanos,
+                                    assigned_to_user_id,
+                                    state,
+                                    tags,
+                                    linked_channel_ids,
+                                    metadata,
+                                )
+                                .await;
+                            (annotation_id, result)
+                        }
+                    },
+                )
+                .await;
+                let stop_after_batch = updates
+                    .iter()
+                    .any(|(_, result)| result.as_ref().is_err_and(is_backend_wide_failure));
+
+                for (annotation_id, result) in updates {
+                    match result {
+                        Ok(annotation) => annotations.push(annotation),
+                        Err(error) => failures.push(AnnotationUpdateFailure {
+                            annotation_id,
+                            error,
+                        }),
+                    }
+                }
+
+                if stop_after_batch {
+                    not_attempted.extend_from_slice(&annotation_ids[chunk_end..]);
+                    break;
+                }
+            }
+        }
+
+        let mut batch_archive_error = None;
+        let mut archive_skipped = false;
+        if is_archived == Some(true) {
+            if failures.is_empty() && not_attempted.is_empty() {
+                let result = self.batch_archive_annotations(annotation_ids).await;
+                match result {
+                    Ok(archived) => annotations = archived,
+                    Err(error) => batch_archive_error = Some(error),
+                }
+            } else {
+                archive_skipped = true;
+            }
+        } else if is_archived == Some(false) && failures.is_empty() && not_attempted.is_empty() {
+            annotations.clear();
+            annotations.reserve(annotation_ids.len());
+            for chunk_start in (0..annotation_ids.len()).step_by(MAX_CONCURRENT_ANNOTATION_UPDATES)
+            {
+                let chunk_end =
+                    (chunk_start + MAX_CONCURRENT_ANNOTATION_UPDATES).min(annotation_ids.len());
+                let service = self.clone();
+                let unarchives = fan_out_bounded(
+                    annotation_ids[chunk_start..chunk_end].to_vec(),
+                    MAX_CONCURRENT_ANNOTATION_UPDATES,
+                    move |annotation_id| {
+                        let service = service.clone();
+                        async move {
+                            let result = service.unarchive_annotation(annotation_id.clone()).await;
+                            (annotation_id, result)
+                        }
+                    },
+                )
+                .await;
+                let stop_after_batch = unarchives
+                    .iter()
+                    .any(|(_, result)| result.as_ref().is_err_and(is_backend_wide_failure));
+
+                for (annotation_id, result) in unarchives {
+                    match result {
+                        Ok(annotation) => annotations.push(annotation),
+                        Err(error) => failures.push(AnnotationUpdateFailure {
+                            annotation_id,
+                            error,
+                        }),
+                    }
+                }
+
+                if stop_after_batch {
+                    not_attempted.extend_from_slice(&annotation_ids[chunk_end..]);
+                    break;
+                }
+            }
+        } else if is_archived == Some(false) {
+            archive_skipped = true;
+        }
+
+        Ok(UpdateAnnotationsResult {
+            annotations,
+            failures,
+            not_attempted,
+            batch_archive_error,
+            archive_skipped,
+        })
+    }
+
     /// Update a subset of an existing annotation's fields. Per
     /// `protos/sift/annotations/v1/annotations.proto::UpdateAnnotationRequest` the
     /// updatable fields are `name`, `description`, `start_time`, `end_time`,
@@ -240,7 +470,6 @@ impl AnnotationService {
             annotation.metadata = v;
             paths.push("metadata".to_string());
         }
-
         let channel = self.channel.clone();
         let resp = with_retry(&self.policy, move || {
             let channel = channel.clone();
@@ -263,4 +492,34 @@ impl AnnotationService {
         resp.annotation
             .ok_or_else(|| anyhow!("update_annotation response missing annotation"))
     }
+
+    #[allow(deprecated)] // The backend requires this deprecated field to unarchive annotations.
+    pub async fn unarchive_annotation(&self, annotation_id: String) -> Result<Annotation> {
+        let channel = self.channel.clone();
+        let resp = with_retry(&self.policy, move || {
+            let channel = channel.clone();
+            let annotation_id = annotation_id.clone();
+            async move {
+                let mut client = AnnotationServiceClient::new(channel);
+                client
+                    .update_annotation(UpdateAnnotationRequest {
+                        annotation: Some(Annotation {
+                            annotation_id,
+                            deleted_date: None,
+                            ..Default::default()
+                        }),
+                        update_mask: Some(FieldMask {
+                            paths: vec!["deleted_date".into()],
+                        }),
+                    })
+                    .await
+                    .map(|resp| resp.into_inner())
+            }
+        })
+        .await
+        .context("failed to unarchive annotation")?;
+
+        resp.annotation
+            .ok_or_else(|| anyhow!("unarchive_annotation response missing annotation"))
+    }
 }
diff --git a/rust/crates/sift_mcp/src/service/annotations/test.rs b/rust/crates/sift_mcp/src/service/annotations/test.rs
index 1cda4956a..743d3b250 100644
--- a/rust/crates/sift_mcp/src/service/annotations/test.rs
+++ b/rust/crates/sift_mcp/src/service/annotations/test.rs
@@ -1,12 +1,21 @@
+use std::{
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+    time::Duration,
+};
+
 use sift_rs::annotations::v1::{
-    Annotation, AnnotationState, AnnotationType, CreateAnnotationResponse, ListAnnotationsResponse,
-    UpdateAnnotationResponse, annotation_service_server::AnnotationServiceServer,
+    Annotation, AnnotationState, AnnotationType, BatchArchiveAnnotationsResponse,
+    CreateAnnotationResponse, ListAnnotationsResponse, UpdateAnnotationResponse,
+    annotation_service_server::AnnotationServiceServer,
 };
 use sift_test_util::{grpc::memory_sift_channel, mock::annotations::v1::MockAnnotationServiceImpl};
-use tokio::task::JoinHandle;
+use tokio::{sync::Semaphore, task::JoinHandle};
 use tonic::{Response, Status, transport::Server};
 
-use super::AnnotationService;
+use super::{AnnotationService, fan_out_bounded};
 use crate::service::common::DEFAULT_LIMIT;
 
 async fn service_with_mock(mock: MockAnnotationServiceImpl) -> (AnnotationService, JoinHandle<()>) {
@@ -27,6 +36,47 @@ async fn service_with_mock(mock: MockAnnotationServiceImpl) -> (AnnotationServic
     )
 }
 
+#[tokio::test]
+async fn bounded_fan_out_limits_concurrency_and_preserves_order() {
+    let active = Arc::new(AtomicUsize::new(0));
+    let max_active = Arc::new(AtomicUsize::new(0));
+    let started = Arc::new(AtomicUsize::new(0));
+    let gate = Arc::new(Semaphore::new(0));
+
+    let active_for_task = Arc::clone(&active);
+    let max_for_task = Arc::clone(&max_active);
+    let started_for_task = Arc::clone(&started);
+    let gate_for_task = Arc::clone(&gate);
+    let task = tokio::spawn(fan_out_bounded((0..120).collect(), 50, move |item| {
+        let active = Arc::clone(&active_for_task);
+        let max_active = Arc::clone(&max_for_task);
+        let started = Arc::clone(&started_for_task);
+        let gate = Arc::clone(&gate_for_task);
+        async move {
+            let current = active.fetch_add(1, Ordering::SeqCst) + 1;
+            max_active.fetch_max(current, Ordering::SeqCst);
+            started.fetch_add(1, Ordering::SeqCst);
+            gate.acquire().await.unwrap().forget();
+            active.fetch_sub(1, Ordering::SeqCst);
+            item
+        }
+    }));
+
+    tokio::time::timeout(Duration::from_secs(1), async {
+        while started.load(Ordering::SeqCst) < 50 {
+            tokio::task::yield_now().await;
+        }
+    })
+    .await
+    .expect("50 updates should start concurrently");
+    assert_eq!(started.load(Ordering::SeqCst), 50);
+    gate.add_permits(120);
+    let results = task.await.unwrap();
+
+    assert_eq!(results, (0..120).collect::<Vec<_>>());
+    assert_eq!(max_active.load(Ordering::SeqCst), 50);
+}
+
 #[tokio::test]
 async fn list_annotations_returns_single_page() {
     let mut mock = MockAnnotationServiceImpl::new();
@@ -275,6 +325,133 @@ async fn create_annotation_propagates_grpc_error() {
     assert!(err.to_string().contains("failed to create annotation"));
 }
 
+#[tokio::test]
+async fn batch_archive_annotations_forwards_ids() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_batch_archive_annotations()
+        .withf(|req| req.get_ref().annotation_ids == ["ann1", "ann2"])
+        .returning(|req| {
+            let annotations = req
+                .into_inner()
+                .annotation_ids
+                .into_iter()
+                .map(|annotation_id| Annotation {
+                    annotation_id,
+                    is_archived: true,
+                    ..Default::default()
+                })
+                .collect();
+            Ok(Response::new(BatchArchiveAnnotationsResponse {
+                annotations,
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let annotations = service
+        .batch_archive_annotations(vec!["ann1".into(), "ann2".into()])
+        .await
+        .expect("batch archive failed");
+
+    assert_eq!(annotations.len(), 2);
+    assert!(annotations.iter().all(|annotation| annotation.is_archived));
+}
+
+#[tokio::test]
+async fn batch_archive_annotations_propagates_grpc_error() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_batch_archive_annotations()
+        .returning(|_| Err(Status::not_found("no such annotation")));
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let error = service
+        .batch_archive_annotations(vec!["ann1".into()])
+        .await
+        .expect_err("expected batch archive error");
+
+    assert!(
+        error
+            .to_string()
+            .contains("failed to batch archive annotations")
+    );
+}
+
+#[tokio::test]
+async fn update_annotations_collects_failures_and_continues() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_update_annotation().times(3).returning(|req| {
+        let annotation = req.into_inner().annotation.unwrap();
+        if annotation.annotation_id == "ann2" {
+            return Err(Status::not_found("no such annotation"));
+        }
+        Ok(Response::new(UpdateAnnotationResponse {
+            annotation: Some(annotation),
+        }))
+    });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let outcome = service
+        .update_annotations(
+            vec!["ann1".into(), "ann2".into(), "ann3".into()],
+            Some("renamed".into()),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )
+        .await
+        .expect("bulk update failed");
+
+    let updated_ids = outcome
+        .annotations
+        .iter()
+        .map(|annotation| annotation.annotation_id.as_str())
+        .collect::<Vec<_>>();
+    assert_eq!(updated_ids, ["ann1", "ann3"]);
+    assert_eq!(outcome.failures.len(), 1);
+    assert_eq!(outcome.failures[0].annotation_id, "ann2");
+}
+
+#[tokio::test]
+async fn update_annotations_stops_after_backend_wide_failure() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_update_annotation()
+        .times(50)
+        .returning(|_| Err(Status::resource_exhausted("slow down")));
+
+    let (service, _h) = service_with_mock(mock).await;
+    let annotation_ids = (0..60)
+        .map(|index| format!("ann{index}"))
+        .collect::<Vec<_>>();
+
+    let outcome = service
+        .update_annotations(
+            annotation_ids.clone(),
+            Some("renamed".into()),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )
+        .await
+        .expect("bulk update failed");
+
+    assert_eq!(outcome.failures.len(), 50);
+    assert_eq!(outcome.not_attempted, annotation_ids[50..]);
+}
+
 #[tokio::test]
 async fn update_annotation_builds_mask_from_provided_fields() {
     let mut mock = MockAnnotationServiceImpl::new();
diff --git a/rust/crates/sift_mcp/src/service/mod.rs b/rust/crates/sift_mcp/src/service/mod.rs
index fe778f3e8..ecad30608 100644
--- a/rust/crates/sift_mcp/src/service/mod.rs
+++ b/rust/crates/sift_mcp/src/service/mod.rs
@@ -8,11 +8,13 @@ pub mod ingest;
 pub mod ping;
 pub mod report_templates;
 pub mod reports;
+pub mod rule_evaluation;
 pub mod rules;
 pub mod runs;
 #[cfg(feature = "test-reports")]
 pub mod test_reports;
 pub mod url;
+pub mod user_defined_functions;
 pub mod users;
 
 pub(crate) mod common;
diff --git a/rust/crates/sift_mcp/src/service/rule_evaluation/mod.rs b/rust/crates/sift_mcp/src/service/rule_evaluation/mod.rs
new file mode 100644
index 000000000..869058c01
--- /dev/null
+++ b/rust/crates/sift_mcp/src/service/rule_evaluation/mod.rs
@@ -0,0 +1,91 @@
+use crate::policy::{RetryPolicy, with_retry};
+use anyhow::{Context, Result};
+use sift_rs::{
+    SiftChannel,
+    common::r#type::v1::{
+        Ids, ResourceIdentifier, ResourceIdentifiers, resource_identifier, resource_identifiers,
+    },
+    rule_evaluation::v1::{
+        EvaluateRulesFromCurrentRuleVersions, EvaluateRulesFromRuleConfigs,
+        EvaluateRulesPreviewRequest, EvaluateRulesPreviewResponse, evaluate_rules_preview_request,
+        rule_evaluation_service_client::RuleEvaluationServiceClient,
+    },
+    rules::v1::UpdateRuleRequest,
+};
+
+#[cfg(test)]
+mod test;
+
+/// Which rule to dry-run: a saved rule identified by id (already resolved from
+/// a name upstream, if that's how the caller identified it), or an ad-hoc
+/// draft definition that is never persisted anywhere.
+pub enum PreviewRuleSource {
+    SavedRuleId(String),
+    DraftRuleConfig(Box<UpdateRuleRequest>),
+}
+
+#[derive(Clone)]
+pub struct RuleEvaluationService {
+    channel: SiftChannel,
+    policy: RetryPolicy,
+}
+
+impl RuleEvaluationService {
+    pub fn new(channel: SiftChannel, policy: RetryPolicy) -> Self {
+        Self { channel, policy }
+    }
+
+    /// Dry-runs rule evaluation against a run via `EvaluateRulesPreview`. Nothing
+    /// is persisted by this RPC: no report, annotation, or rule version is
+    /// created. Returns the count of annotations that would be created and their
+    /// would-be details.
+    pub async fn preview_rule(
+        &self,
+        run_id: String,
+        source: PreviewRuleSource,
+        organization_id: Option<String>,
+    ) -> Result<EvaluateRulesPreviewResponse> {
+        let mode = match source {
+            PreviewRuleSource::SavedRuleId(rule_id) => {
+                evaluate_rules_preview_request::Mode::Rules(EvaluateRulesFromCurrentRuleVersions {
+                    rules: Some(ResourceIdentifiers {
+                        identifiers: Some(resource_identifiers::Identifiers::Ids(Ids {
+                            ids: vec![rule_id],
+                        })),
+                    }),
+                })
+            }
+            PreviewRuleSource::DraftRuleConfig(config) => {
+                evaluate_rules_preview_request::Mode::RuleConfigs(EvaluateRulesFromRuleConfigs {
+                    configs: vec![*config],
+                })
+            }
+        };
+
+        let request = EvaluateRulesPreviewRequest {
+            organization_id: organization_id.unwrap_or_default(),
+            time: Some(evaluate_rules_preview_request::Time::Run(
+                ResourceIdentifier {
+                    identifier: Some(resource_identifier::Identifier::Id(run_id)),
+                },
+            )),
+            mode: Some(mode),
+            ..Default::default()
+        };
+
+        let channel = self.channel.clone();
+        with_retry(&self.policy, move || {
+            let channel = channel.clone();
+            let request = request.clone();
+            async move {
+                let mut client = RuleEvaluationServiceClient::new(channel);
+                client
+                    .evaluate_rules_preview(request)
+                    .await
+                    .map(|resp| resp.into_inner())
+            }
+        })
+        .await
+        .context("failed to preview rule evaluation")
+    }
+}
diff --git a/rust/crates/sift_mcp/src/service/rule_evaluation/test.rs b/rust/crates/sift_mcp/src/service/rule_evaluation/test.rs
new file mode 100644
index 000000000..35b9142bd
--- /dev/null
+++ b/rust/crates/sift_mcp/src/service/rule_evaluation/test.rs
@@ -0,0 +1,146 @@
+use sift_rs::{
+    common::r#type::v1::{resource_identifier, resource_identifiers},
+    rule_evaluation::v1::{
+        EvaluateRulesPreviewResponse, evaluate_rules_preview_request,
+        rule_evaluation_service_server::RuleEvaluationServiceServer,
+    },
+    rules::v1::{DryRunAnnotation, UpdateRuleRequest},
+};
+use sift_test_util::{
+    grpc::memory_sift_channel, mock::rule_evaluation::v1::MockRuleEvaluationServiceImpl,
+};
+use tokio::task::JoinHandle;
+use tonic::{Response, Status, transport::Server};
+
+use super::{PreviewRuleSource, RuleEvaluationService};
+use crate::policy::RetryPolicy;
+
+async fn service_with_mock(
+    mock: MockRuleEvaluationServiceImpl,
+) -> (RuleEvaluationService, JoinHandle<()>) {
+    let (client, server) = tokio::io::duplex(1024);
+    let channel = memory_sift_channel(client).await;
+
+    let handle = tokio::spawn(async move {
+        Server::builder()
+            .add_service(RuleEvaluationServiceServer::new(mock))
+            .serve_with_incoming(tokio_stream::once(Ok::<_, std::io::Error>(server)))
+            .await
+            .unwrap();
+    });
+
+    (
+        RuleEvaluationService::new(channel, RetryPolicy::default()),
+        handle,
+    )
+}
+
+#[tokio::test]
+async fn preview_rule_builds_saved_rule_request() {
+    let mut mock = MockRuleEvaluationServiceImpl::new();
+    mock.expect_evaluate_rules_preview()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            let run_matches = matches!(
+                &req.time,
+                Some(evaluate_rules_preview_request::Time::Run(id))
+                    if matches!(&id.identifier, Some(resource_identifier::Identifier::Id(v)) if v == "run-1")
+            );
+            let mode_matches = matches!(
+                &req.mode,
+                Some(evaluate_rules_preview_request::Mode::Rules(r))
+                    if matches!(
+                        r.rules.as_ref().and_then(|r| r.identifiers.as_ref()),
+                        Some(resource_identifiers::Identifiers::Ids(ids)) if ids.ids == vec!["rule-1".to_string()]
+                    )
+            );
+            run_matches && mode_matches
+        })
+        .returning(|_| {
+            Ok(Response::new(EvaluateRulesPreviewResponse {
+                created_annotation_count: 2,
+                dry_run_annotations: vec![],
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let resp = service
+        .preview_rule(
+            "run-1".to_string(),
+            PreviewRuleSource::SavedRuleId("rule-1".to_string()),
+            None,
+        )
+        .await
+        .expect("preview_rule failed");
+
+    assert_eq!(resp.created_annotation_count, 2);
+}
+
+#[tokio::test]
+async fn preview_rule_builds_draft_rule_config_request() {
+    let mut mock = MockRuleEvaluationServiceImpl::new();
+    mock.expect_evaluate_rules_preview()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            matches!(
+                &req.mode,
+                Some(evaluate_rules_preview_request::Mode::RuleConfigs(cfg))
+                    if cfg.configs.len() == 1 && cfg.configs[0].name == "draft rule"
+            )
+        })
+        .returning(|_| {
+            Ok(Response::new(EvaluateRulesPreviewResponse {
+                created_annotation_count: 1,
+                dry_run_annotations: vec![DryRunAnnotation {
+                    condition_id: "cond-1".into(),
+                    name: "draft rule".into(),
+                    ..Default::default()
+                }],
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let draft = UpdateRuleRequest {
+        name: "draft rule".into(),
+        ..Default::default()
+    };
+
+    let resp = service
+        .preview_rule(
+            "run-1".to_string(),
+            PreviewRuleSource::DraftRuleConfig(Box::new(draft)),
+            None,
+        )
+        .await
+        .expect("preview_rule failed");
+
+    assert_eq!(resp.created_annotation_count, 1);
+    assert_eq!(resp.dry_run_annotations.len(), 1);
+}
+
+#[tokio::test]
+async fn preview_rule_propagates_grpc_error() {
+    let mut mock = MockRuleEvaluationServiceImpl::new();
+    mock.expect_evaluate_rules_preview()
+        .returning(|_| Err(Status::invalid_argument("bad rule config")));
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let err = service
+        .preview_rule(
+            "run-1".to_string(),
+            PreviewRuleSource::SavedRuleId("rule-1".to_string()),
+            None,
+        )
+        .await
+        .expect_err("expected error");
+
+    assert!(
+        err.to_string()
+            .contains("failed to preview rule evaluation")
+    );
+}
diff --git a/rust/crates/sift_mcp/src/service/user_defined_functions/mod.rs b/rust/crates/sift_mcp/src/service/user_defined_functions/mod.rs
new file mode 100644
index 000000000..728a53a33
--- /dev/null
+++ b/rust/crates/sift_mcp/src/service/user_defined_functions/mod.rs
@@ -0,0 +1,377 @@
+use crate::policy::{RetryPolicy, with_retry};
+use crate::service::common;
+use anyhow::{Context, Result, anyhow};
+use pbjson_types::FieldMask;
+use sift_rs::{
+    SiftChannel,
+    common::r#type::v1::{FunctionInput, UserDefinedFunction},
+    metadata::v1::MetadataValue,
+    user_defined_functions::v1::{
+        CreateUserDefinedFunctionRequest, GetUserDefinedFunctionRequest,
+        ListUserDefinedFunctionVersionsRequest, ListUserDefinedFunctionVersionsResponse,
+        ListUserDefinedFunctionsRequest, ListUserDefinedFunctionsResponse,
+        UpdateUserDefinedFunctionRequest,
+        user_defined_function_service_client::UserDefinedFunctionServiceClient,
+    },
+};
+
+#[cfg(test)]
+mod test;
+
+/// A partial set of changes to apply to an existing user defined function.
+/// `None` means "leave unchanged" — only the fields set here reach the update
+/// mask. Archive state has its own entry point
+/// ([`UserDefinedFunctionService::set_user_defined_function_archived`]) so the
+/// archive flip stays a separate, gated operation.
+#[derive(Debug, Default)]
+pub struct UdfUpdate {
+    pub name: Option<String>,
+    pub description: Option<String>,
+    pub expression: Option<String>,
+    pub function_inputs: Option<Vec<FunctionInput>>,
+    pub metadata: Option<Vec<MetadataValue>>,
+}
+
+#[derive(Clone)]
+pub struct UserDefinedFunctionService {
+    channel: SiftChannel,
+    policy: RetryPolicy,
+}
+
+impl UserDefinedFunctionService {
+    pub fn new(channel: SiftChannel, policy: RetryPolicy) -> Self {
+        Self { channel, policy }
+    }
+
+    /// Lists the latest version of each user defined function.
+    pub async fn list_user_defined_functions(
+        &self,
+        filter: String,
+        order_by: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<common::Page<UserDefinedFunction>> {
+        let (page_size, record_limit) = common::paging(limit);
+
+        let mut page_token = String::new();
+        let mut results = Vec::new();
+        let mut has_more = false;
+
+        let order_by = order_by.unwrap_or_default();
+
+        loop {
+            let channel = self.channel.clone();
+            let filter = filter.clone();
+            let order_by = order_by.clone();
+            let token = page_token.clone();
+
+            let resp = with_retry(&self.policy, move || {
+                let channel = channel.clone();
+                let filter = filter.clone();
+                let order_by = order_by.clone();
+                let token = token.clone();
+                async move {
+                    let mut client = UserDefinedFunctionServiceClient::new(channel);
+                    client
+                        .list_user_defined_functions(ListUserDefinedFunctionsRequest {
+                            page_size,
+                            page_token: token,
+                            filter,
+                            order_by,
+                        })
+                        .await
+                        .map(|resp| resp.into_inner())
+                }
+            })
+            .await
+            .context("failed to query user defined functions")?;
+
+            let ListUserDefinedFunctionsResponse {
+                user_defined_functions,
+                next_page_token,
+            } = resp;
+            if user_defined_functions.is_empty() {
+                break;
+            }
+            results.extend(user_defined_functions);
+
+            if results.len() >= record_limit {
+                // The cap, not the end of the data: report that more exist so the
+                // caller does not read this page's size as the match total.
+                has_more = results.len() > record_limit || !next_page_token.is_empty();
+                break;
+            }
+            if next_page_token.is_empty() {
+                break;
+            }
+            page_token = next_page_token;
+        }
+
+        results.truncate(record_limit);
+
+        Ok(common::Page {
+            items: results,
+            has_more,
+        })
+    }
+
+    /// Lists the version history of one user defined function. The caller
+    /// guarantees exactly one of `user_defined_function_id` or `name` is
+    /// non-empty; the proto ignores `name` when the id is present.
+    pub async fn list_user_defined_function_versions(
+        &self,
+        user_defined_function_id: String,
+        name: String,
+        filter: String,
+        order_by: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<common::Page<UserDefinedFunction>> {
+        let (page_size, record_limit) = common::paging(limit);
+
+        let mut page_token = String::new();
+        let mut results = Vec::new();
+        let mut has_more = false;
+
+        let order_by = order_by.unwrap_or_default();
+
+        loop {
+            let channel = self.channel.clone();
+            let user_defined_function_id = user_defined_function_id.clone();
+            let name = name.clone();
+            let filter = filter.clone();
+            let order_by = order_by.clone();
+            let token = page_token.clone();
+
+            let resp = with_retry(&self.policy, move || {
+                let channel = channel.clone();
+                let user_defined_function_id = user_defined_function_id.clone();
+                let name = name.clone();
+                let filter = filter.clone();
+                let order_by = order_by.clone();
+                let token = token.clone();
+                async move {
+                    let mut client = UserDefinedFunctionServiceClient::new(channel);
+                    client
+                        .list_user_defined_function_versions(
+                            ListUserDefinedFunctionVersionsRequest {
+                                user_defined_function_id,
+                                name,
+                                page_size,
+                                page_token: token,
+                                filter,
+                                order_by,
+                            },
+                        )
+                        .await
+                        .map(|resp| resp.into_inner())
+                }
+            })
+            .await
+            .context("failed to query user defined function versions")?;
+
+            let ListUserDefinedFunctionVersionsResponse {
+                user_defined_functions,
+                next_page_token,
+            } = resp;
+            if user_defined_functions.is_empty() {
+                break;
+            }
+            results.extend(user_defined_functions);
+
+            if results.len() >= record_limit {
+                // The cap, not the end of the data: report that more exist so the
+                // caller does not read this page's size as the match total.
+                has_more = results.len() > record_limit || !next_page_token.is_empty();
+                break;
+            }
+            if next_page_token.is_empty() {
+                break;
+            }
+            page_token = next_page_token;
+        }
+
+        results.truncate(record_limit);
+
+        Ok(common::Page {
+            items: results,
+            has_more,
+        })
+    }
+
+    /// Creates a user defined function at version 1 and returns it.
+    pub async fn create_user_defined_function(
+        &self,
+        name: String,
+        description: Option<String>,
+        expression: String,
+        function_inputs: Vec<FunctionInput>,
+        user_notes: Option<String>,
+        metadata: Vec<MetadataValue>,
+    ) -> Result<UserDefinedFunction> {
+        let channel = self.channel.clone();
+
+        let resp = with_retry(&self.policy, move || {
+            let channel = channel.clone();
+            let name = name.clone();
+            let description = description.clone();
+            let expression = expression.clone();
+            let function_inputs = function_inputs.clone();
+            let user_notes = user_notes.clone();
+            let metadata = metadata.clone();
+            async move {
+                let mut client = UserDefinedFunctionServiceClient::new(channel);
+                client
+                    .create_user_defined_function(CreateUserDefinedFunctionRequest {
+                        name,
+                        description,
+                        expression,
+                        function_inputs,
+                        user_notes,
+                        metadata,
+                    })
+                    .await
+                    .map(|resp| resp.into_inner())
+            }
+        })
+        .await
+        .context("failed to create user defined function")?;
+
+        resp.user_defined_function.ok_or_else(|| {
+            anyhow!("create_user_defined_function response missing user defined function")
+        })
+    }
+
+    /// Updates a user defined function through the field mask. Per
+    /// `protos/sift/user_defined_functions/v1/user_defined_functions.proto::UpdateUserDefinedFunctionRequest`
+    /// the updatable fields are `name`, `archived_date`, `is_archived`,
+    /// `description`, `expression`, `function_inputs`, and `metadata`; archive
+    /// state goes through [`Self::set_user_defined_function_archived`].
+    ///
+    /// The RPC has no version precondition. Every accepted update creates a new
+    /// version and returns it, so the request carries only the id and the masked
+    /// fields — never a version read earlier by the caller.
+    pub async fn update_user_defined_function(
+        &self,
+        user_defined_function_id: String,
+        changes: UdfUpdate,
+    ) -> Result<UserDefinedFunction> {
+        let user_notes = self
+            .get_user_defined_function(user_defined_function_id.clone())
+            .await?
+            .user_notes;
+        let mut function = UserDefinedFunction {
+            user_defined_function_id,
+            user_notes,
+            ..Default::default()
+        };
+        let mut paths = Vec::new();
+
+        let UdfUpdate {
+            name,
+            description,
+            expression,
+            function_inputs,
+            metadata,
+        } = changes;
+
+        if let Some(v) = name {
+            function.name = v;
+            paths.push("name".to_string());
+        }
+        if let Some(v) = description {
+            function.description = v;
+            paths.push("description".to_string());
+        }
+        if let Some(v) = expression {
+            function.expression = v;
+            paths.push("expression".to_string());
+        }
+        if let Some(v) = function_inputs {
+            function.function_inputs = v;
+            paths.push("function_inputs".to_string());
+        }
+        if let Some(v) = metadata {
+            function.metadata = v;
+            paths.push("metadata".to_string());
+        }
+
+        self.send_update(function, paths).await
+    }
+
+    /// Archives or unarchives a user defined function. There is no dedicated
+    /// archive RPC: the proto sets `is_archived` through the update mask.
+    pub async fn set_user_defined_function_archived(
+        &self,
+        user_defined_function_id: String,
+        is_archived: bool,
+    ) -> Result<UserDefinedFunction> {
+        let user_notes = self
+            .get_user_defined_function(user_defined_function_id.clone())
+            .await?
+            .user_notes;
+        let function = UserDefinedFunction {
+            user_defined_function_id,
+            is_archived,
+            user_notes,
+            ..Default::default()
+        };
+
+        self.send_update(function, vec!["is_archived".to_string()])
+            .await
+    }
+
+    async fn get_user_defined_function(
+        &self,
+        user_defined_function_id: String,
+    ) -> Result<UserDefinedFunction> {
+        let channel = self.channel.clone();
+        let resp = with_retry(&self.policy, move || {
+            let channel = channel.clone();
+            let user_defined_function_id = user_defined_function_id.clone();
+            async move {
+                let mut client = UserDefinedFunctionServiceClient::new(channel);
+                client
+                    .get_user_defined_function(GetUserDefinedFunctionRequest {
+                        user_defined_function_id,
+                        name: String::new(),
+                    })
+                    .await
+                    .map(|resp| resp.into_inner())
+            }
+        })
+        .await
+        .context("failed to fetch user defined function")?;
+
+        resp.user_defined_function.ok_or_else(|| {
+            anyhow!("get_user_defined_function response missing user defined function")
+        })
+    }
+
+    async fn send_update(
+        &self,
+        function: UserDefinedFunction,
+        paths: Vec<String>,
+    ) -> Result<UserDefinedFunction> {
+        let channel = self.channel.clone();
+        let resp = with_retry(&self.policy, move || {
+            let channel = channel.clone();
+            let function = function.clone();
+            let paths = paths.clone();
+            async move {
+                let mut client = UserDefinedFunctionServiceClient::new(channel);
+                client
+                    .update_user_defined_function(UpdateUserDefinedFunctionRequest {
+                        user_defined_function: Some(function),
+                        update_mask: Some(FieldMask { paths }),
+                    })
+                    .await
+                    .map(|resp| resp.into_inner())
+            }
+        })
+        .await
+        .context("failed to update user defined function")?;
+
+        resp.user_defined_function.ok_or_else(|| {
+            anyhow!("update_user_defined_function response missing user defined function")
+        })
+    }
+}
diff --git a/rust/crates/sift_mcp/src/service/user_defined_functions/test.rs b/rust/crates/sift_mcp/src/service/user_defined_functions/test.rs
new file mode 100644
index 000000000..9d26d16fb
--- /dev/null
+++ b/rust/crates/sift_mcp/src/service/user_defined_functions/test.rs
@@ -0,0 +1,860 @@
+use sift_rs::{
+    common::r#type::v1::{FunctionDataType, FunctionInput, UserDefinedFunction},
+    metadata::v1::{
+        MetadataKey, MetadataKeyType, MetadataValue, metadata_value::Value as MetadataValueInner,
+    },
+    user_defined_functions::v1::{
+        CreateUserDefinedFunctionResponse, GetUserDefinedFunctionResponse,
+        ListUserDefinedFunctionVersionsResponse, ListUserDefinedFunctionsResponse,
+        UpdateUserDefinedFunctionResponse,
+        user_defined_function_service_server::UserDefinedFunctionServiceServer,
+    },
+};
+use sift_test_util::{
+    grpc::memory_sift_channel, mock::user_defined_functions::v1::MockUserDefinedFunctionServiceImpl,
+};
+use tokio::task::JoinHandle;
+use tonic::{Response, Status, transport::Server};
+
+use super::{UdfUpdate, UserDefinedFunctionService};
+use crate::policy::RetryPolicy;
+use crate::service::common::DEFAULT_LIMIT;
+
+fn string_metadata(name: &str, value: &str) -> MetadataValue {
+    MetadataValue {
+        key: Some(MetadataKey {
+            name: name.into(),
+            r#type: MetadataKeyType::String.into(),
+            ..Default::default()
+        }),
+        value: Some(MetadataValueInner::StringValue(value.into())),
+        ..Default::default()
+    }
+}
+
+fn numeric_input(identifier: &str) -> FunctionInput {
+    FunctionInput {
+        identifier: identifier.into(),
+        data_type: FunctionDataType::Numeric.into(),
+        constant: false,
+    }
+}
+
+fn udf(id: &str, name: &str) -> UserDefinedFunction {
+    UserDefinedFunction {
+        user_defined_function_id: id.into(),
+        name: name.into(),
+        ..Default::default()
+    }
+}
+
+fn expect_current_udf(mock: &mut MockUserDefinedFunctionServiceImpl, id: &str, user_notes: &str) {
+    let expected_id = id.to_string();
+    let response_id = id.to_string();
+    let user_notes = user_notes.to_string();
+    mock.expect_get_user_defined_function()
+        .times(1)
+        .withf(move |req| {
+            let req = req.get_ref();
+            req.user_defined_function_id == expected_id && req.name.is_empty()
+        })
+        .returning(move |_| {
+            Ok(Response::new(GetUserDefinedFunctionResponse {
+                user_defined_function: Some(UserDefinedFunction {
+                    user_defined_function_id: response_id.clone(),
+                    user_notes: user_notes.clone(),
+                    ..Default::default()
+                }),
+            }))
+        });
+}
+
+async fn service_with_mock(
+    mock: MockUserDefinedFunctionServiceImpl,
+) -> (UserDefinedFunctionService, JoinHandle<()>) {
+    let (client, server) = tokio::io::duplex(1024);
+    let channel = memory_sift_channel(client).await;
+
+    let handle = tokio::spawn(async move {
+        Server::builder()
+            .add_service(UserDefinedFunctionServiceServer::new(mock))
+            .serve_with_incoming(tokio_stream::once(Ok::<_, std::io::Error>(server)))
+            .await
+            .unwrap();
+    });
+
+    (
+        UserDefinedFunctionService::new(channel, RetryPolicy::default()),
+        handle,
+    )
+}
+
+#[tokio::test]
+async fn list_user_defined_functions_returns_single_page() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_functions()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            req.filter == "name.matches(\"(?i)rms\")"
+                && req.order_by == "name"
+                && req.page_size == DEFAULT_LIMIT
+                && req.page_token.is_empty()
+        })
+        .returning(|_| {
+            Ok(Response::new(ListUserDefinedFunctionsResponse {
+                user_defined_functions: vec![udf("f1", "rms"), udf("f2", "rms_windowed")],
+                next_page_token: String::new(),
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let functions = service
+        .list_user_defined_functions(
+            "name.matches(\"(?i)rms\")".to_string(),
+            Some("name".to_string()),
+            None,
+        )
+        .await
+        .expect("list_user_defined_functions failed")
+        .items;
+
+    assert_eq!(functions.len(), 2);
+    assert_eq!(functions[0].user_defined_function_id, "f1");
+    assert_eq!(functions[1].user_defined_function_id, "f2");
+}
+
+#[tokio::test]
+async fn list_user_defined_functions_paginates_until_token_empty() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_functions().returning(|req| {
+        let req = req.into_inner();
+        assert_eq!(req.page_size, DEFAULT_LIMIT);
+        let (functions, next) = match req.page_token.as_str() {
+            "" => (vec![udf("f1", "a")], "page-2".to_string()),
+            "page-2" => (vec![udf("f2", "b")], "page-3".to_string()),
+            "page-3" => (vec![udf("f3", "c")], String::new()),
+            other => return Err(Status::invalid_argument(format!("bad token: {other}"))),
+        };
+        Ok(Response::new(ListUserDefinedFunctionsResponse {
+            user_defined_functions: functions,
+            next_page_token: next,
+        }))
+    });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let functions = service
+        .list_user_defined_functions(String::new(), None, None)
+        .await
+        .expect("list_user_defined_functions failed")
+        .items;
+
+    let ids: Vec<&str> = functions
+        .iter()
+        .map(|f| f.user_defined_function_id.as_str())
+        .collect();
+    assert_eq!(ids, vec!["f1", "f2", "f3"]);
+}
+
+#[tokio::test]
+async fn list_user_defined_functions_truncates_to_limit_across_pages() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_functions().returning(|req| {
+        let req = req.into_inner();
+        assert_eq!(req.page_size, 3);
+        let (functions, next) = match req.page_token.as_str() {
+            "" => (vec![udf("f1", "a"), udf("f2", "b")], "page-2".to_string()),
+            "page-2" => (vec![udf("f3", "c"), udf("f4", "d")], String::new()),
+            other => return Err(Status::invalid_argument(format!("bad token: {other}"))),
+        };
+        Ok(Response::new(ListUserDefinedFunctionsResponse {
+            user_defined_functions: functions,
+            next_page_token: next,
+        }))
+    });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let functions = service
+        .list_user_defined_functions(String::new(), None, Some(3))
+        .await
+        .expect("list_user_defined_functions failed")
+        .items;
+
+    let ids: Vec<&str> = functions
+        .iter()
+        .map(|f| f.user_defined_function_id.as_str())
+        .collect();
+    assert_eq!(ids, vec!["f1", "f2", "f3"]);
+}
+
+#[tokio::test]
+async fn list_user_defined_functions_clamps_limit_to_page_size() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_functions()
+        .times(1)
+        .withf(|req| req.get_ref().page_size == 200)
+        .returning(|_| {
+            Ok(Response::new(ListUserDefinedFunctionsResponse {
+                user_defined_functions: vec![udf("f1", "a")],
+                next_page_token: String::new(),
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    service
+        .list_user_defined_functions(String::new(), None, Some(5_000))
+        .await
+        .expect("list_user_defined_functions failed");
+}
+
+#[tokio::test]
+async fn list_user_defined_functions_breaks_on_empty_page() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_functions()
+        .times(1)
+        .returning(|_| {
+            Ok(Response::new(ListUserDefinedFunctionsResponse {
+                user_defined_functions: vec![],
+                next_page_token: "ignored".into(),
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let functions = service
+        .list_user_defined_functions(String::new(), None, None)
+        .await
+        .expect("list_user_defined_functions failed")
+        .items;
+
+    assert!(functions.is_empty());
+}
+
+#[tokio::test]
+async fn list_user_defined_functions_propagates_grpc_error() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_functions()
+        .returning(|_| Err(Status::invalid_argument("bad filter")));
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let err = service
+        .list_user_defined_functions("nope".to_string(), None, None)
+        .await
+        .expect_err("expected error");
+
+    assert!(
+        err.to_string()
+            .contains("failed to query user defined functions")
+    );
+}
+
+#[tokio::test]
+async fn list_versions_sends_id_filter_and_order_by() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_function_versions()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            req.user_defined_function_id == "f1"
+                && req.name.is_empty()
+                && req.filter == "version == 2"
+                && req.order_by == "version desc"
+                && req.page_size == DEFAULT_LIMIT
+                && req.page_token.is_empty()
+        })
+        .returning(|_| {
+            Ok(Response::new(ListUserDefinedFunctionVersionsResponse {
+                user_defined_functions: vec![UserDefinedFunction {
+                    user_defined_function_id: "f1".into(),
+                    user_defined_function_version_id: "v2".into(),
+                    version: 2,
+                    ..Default::default()
+                }],
+                next_page_token: String::new(),
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let versions = service
+        .list_user_defined_function_versions(
+            "f1".to_string(),
+            String::new(),
+            "version == 2".to_string(),
+            Some("version desc".to_string()),
+            None,
+        )
+        .await
+        .expect("list_user_defined_function_versions failed")
+        .items;
+
+    assert_eq!(versions.len(), 1);
+    assert_eq!(versions[0].version, 2);
+}
+
+#[tokio::test]
+async fn list_versions_sends_name_when_id_is_empty() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_function_versions()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            req.user_defined_function_id.is_empty() && req.name == "rms"
+        })
+        .returning(|_| {
+            Ok(Response::new(ListUserDefinedFunctionVersionsResponse {
+                user_defined_functions: vec![udf("f1", "rms")],
+                next_page_token: String::new(),
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    service
+        .list_user_defined_function_versions(
+            String::new(),
+            "rms".to_string(),
+            String::new(),
+            None,
+            None,
+        )
+        .await
+        .expect("list_user_defined_function_versions failed");
+}
+
+#[tokio::test]
+async fn list_versions_paginates_and_truncates_to_limit() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_function_versions()
+        .returning(|req| {
+            let req = req.into_inner();
+            assert_eq!(req.page_size, 2);
+            let (functions, next) = match req.page_token.as_str() {
+                "" => (
+                    vec![
+                        UserDefinedFunction {
+                            version: 1,
+                            ..Default::default()
+                        },
+                        UserDefinedFunction {
+                            version: 2,
+                            ..Default::default()
+                        },
+                    ],
+                    "page-2".to_string(),
+                ),
+                "page-2" => (
+                    vec![UserDefinedFunction {
+                        version: 3,
+                        ..Default::default()
+                    }],
+                    String::new(),
+                ),
+                other => return Err(Status::invalid_argument(format!("bad token: {other}"))),
+            };
+            Ok(Response::new(ListUserDefinedFunctionVersionsResponse {
+                user_defined_functions: functions,
+                next_page_token: next,
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let versions = service
+        .list_user_defined_function_versions(
+            "f1".to_string(),
+            String::new(),
+            String::new(),
+            None,
+            Some(2),
+        )
+        .await
+        .expect("list_user_defined_function_versions failed")
+        .items;
+
+    let numbers: Vec<u32> = versions.iter().map(|v| v.version).collect();
+    assert_eq!(numbers, vec![1, 2]);
+}
+
+#[tokio::test]
+async fn list_versions_propagates_grpc_error() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_function_versions()
+        .returning(|_| Err(Status::not_found("no such function")));
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let err = service
+        .list_user_defined_function_versions(
+            "missing".to_string(),
+            String::new(),
+            String::new(),
+            None,
+            None,
+        )
+        .await
+        .expect_err("expected error");
+
+    assert!(
+        err.to_string()
+            .contains("failed to query user defined function versions")
+    );
+}
+
+#[tokio::test]
+async fn create_sends_every_provided_field() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_create_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            req.name == "rms"
+                && req.description.as_deref() == Some("root mean square")
+                && req.expression == "sqrt(mean($x * $x))"
+                && req.function_inputs.len() == 1
+                && req.function_inputs[0].identifier == "x"
+                && req.function_inputs[0].data_type == i32::from(FunctionDataType::Numeric)
+                && req.user_notes.as_deref() == Some("initial version")
+                && req.metadata.len() == 1
+        })
+        .returning(|req| {
+            let req = req.into_inner();
+            Ok(Response::new(CreateUserDefinedFunctionResponse {
+                user_defined_function: Some(UserDefinedFunction {
+                    user_defined_function_id: "f1".into(),
+                    user_defined_function_version_id: "v1".into(),
+                    version: 1,
+                    name: req.name,
+                    expression: req.expression,
+                    function_inputs: req.function_inputs,
+                    ..Default::default()
+                }),
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let created = service
+        .create_user_defined_function(
+            "rms".to_string(),
+            Some("root mean square".to_string()),
+            "sqrt(mean($x * $x))".to_string(),
+            vec![numeric_input("x")],
+            Some("initial version".to_string()),
+            vec![string_metadata("owner", "avionics")],
+        )
+        .await
+        .expect("create_user_defined_function failed");
+
+    assert_eq!(created.user_defined_function_id, "f1");
+    assert_eq!(created.version, 1);
+}
+
+#[tokio::test]
+async fn create_omits_optional_fields_when_absent() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_create_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            req.description.is_none() && req.user_notes.is_none() && req.metadata.is_empty()
+        })
+        .returning(|_| {
+            Ok(Response::new(CreateUserDefinedFunctionResponse {
+                user_defined_function: Some(udf("f1", "rms")),
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    service
+        .create_user_defined_function(
+            "rms".to_string(),
+            None,
+            "$x".to_string(),
+            vec![numeric_input("x")],
+            None,
+            Vec::new(),
+        )
+        .await
+        .expect("create_user_defined_function failed");
+}
+
+#[tokio::test]
+async fn create_errors_when_response_missing_function() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_create_user_defined_function().returning(|_| {
+        Ok(Response::new(CreateUserDefinedFunctionResponse {
+            user_defined_function: None,
+        }))
+    });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let err = service
+        .create_user_defined_function(
+            "rms".to_string(),
+            None,
+            "$x".to_string(),
+            vec![numeric_input("x")],
+            None,
+            Vec::new(),
+        )
+        .await
+        .expect_err("expected error");
+
+    assert!(
+        err.to_string()
+            .contains("create_user_defined_function response missing user defined function")
+    );
+}
+
+#[tokio::test]
+async fn create_propagates_grpc_error() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_create_user_defined_function()
+        .returning(|_| Err(Status::invalid_argument("bad expression")));
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let err = service
+        .create_user_defined_function(
+            "rms".to_string(),
+            None,
+            "nonsense(".to_string(),
+            vec![],
+            None,
+            Vec::new(),
+        )
+        .await
+        .expect_err("expected error");
+
+    assert!(
+        err.to_string()
+            .contains("failed to create user defined function")
+    );
+}
+
+#[tokio::test]
+async fn update_masks_only_the_provided_fields() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "f1", "existing notes");
+    mock.expect_update_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            let function = req
+                .user_defined_function
+                .as_ref()
+                .expect("function present");
+            let mask = req.update_mask.as_ref().expect("mask present");
+            function.user_defined_function_id == "f1"
+                && function.description == "updated"
+                && function.user_notes == "existing notes"
+                && function.expression.is_empty()
+                && function.function_inputs.is_empty()
+                && function.metadata.is_empty()
+                && mask.paths == vec!["description".to_string()]
+        })
+        .returning(|req| {
+            let req = req.into_inner();
+            Ok(Response::new(UpdateUserDefinedFunctionResponse {
+                user_defined_function: req.user_defined_function,
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let updated = service
+        .update_user_defined_function(
+            "f1".to_string(),
+            UdfUpdate {
+                description: Some("updated".to_string()),
+                ..Default::default()
+            },
+        )
+        .await
+        .expect("update_user_defined_function failed");
+
+    assert_eq!(updated.user_defined_function_id, "f1");
+}
+
+#[tokio::test]
+async fn update_masks_every_provided_field_in_declaration_order() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "f1", "");
+    mock.expect_update_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            let function = req
+                .user_defined_function
+                .as_ref()
+                .expect("function present");
+            let mask = req.update_mask.as_ref().expect("mask present");
+            function.name == "rms_v2"
+                && function.description == "updated"
+                && function.expression == "$x * 2"
+                && function.function_inputs.len() == 1
+                && function.metadata.len() == 1
+                && mask.paths
+                    == vec![
+                        "name".to_string(),
+                        "description".to_string(),
+                        "expression".to_string(),
+                        "function_inputs".to_string(),
+                        "metadata".to_string(),
+                    ]
+        })
+        .returning(|req| {
+            let req = req.into_inner();
+            Ok(Response::new(UpdateUserDefinedFunctionResponse {
+                user_defined_function: req.user_defined_function,
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    service
+        .update_user_defined_function(
+            "f1".to_string(),
+            UdfUpdate {
+                name: Some("rms_v2".to_string()),
+                description: Some("updated".to_string()),
+                expression: Some("$x * 2".to_string()),
+                function_inputs: Some(vec![numeric_input("x")]),
+                metadata: Some(vec![string_metadata("owner", "avionics")]),
+            },
+        )
+        .await
+        .expect("update_user_defined_function failed");
+}
+
+#[tokio::test]
+async fn update_sends_no_version_precondition() {
+    // `UpdateUserDefinedFunctionRequest` has no version precondition field: the
+    // service always creates a new version and returns it. Assert the request
+    // carries no stale version identifiers that could be mistaken for one, and
+    // that the caller sees the new version from the response.
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "f1", "");
+    mock.expect_update_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let function = req
+                .get_ref()
+                .user_defined_function
+                .as_ref()
+                .expect("function present");
+            function.version == 0
+                && function.user_defined_function_version_id.is_empty()
+                && function.function_dependencies.is_empty()
+        })
+        .returning(|req| {
+            let req = req.into_inner();
+            let mut function = req.user_defined_function.expect("function present");
+            function.version = 7;
+            function.user_defined_function_version_id = "v7".into();
+            Ok(Response::new(UpdateUserDefinedFunctionResponse {
+                user_defined_function: Some(function),
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let updated = service
+        .update_user_defined_function(
+            "f1".to_string(),
+            UdfUpdate {
+                expression: Some("$x + 1".to_string()),
+                ..Default::default()
+            },
+        )
+        .await
+        .expect("update_user_defined_function failed");
+
+    assert_eq!(updated.version, 7);
+    assert_eq!(updated.user_defined_function_version_id, "v7");
+}
+
+#[tokio::test]
+async fn update_with_no_fields_sends_an_empty_mask() {
+    // The tool handler rejects this case; the service contract is to send
+    // exactly what it was given.
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "f1", "");
+    mock.expect_update_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            let function = req
+                .user_defined_function
+                .as_ref()
+                .expect("function present");
+            let mask = req.update_mask.as_ref().expect("mask present");
+            function.user_defined_function_id == "f1" && mask.paths.is_empty()
+        })
+        .returning(|req| {
+            let req = req.into_inner();
+            Ok(Response::new(UpdateUserDefinedFunctionResponse {
+                user_defined_function: req.user_defined_function,
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    service
+        .update_user_defined_function("f1".to_string(), UdfUpdate::default())
+        .await
+        .expect("update_user_defined_function failed");
+}
+
+#[tokio::test]
+async fn update_errors_when_response_missing_function() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "f1", "");
+    mock.expect_update_user_defined_function().returning(|_| {
+        Ok(Response::new(UpdateUserDefinedFunctionResponse {
+            user_defined_function: None,
+        }))
+    });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let err = service
+        .update_user_defined_function(
+            "f1".to_string(),
+            UdfUpdate {
+                description: Some("x".to_string()),
+                ..Default::default()
+            },
+        )
+        .await
+        .expect_err("expected error");
+
+    assert!(
+        err.to_string()
+            .contains("update_user_defined_function response missing user defined function")
+    );
+}
+
+#[tokio::test]
+async fn update_propagates_grpc_error() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "f1", "");
+    mock.expect_update_user_defined_function()
+        .returning(|_| Err(Status::failed_precondition("function has dependents")));
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let err = service
+        .update_user_defined_function(
+            "f1".to_string(),
+            UdfUpdate {
+                function_inputs: Some(vec![numeric_input("x")]),
+                ..Default::default()
+            },
+        )
+        .await
+        .expect_err("expected error");
+
+    assert!(
+        err.to_string()
+            .contains("failed to update user defined function")
+    );
+}
+
+#[tokio::test]
+async fn archive_sets_is_archived_true_through_the_mask() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "f1", "archived notes");
+    mock.expect_update_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            let function = req
+                .user_defined_function
+                .as_ref()
+                .expect("function present");
+            let mask = req.update_mask.as_ref().expect("mask present");
+            function.user_defined_function_id == "f1"
+                && function.is_archived
+                && function.user_notes == "archived notes"
+                && function.archived_date.is_none()
+                && mask.paths == vec!["is_archived".to_string()]
+        })
+        .returning(|req| {
+            let req = req.into_inner();
+            Ok(Response::new(UpdateUserDefinedFunctionResponse {
+                user_defined_function: req.user_defined_function,
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let archived = service
+        .set_user_defined_function_archived("f1".to_string(), true)
+        .await
+        .expect("set_user_defined_function_archived failed");
+
+    assert!(archived.is_archived);
+}
+
+#[tokio::test]
+async fn unarchive_sets_is_archived_false_through_the_mask() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "f2", "");
+    mock.expect_update_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            let function = req
+                .user_defined_function
+                .as_ref()
+                .expect("function present");
+            let mask = req.update_mask.as_ref().expect("mask present");
+            function.user_defined_function_id == "f2"
+                && !function.is_archived
+                && mask.paths == vec!["is_archived".to_string()]
+        })
+        .returning(|req| {
+            let req = req.into_inner();
+            Ok(Response::new(UpdateUserDefinedFunctionResponse {
+                user_defined_function: req.user_defined_function,
+            }))
+        });
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let unarchived = service
+        .set_user_defined_function_archived("f2".to_string(), false)
+        .await
+        .expect("set_user_defined_function_archived failed");
+
+    assert!(!unarchived.is_archived);
+}
+
+#[tokio::test]
+async fn set_archived_propagates_grpc_error() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "missing", "");
+    mock.expect_update_user_defined_function()
+        .returning(|_| Err(Status::not_found("function missing")));
+
+    let (service, _h) = service_with_mock(mock).await;
+
+    let err = service
+        .set_user_defined_function_archived("missing".to_string(), true)
+        .await
+        .expect_err("expected error");
+
+    assert!(
+        err.to_string()
+            .contains("failed to update user defined function")
+    );
+}
diff --git a/rust/crates/sift_mcp/src/tool/annotations/mod.rs b/rust/crates/sift_mcp/src/tool/annotations/mod.rs
index 528cf390a..5e48e73e7 100644
--- a/rust/crates/sift_mcp/src/tool/annotations/mod.rs
+++ b/rust/crates/sift_mcp/src/tool/annotations/mod.rs
@@ -20,6 +20,16 @@ use crate::{
 #[cfg(test)]
 mod test;
 
+const MAX_UPDATE_ANNOTATIONS: usize = 1_000;
+
+fn upstream_error_message(error: &anyhow::Error) -> String {
+    if let Some(status) = error.downcast_ref::<tonic::Status>() {
+        format!("{}: {}", status.code(), status.message())
+    } else {
+        error.to_string()
+    }
+}
+
 #[derive(Debug, Deserialize, JsonSchema)]
 pub struct AnnotationListParams {
     pub(crate) filter: String,
@@ -48,7 +58,7 @@ pub struct CreateAnnotationParams {
 
 #[derive(Debug, Deserialize, JsonSchema)]
 pub struct UpdateAnnotationParams {
-    annotation_id: String,
+    annotation_ids: Vec<String>,
     name: Option<String>,
     description: Option<String>,
     start_time_unix_nanos: Option<i64>,
@@ -58,6 +68,7 @@ pub struct UpdateAnnotationParams {
     tags: Option<Vec<String>>,
     linked_channel_ids: Option<Vec<String>>,
     metadata: Option<Vec<MetadataEntry>>,
+    is_archived: Option<bool>,
 }
 
 fn parse_annotation_type(s: &str) -> Result<AnnotationType, ErrorData> {
@@ -305,15 +316,22 @@ impl SiftMcpServer {
     #[tool(
         name = "update_annotation",
         description = "
-            Update an existing annotation. Wraps `annotations/v1 UpdateAnnotation`.
+            Update one or more existing annotations. Uses `annotations/v1 BatchArchiveAnnotations` when archiving
+            and one `UpdateAnnotation` request per annotation when unarchiving.
 
             Output:
-              - `{ \"annotation\": Annotation, \"annotation_url\": string|null, \"next_step\": string }`. The
-                returned `Annotation` is the post-update state from the server; `annotation_url` is its Sift web
-                link, or null when the host can't be derived.
+              - `{ \"annotations\": [Annotation, ...], \"failures\": [...], \"batch_archive_error\": object|null,
+                \"not_attempted\": [string, ...], \"archive_skipped\": bool, \"next_step\": string }`. Successful
+                annotations include a `url` field when the host can be derived. Each individual failure includes
+                `annotation_id` and an upstream `message`. `batch_archive_error` includes `annotation_ids` and an
+                upstream `message` only for a failed `BatchArchiveAnnotations` request. Partial failures set the tool result's
+                `isError` flag. `archive_skipped` is true when the requested archive-state change was not attempted
+                because field updates failed.
 
             Parameters:
-              - `annotation_id`: required; the id of the annotation to update.
+              - `annotation_ids`: required list of 1 to 1000 annotation ids. The same changes are applied to every
+                annotation. This replaces the former `annotation_id` parameter; pass a single annotation as a
+                one-element list.
               - `name`: optional new name.
               - `description`: optional new description.
               - `start_time_unix_nanos` / `end_time_unix_nanos`: optional new time bounds in Unix nanoseconds.
@@ -324,17 +342,28 @@ impl SiftMcpServer {
                 Pass `[]` to clear. Bit-field and calculated-channel links are not exposed here.
               - `metadata`: optional; REPLACES the full metadata list. Each entry is
                 `{ \"name\": \"<key>\", \"value\": <scalar> }`. Pass `[]` to clear.
+              - `is_archived`: optional archive state. `true` uses one batch-archive request; `false` uses one
+                per-annotation update request that clears the annotation's delete date. When combined with other
+                fields, annotations are updated before their archive state changes.
 
               At least one updatable field must be set; otherwise the tool returns `INVALID_PARAMS`.
 
             Errors:
-              - `INVALID_PARAMS` if `annotation_id` is empty, `state` is unrecognized, or no updatable field is set.
-              - `RESOURCE_NOT_FOUND` if no annotation matches `annotation_id`.
-              - `INTERNAL_ERROR` for upstream gRPC failures.
+              - `INVALID_PARAMS` if `annotation_ids` is empty, contains an empty id, exceeds 1000 ids, `state` is
+                unrecognized, or no updatable field is set.
+              - Individual upstream failures, including unarchive failures, are returned in `failures` next to
+                successful results. Follow each failure's guidance and retry only eligible failed ids.
+              - Backend-wide failures stop later batches. Their ids are returned in `not_attempted` without an API
+                request.
+              - Batch archive failures are returned in `batch_archive_error`. The archive outcome may be unknown.
 
             Guidance:
-              - This is a write. CONFIRM the target and the full proposed values with the user before invoking —
+              - This is a write. CONFIRM every target and the full proposed values with the user before invoking —
                 `tags`, `linked_channel_ids`, and `metadata` are REPLACE operations, not merges.
+              - General field updates and unarchive issue one API request per annotation and are not atomic. Requests
+                run in batches of up to 50. A backend-wide failure stops later batches. Archive uses one batch API
+                request. Requested archive-state changes begin only after all individual updates succeed; otherwise
+                `archive_skipped` is true.
               - For appends, read the current annotation via `list_annotations` filtered by
                 `annotation_id == \"<id>\"`, then send the union.
         ",
@@ -352,7 +381,7 @@ impl SiftMcpServer {
         self.require_destructive()?;
 
         let Parameters(UpdateAnnotationParams {
-            annotation_id,
+            annotation_ids,
             name,
             description,
             start_time_unix_nanos,
@@ -362,16 +391,31 @@ impl SiftMcpServer {
             tags,
             linked_channel_ids,
             metadata,
+            is_archived,
         }) = params;
 
-        if annotation_id.is_empty() {
+        if annotation_ids.is_empty() {
             return Err(ErrorData::invalid_params(
-                "`annotation_id` must not be empty",
+                "`annotation_ids` must contain at least one id",
                 None,
             ));
         }
 
-        let has_update = name.is_some()
+        if annotation_ids.len() > MAX_UPDATE_ANNOTATIONS {
+            return Err(ErrorData::invalid_params(
+                format!("`annotation_ids` must contain at most {MAX_UPDATE_ANNOTATIONS} ids"),
+                None,
+            ));
+        }
+
+        if annotation_ids.iter().any(String::is_empty) {
+            return Err(ErrorData::invalid_params(
+                "`annotation_ids` must not contain empty ids",
+                None,
+            ));
+        }
+
+        let has_field_update = name.is_some()
             || description.is_some()
             || start_time_unix_nanos.is_some()
             || end_time_unix_nanos.is_some()
@@ -380,7 +424,7 @@ impl SiftMcpServer {
             || tags.is_some()
             || linked_channel_ids.is_some()
             || metadata.is_some();
-        if !has_update {
+        if !has_field_update && is_archived.is_none() {
             return Err(ErrorData::invalid_params(
                 "at least one updatable field must be provided",
                 None,
@@ -389,11 +433,12 @@ impl SiftMcpServer {
 
         let state = state.map(|s| parse_annotation_state(&s)).transpose()?;
         let metadata = metadata.map(|m| m.into_iter().map(MetadataValue::from).collect::<Vec<_>>());
-
-        let annotation = self
+        let requested_ids = annotation_ids.clone();
+        let requested_count = annotation_ids.len();
+        let outcome = self
             .annotation_service
-            .update_annotation(
-                annotation_id,
+            .update_annotations(
+                annotation_ids,
                 name,
                 description,
                 start_time_unix_nanos,
@@ -403,27 +448,91 @@ impl SiftMcpServer {
                 tags,
                 linked_channel_ids,
                 metadata,
+                is_archived,
             )
             .await
             .map_err(from_anyhow)?;
 
-        let annotation_url = self
-            .url_service
-            .build_annotation_url(&annotation.annotation_id)
-            .ok();
-        let next_step = format!(
-            "Updated annotation `{}` ({}).{} Surface the new state to the user and confirm the change \
-             matches their intent. Remember: tags, linked channels, and metadata are REPLACE operations.",
-            annotation.name,
-            annotation.annotation_id,
-            url_clause(annotation_url.as_deref()),
-        );
-
-        let mut result = CallToolResult::structured(serde_json::json!({
-            "annotation": annotation,
-            "annotation_url": annotation_url,
+        let updated_count = outcome.annotations.len();
+        let failures = outcome
+            .failures
+            .into_iter()
+            .map(|failure| {
+                serde_json::json!({
+                    "annotation_id": failure.annotation_id,
+                    "message": upstream_error_message(&failure.error),
+                })
+            })
+            .collect::<Vec<_>>();
+        let failure_count = failures.len();
+        let not_attempted = outcome.not_attempted;
+        let not_attempted_count = not_attempted.len();
+        let batch_archive_error = outcome.batch_archive_error.map(|error| {
+            serde_json::json!({
+                "annotation_ids": requested_ids,
+                "message": upstream_error_message(&error),
+            })
+        });
+        let has_errors =
+            failure_count > 0 || not_attempted_count > 0 || batch_archive_error.is_some();
+
+        let annotations = outcome.annotations;
+        let annotations = with_urls(&annotations, |annotation| {
+            self.url_service
+                .build_annotation_url(&annotation.annotation_id)
+                .ok()
+        })?;
+        let next_step = if batch_archive_error.is_some() {
+            format!(
+                "Completed field updates for {updated_count} of {requested_count} annotation(s), but batch archive \
+                 failed. Archive state may be unknown. Verify the targets with `list_annotations` before retrying.",
+            )
+        } else if outcome.archive_skipped {
+            if not_attempted_count > 0 {
+                format!(
+                    "Updated {updated_count} of {requested_count} annotation(s); {failure_count} failed and \
+                     {not_attempted_count} were not attempted after a backend-wide failure. The archive state change was not \
+                     attempted. Review `failures` before retrying eligible failed and not-attempted ids."
+                )
+            } else {
+                format!(
+                    "Updated {updated_count} of {requested_count} annotation(s); {failure_count} failed. The archive state change was \
+                     not attempted because individual updates failed. Review `failures`, follow their guidance, and \
+                     retry only eligible failed ids."
+                )
+            }
+        } else if not_attempted_count > 0 {
+            format!(
+                "Updated {updated_count} of {requested_count} annotation(s); {failure_count} failed and \
+                 {not_attempted_count} were not attempted after a backend-wide failure. Review `failures` before \
+                 retrying eligible failed and not-attempted ids."
+            )
+        } else if failure_count > 0 {
+            format!(
+                "Updated {updated_count} of {requested_count} annotation(s); {failure_count} failed. Successful \
+                 annotations are already changed. Review `failures`, follow their guidance, and retry only eligible \
+                 failed ids."
+            )
+        } else {
+            format!(
+                "Updated {updated_count} annotation(s). Surface the new states and links to the user and confirm the \
+                 changes match their intent. Remember: tags, linked channels, and metadata are REPLACE operations."
+            )
+        };
+
+        let structured = serde_json::json!({
+            "annotations": annotations,
+            "failures": failures,
+            "not_attempted": not_attempted,
+            "batch_archive_error": batch_archive_error,
+            "archive_skipped": outcome.archive_skipped,
             "next_step": next_step,
-        }));
+        });
+        let mut result = if has_errors {
+            CallToolResult::structured_error(structured)
+        } else {
+            CallToolResult::structured(structured)
+        };
         result.content = vec![ContentBlock::text(next_step)];
         Ok(result)
     }
diff --git a/rust/crates/sift_mcp/src/tool/annotations/test.rs b/rust/crates/sift_mcp/src/tool/annotations/test.rs
index 614f10641..a0f00ad9d 100644
--- a/rust/crates/sift_mcp/src/tool/annotations/test.rs
+++ b/rust/crates/sift_mcp/src/tool/annotations/test.rs
@@ -1,14 +1,22 @@
+use std::sync::{
+    Arc,
+    atomic::{AtomicUsize, Ordering},
+};
+
 use rmcp::{handler::server::wrapper::Parameters, model::ErrorCode};
 use sift_rs::annotations::v1::{
-    Annotation, CreateAnnotationResponse, ListAnnotationsResponse, UpdateAnnotationResponse,
-    annotation_service_server::AnnotationServiceServer,
+    Annotation, BatchArchiveAnnotationsResponse, CreateAnnotationResponse, ListAnnotationsResponse,
+    UpdateAnnotationResponse, annotation_service_server::AnnotationServiceServer,
 };
 use sift_test_util::{grpc::memory_sift_channel, mock::annotations::v1::MockAnnotationServiceImpl};
 use tokio::task::JoinHandle;
 use tonic::{Response, Status, transport::Server};
 
 use super::{AnnotationListParams, CreateAnnotationParams, UpdateAnnotationParams};
-use crate::{server::SiftMcpServer, tool::common::test_support::structured_field};
+use crate::{
+    server::SiftMcpServer,
+    tool::common::test_support::{structured, structured_field},
+};
 
 async fn server_with_mock(mock: MockAnnotationServiceImpl) -> (SiftMcpServer, JoinHandle<()>) {
     let (client, server) = tokio::io::duplex(1024);
@@ -48,7 +56,7 @@ fn create_params() -> CreateAnnotationParams {
 
 fn update_params(annotation_id: &str) -> UpdateAnnotationParams {
     UpdateAnnotationParams {
-        annotation_id: annotation_id.into(),
+        annotation_ids: vec![annotation_id.into()],
         name: None,
         description: None,
         start_time_unix_nanos: None,
@@ -58,9 +66,20 @@ fn update_params(annotation_id: &str) -> UpdateAnnotationParams {
         tags: None,
         linked_channel_ids: None,
         metadata: None,
+        is_archived: None,
     }
 }
 
+#[test]
+fn update_annotation_params_accept_bulk_ids() {
+    let params = serde_json::from_value::<UpdateAnnotationParams>(serde_json::json!({
+        "annotation_ids": ["ann1", "ann2"],
+        "name": "renamed",
+    }));
+
+    assert!(params.is_ok());
+}
+
 #[tokio::test]
 async fn list_annotations_returns_single_page() {
     let mut mock = MockAnnotationServiceImpl::new();
@@ -208,8 +227,445 @@ async fn update_annotation_happy_path() {
         .await
         .expect("update_annotation failed");
 
-    let annotation = structured_field(resp, "annotation");
-    assert_eq!(annotation["name"], "renamed");
+    let annotations = structured_field(resp, "annotations");
+    assert_eq!(annotations[0]["name"], "renamed");
+    assert_eq!(
+        annotations[0]["url"],
+        "https://app.test.local/annotation/ann1"
+    );
+}
+
+#[tokio::test]
+async fn update_annotation_updates_each_annotation() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_update_annotation().times(2).returning(|req| {
+        let annotation = req.into_inner().annotation.unwrap();
+        Ok(Response::new(UpdateAnnotationResponse {
+            annotation: Some(annotation),
+        }))
+    });
+
+    let (server, _h) = server_with_mock(mock).await;
+
+    let mut params = update_params("ann1");
+    params.annotation_ids.push("ann2".into());
+    params.name = Some("renamed".into());
+
+    let resp = server
+        .update_annotation(Parameters(params))
+        .await
+        .expect("update_annotation failed");
+
+    let annotations = structured_field(resp, "annotations");
+    assert_eq!(annotations[0]["annotationId"], "ann1");
+    assert_eq!(annotations[1]["annotationId"], "ann2");
+}
+
+#[tokio::test]
+async fn update_annotation_reports_partial_failures_and_continues() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_update_annotation().times(3).returning(|req| {
+        let annotation = req.into_inner().annotation.unwrap();
+        if annotation.annotation_id == "ann2" {
+            return Err(Status::not_found("no such annotation"));
+        }
+        Ok(Response::new(UpdateAnnotationResponse {
+            annotation: Some(annotation),
+        }))
+    });
+
+    let (server, _h) = server_with_mock(mock).await;
+
+    let mut params = update_params("ann1");
+    params.annotation_ids.extend(["ann2".into(), "ann3".into()]);
+    params.name = Some("renamed".into());
+
+    let resp = server
+        .update_annotation(Parameters(params))
+        .await
+        .expect("partial update result should be returned");
+
+    assert_eq!(resp.is_error, Some(true));
+    let content = serde_json::to_string(&resp.content).expect("content should serialize");
+    assert_eq!(resp.content.len(), 1);
+    assert!(!content.contains("ann2"));
+    assert!(!content.contains("no such annotation"));
+    let body = structured(resp);
+    assert_eq!(body["annotations"][0]["annotationId"], "ann1");
+    assert_eq!(body["annotations"][1]["annotationId"], "ann3");
+    assert_eq!(body["failures"][0]["annotation_id"], "ann2");
+    assert_eq!(
+        body["failures"][0]["message"],
+        "Some requested entity was not found: no such annotation"
+    );
+    assert_eq!(body["not_attempted"], serde_json::json!([]));
+}
+
+#[tokio::test]
+async fn update_annotation_reports_ids_not_attempted_after_backend_wide_failure() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_update_annotation()
+        .times(50)
+        .returning(|_| Err(Status::resource_exhausted("slow down")));
+
+    let (server, _h) = server_with_mock(mock).await;
+
+    let mut params = update_params("ann0");
+    params
+        .annotation_ids
+        .extend((1..60).map(|index| format!("ann{index}")));
+    params.name = Some("renamed".into());
+
+    let resp = server
+        .update_annotation(Parameters(params))
+        .await
+        .expect("partial update result should be returned");
+
+    assert_eq!(resp.is_error, Some(true));
+    let content = serde_json::to_string(&resp.content).expect("content should serialize");
+    assert_eq!(resp.content.len(), 1);
+    assert!(!content.contains("ann0"));
+    assert!(!content.contains("ann59"));
+    let body = structured(resp);
+    assert_eq!(body["failures"].as_array().unwrap().len(), 50);
+    assert_eq!(body["not_attempted"].as_array().unwrap().len(), 10);
+    assert_eq!(body["not_attempted"][0], "ann50");
+    assert_eq!(body["not_attempted"][9], "ann59");
+}
+
+#[tokio::test]
+async fn update_annotation_batch_archives_annotations() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_batch_archive_annotations()
+        .withf(|req| req.get_ref().annotation_ids == ["ann1", "ann2"])
+        .returning(|_| {
+            Ok(Response::new(BatchArchiveAnnotationsResponse {
+                annotations: vec![
+                    Annotation {
+                        annotation_id: "ann1".into(),
+                        is_archived: true,
+                        ..Default::default()
+                    },
+                    Annotation {
+                        annotation_id: "ann2".into(),
+                        is_archived: true,
+                        ..Default::default()
+                    },
+                ],
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock).await;
+
+    let mut params = update_params("ann1");
+    params.annotation_ids.push("ann2".into());
+    params.is_archived = Some(true);
+
+    let resp = server
+        .update_annotation(Parameters(params))
+        .await
+        .expect("update_annotation failed");
+
+    let annotations = structured_field(resp, "annotations");
+    assert_eq!(annotations.as_array().unwrap().len(), 2);
+    assert_eq!(annotations[0]["isArchived"], true);
+}
+
+#[tokio::test]
+async fn update_annotation_updates_fields_before_archiving() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    let updated_count = Arc::new(AtomicUsize::new(0));
+
+    let update_count = Arc::clone(&updated_count);
+    mock.expect_update_annotation()
+        .times(2)
+        .returning(move |req| {
+            update_count.fetch_add(1, Ordering::SeqCst);
+            let annotation = req.into_inner().annotation.unwrap();
+            Ok(Response::new(UpdateAnnotationResponse {
+                annotation: Some(annotation),
+            }))
+        });
+
+    let archive_count = Arc::clone(&updated_count);
+    mock.expect_batch_archive_annotations()
+        .withf(move |_| archive_count.load(Ordering::SeqCst) == 2)
+        .returning(|req| {
+            let annotations = req
+                .into_inner()
+                .annotation_ids
+                .into_iter()
+                .map(|annotation_id| Annotation {
+                    annotation_id,
+                    is_archived: true,
+                    ..Default::default()
+                })
+                .collect();
+            Ok(Response::new(BatchArchiveAnnotationsResponse {
+                annotations,
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock).await;
+
+    let mut params = update_params("ann1");
+    params.annotation_ids.push("ann2".into());
+    params.name = Some("renamed".into());
+    params.is_archived = Some(true);
+
+    server
+        .update_annotation(Parameters(params))
+        .await
+        .expect("update_annotation failed");
+}
+
+#[tokio::test]
+async fn update_annotation_skips_archive_after_partial_field_failure() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_update_annotation().times(2).returning(|req| {
+        let annotation = req.into_inner().annotation.unwrap();
+        if annotation.annotation_id == "ann2" {
+            return Err(Status::not_found("no such annotation"));
+        }
+        Ok(Response::new(UpdateAnnotationResponse {
+            annotation: Some(annotation),
+        }))
+    });
+    mock.expect_batch_archive_annotations().times(0);
+
+    let (server, _h) = server_with_mock(mock).await;
+
+    let mut params = update_params("ann1");
+    params.annotation_ids.push("ann2".into());
+    params.name = Some("renamed".into());
+    params.is_archived = Some(true);
+
+    let resp = server
+        .update_annotation(Parameters(params))
+        .await
+        .expect("partial update result should be returned");
+
+    assert_eq!(resp.is_error, Some(true));
+    let body = structured(resp);
+    assert_eq!(body["archive_skipped"], true);
+    assert_eq!(body["annotations"][0]["annotationId"], "ann1");
+    assert_eq!(body["failures"][0]["annotation_id"], "ann2");
+}
+
+#[tokio::test]
+async fn update_annotation_reports_batch_archive_error() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_batch_archive_annotations()
+        .returning(|_| Err(Status::not_found("one target was not found")));
+
+    let (server, _h) = server_with_mock(mock).await;
+
+    let mut params = update_params("ann1");
+    params.annotation_ids.push("ann2".into());
+    params.is_archived = Some(true);
+
+    let resp = server
+        .update_annotation(Parameters(params))
+        .await
+        .expect("batch archive failure details should be returned");
+
+    assert_eq!(resp.is_error, Some(true));
+    let body = structured(resp);
+    assert_eq!(
+        body["batch_archive_error"]["annotation_ids"],
+        serde_json::json!(["ann1", "ann2"])
+    );
+    assert_eq!(
+        body["batch_archive_error"]["message"],
+        "Some requested entity was not found: one target was not found"
+    );
+    assert!(body["batch_archive_error"].get("code").is_none());
+}
+
+#[tokio::test]
+#[allow(deprecated)] // The backend requires this deprecated field to unarchive annotations.
+async fn update_annotation_reports_partial_unarchive_failures() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_update_annotation().times(2).returning(|req| {
+        let req = req.into_inner();
+        assert_eq!(req.update_mask.unwrap().paths, ["deleted_date"]);
+        let annotation = req.annotation.unwrap();
+        assert_eq!(annotation.deleted_date, None);
+        let annotation_id = annotation.annotation_id;
+        if annotation_id == "ann2" {
+            return Err(Status::not_found("no such annotation"));
+        }
+        Ok(Response::new(UpdateAnnotationResponse {
+            annotation: Some(Annotation {
+                annotation_id,
+                is_archived: false,
+                ..Default::default()
+            }),
+        }))
+    });
+
+    let (server, _h) = server_with_mock(mock).await;
+
+    let mut params = update_params("ann1");
+    params.annotation_ids.push("ann2".into());
+    params.is_archived = Some(false);
+
+    let resp = server
+        .update_annotation(Parameters(params))
+        .await
+        .expect("partial unarchive result should be returned");
+
+    assert_eq!(resp.is_error, Some(true));
+    let body = structured(resp);
+    assert_eq!(body["annotations"][0]["annotationId"], "ann1");
+    assert_eq!(body["failures"][0]["annotation_id"], "ann2");
+    assert_eq!(
+        body["failures"][0]["message"],
+        "Some requested entity was not found: no such annotation"
+    );
+    assert_eq!(body["batch_archive_error"], serde_json::Value::Null);
+    assert!(body["failures"][0].get("code").is_none());
+}
+
+#[tokio::test]
+#[allow(deprecated)] // The backend requires this deprecated field to unarchive annotations.
+async fn update_annotation_batch_unarchives_annotations() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_update_annotation().times(2).returning(|req| {
+        let req = req.into_inner();
+        assert_eq!(req.update_mask.unwrap().paths, ["deleted_date"]);
+        let annotation = req.annotation.unwrap();
+        assert_eq!(annotation.deleted_date, None);
+        Ok(Response::new(UpdateAnnotationResponse {
+            annotation: Some(Annotation {
+                annotation_id: annotation.annotation_id,
+                is_archived: false,
+                ..Default::default()
+            }),
+        }))
+    });
+
+    let (server, _h) = server_with_mock(mock).await;
+
+    let mut params = update_params("ann1");
+    params.annotation_ids.push("ann2".into());
+    params.is_archived = Some(false);
+
+    let resp = server
+        .update_annotation(Parameters(params))
+        .await
+        .expect("update_annotation failed");
+
+    let annotations = structured_field(resp, "annotations");
+    assert_eq!(annotations.as_array().unwrap().len(), 2);
+    assert_eq!(annotations[0]["annotationId"], "ann1");
+    assert_eq!(annotations[1]["annotationId"], "ann2");
+}
+
+#[tokio::test]
+#[allow(deprecated)] // The backend requires this deprecated field to unarchive annotations.
+async fn update_annotation_reports_unarchive_ids_not_attempted_after_backend_wide_failure() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_update_annotation().times(50).returning(|req| {
+        let req = req.into_inner();
+        assert_eq!(req.update_mask.unwrap().paths, ["deleted_date"]);
+        assert_eq!(req.annotation.unwrap().deleted_date, None);
+        Err(Status::resource_exhausted("slow down"))
+    });
+
+    let (server, _h) = server_with_mock(mock).await;
+
+    let mut params = update_params("ann1");
+    params
+        .annotation_ids
+        .extend((2..=51).map(|index| format!("ann{index}")));
+    params.is_archived = Some(false);
+
+    let resp = server
+        .update_annotation(Parameters(params))
+        .await
+        .expect("partial unarchive result should be returned");
+
+    assert_eq!(resp.is_error, Some(true));
+    let body = structured(resp);
+    assert_eq!(body["failures"].as_array().unwrap().len(), 50);
+    assert_eq!(body["not_attempted"], serde_json::json!(["ann51"]));
+    assert_eq!(body["batch_archive_error"], serde_json::Value::Null);
+}
+
+#[tokio::test]
+#[allow(deprecated)] // The backend requires this deprecated field to unarchive annotations.
+async fn update_annotation_updates_fields_before_unarchiving() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    let updated_count = Arc::new(AtomicUsize::new(0));
+
+    let update_count = Arc::clone(&updated_count);
+    mock.expect_update_annotation()
+        .times(4)
+        .returning(move |req| {
+            let req = req.into_inner();
+            let paths = req.update_mask.unwrap().paths;
+            let annotation = req.annotation.unwrap();
+            if paths == ["deleted_date"] {
+                assert_eq!(update_count.load(Ordering::SeqCst), 2);
+                assert_eq!(annotation.deleted_date, None);
+            } else {
+                assert_eq!(paths, ["name"]);
+                update_count.fetch_add(1, Ordering::SeqCst);
+            }
+            Ok(Response::new(UpdateAnnotationResponse {
+                annotation: Some(annotation),
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock).await;
+
+    let mut params = update_params("ann1");
+    params.annotation_ids.push("ann2".into());
+    params.name = Some("renamed".into());
+    params.is_archived = Some(false);
+
+    server
+        .update_annotation(Parameters(params))
+        .await
+        .expect("update_annotation failed");
+}
+
+#[tokio::test]
+async fn update_annotation_rejects_empty_ids() {
+    let (server, _h) = server_with_mock(MockAnnotationServiceImpl::new()).await;
+
+    let mut params = update_params("ann1");
+    params.annotation_ids.clear();
+
+    let err = server
+        .update_annotation(Parameters(params))
+        .await
+        .expect_err("expected error");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+}
+
+#[tokio::test]
+async fn update_annotation_rejects_more_than_1000_ids_without_requests() {
+    let mut mock = MockAnnotationServiceImpl::new();
+    mock.expect_update_annotation().times(0);
+    mock.expect_batch_archive_annotations().times(0);
+
+    let (server, _h) = server_with_mock(mock).await;
+
+    let mut params = update_params("ann0");
+    params
+        .annotation_ids
+        .extend((1..=1_000).map(|index| format!("ann{index}")));
+    params.name = Some("renamed".into());
+
+    let err = server
+        .update_annotation(Parameters(params))
+        .await
+        .expect_err("expected error");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
 }
 
 #[tokio::test]
@@ -247,10 +703,16 @@ async fn update_annotation_propagates_grpc_error() {
     let mut params = update_params("ann1");
     params.name = Some("x".into());
 
-    let err = server
+    let resp = server
         .update_annotation(Parameters(params))
         .await
-        .expect_err("expected error");
+        .expect("failure details should be returned");
 
-    assert_eq!(err.code, ErrorCode::RESOURCE_NOT_FOUND);
+    assert_eq!(resp.is_error, Some(true));
+    let body = structured(resp);
+    assert_eq!(body["failures"][0]["annotation_id"], "ann1");
+    assert_eq!(
+        body["failures"][0]["message"],
+        "Some requested entity was not found: no such annotation"
+    );
 }
diff --git a/rust/crates/sift_mcp/src/tool/mod.rs b/rust/crates/sift_mcp/src/tool/mod.rs
index 331d92b16..dc9858e1f 100644
--- a/rust/crates/sift_mcp/src/tool/mod.rs
+++ b/rust/crates/sift_mcp/src/tool/mod.rs
@@ -9,9 +9,11 @@ pub mod explore;
 pub mod ping;
 pub mod report_templates;
 pub mod reports;
+pub mod rule_evaluation;
 pub mod rules;
 pub mod runs;
 #[cfg(feature = "test-reports")]
 pub mod test_reports;
 pub mod update;
+pub mod user_defined_functions;
 pub mod users;
diff --git a/rust/crates/sift_mcp/src/tool/rule_evaluation/mod.rs b/rust/crates/sift_mcp/src/tool/rule_evaluation/mod.rs
new file mode 100644
index 000000000..6eef4bc4b
--- /dev/null
+++ b/rust/crates/sift_mcp/src/tool/rule_evaluation/mod.rs
@@ -0,0 +1,194 @@
+use rmcp::{
+    ErrorData,
+    handler::server::wrapper::Parameters,
+    model::{CallToolResult, ContentBlock},
+    schemars::{self, JsonSchema},
+    tool, tool_router,
+};
+use serde::Deserialize;
+use sift_rs::rules::v1::UpdateRuleRequest;
+
+use crate::{
+    error::{self, from_anyhow},
+    server::SiftMcpServer,
+    service::{common::cel_escape, rule_evaluation::PreviewRuleSource},
+};
+
+#[cfg(test)]
+mod test;
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct PreviewRuleParams {
+    pub(crate) run_id: String,
+    pub(crate) rule_id: Option<String>,
+    pub(crate) rule_name: Option<String>,
+    pub(crate) draft_rule_config: Option<String>,
+    pub(crate) organization_id: Option<String>,
+}
+
+/// Which saved-rule selector the caller gave, prior to resolving a name to an id.
+enum SavedRuleSelector {
+    Id(String),
+    Name(String),
+}
+
+#[tool_router(router = rule_evaluation_router, vis = "pub(crate)")]
+impl SiftMcpServer {
+    #[tool(
+        name = "preview_rule",
+        description = "
+            Dry-run a rule against a run and return the annotations that would be generated. This is a READ-ONLY
+            action: nothing is persisted (no report, annotation, or rule version is created). To persist an
+            evaluation, use `create_report` instead once the preview looks right.
+
+            Output:
+              - `{ \"created_annotation_count\": number, \"dry_run_annotations\": [DryRunAnnotation, ...],
+                \"next_step\": string }`. Each `DryRunAnnotation` has `condition_id`, `name`, `start_time`,
+                `end_time`, and `condition_version_id` for one annotation the rule would create.
+
+            Parameters:
+              - `run_id`: required; the run to evaluate the rule against.
+              - The rule under test is one of two mutually exclusive shapes — provide exactly one:
+                - SAVED rule: set `rule_id` or `rule_name` (not both). `rule_name` is resolved to a rule id via an
+                  exact `name ==` lookup; if more than one rule shares the name, an arbitrary match is used, so
+                  prefer `rule_id` when it's known.
+                - DRAFT rule: set `draft_rule_config`, a JSON string matching
+                  `protos/sift/rules/v1/rules.proto::UpdateRuleRequest` — the same shape `create_rule` takes as
+                  `rule_json`. Nothing is looked up or saved for this shape; the whole definition travels in the
+                  request. Mirror an existing rule retrieved via `list_rules` rather than authoring blind.
+              - `organization_id`: optional. Required only when the caller belongs to multiple organizations.
+
+            Errors:
+              - `INVALID_PARAMS` if `run_id` is empty; if neither a saved-rule selector nor `draft_rule_config` is
+                given, or both are; if both `rule_id` and `rule_name` are given; or if `draft_rule_config` is not
+                valid JSON matching the rule schema.
+              - `RESOURCE_NOT_FOUND` if `rule_name` matches no rule, or `run_id` does not exist.
+              - `INTERNAL_ERROR` for upstream gRPC failures.
+
+            Guidance:
+              - This is read-only — no user confirmation is needed before calling it, unlike `create_report`.
+              - After a good preview, offer the user the next step: `create_report` to persist the evaluation as a
+                report, or `create_rule`/`update_rule` to save a draft as a real rule.
+        ",
+        annotations(title = "rule_evaluation/preview_rule", read_only_hint = true)
+    )]
+    pub async fn preview_rule(&self, params: Parameters<PreviewRuleParams>) -> error::McpResult {
+        let Parameters(PreviewRuleParams {
+            run_id,
+            rule_id,
+            rule_name,
+            draft_rule_config,
+            organization_id,
+        }) = params;
+
+        if run_id.is_empty() {
+            return Err(ErrorData::invalid_params(
+                "`run_id` must not be empty",
+                None,
+            ));
+        }
+
+        let selector = saved_rule_selector(rule_id, rule_name)?;
+
+        let source = match (selector, draft_rule_config) {
+            (Some(_), Some(_)) => {
+                return Err(ErrorData::invalid_params(
+                    "provide either a saved rule (`rule_id`/`rule_name`) or `draft_rule_config`, not both",
+                    None,
+                ));
+            }
+            (None, None) => {
+                return Err(ErrorData::invalid_params(
+                    "provide either a saved rule (`rule_id`/`rule_name`) or `draft_rule_config`",
+                    None,
+                ));
+            }
+            (Some(selector), None) => {
+                let rule_id = self.resolve_saved_rule_id(selector).await?;
+                PreviewRuleSource::SavedRuleId(rule_id)
+            }
+            (None, Some(draft_rule_config)) => {
+                let config = parse_draft_rule_config(&draft_rule_config)?;
+                PreviewRuleSource::DraftRuleConfig(Box::new(config))
+            }
+        };
+
+        let result = self
+            .rule_evaluation_service
+            .preview_rule(run_id, source, organization_id)
+            .await
+            .map_err(from_anyhow)?;
+
+        let next_step = format!(
+            "Preview evaluated {} annotation(s) that would be created. Nothing was persisted (no report, \
+             annotation, or rule was saved). Review the dry-run results with the user; if they want to keep \
+             them, use `create_report` to persist an evaluation over this run.",
+            result.created_annotation_count,
+        );
+
+        let mut result = CallToolResult::structured(serde_json::json!({
+            "created_annotation_count": result.created_annotation_count,
+            "dry_run_annotations": result.dry_run_annotations,
+            "next_step": next_step,
+        }));
+        result.content = vec![ContentBlock::text(next_step)];
+        Ok(result)
+    }
+}
+
+/// Resolve the mutually exclusive `(rule_id, rule_name)` params into an
+/// optional selector. `None` means the caller gave neither (the "draft rule"
+/// case is expected instead); both set is an error.
+fn saved_rule_selector(
+    rule_id: Option<String>,
+    rule_name: Option<String>,
+) -> Result<Option<SavedRuleSelector>, ErrorData> {
+    match (rule_id, rule_name) {
+        (Some(id), None) => Ok(Some(SavedRuleSelector::Id(id))),
+        (None, Some(name)) => Ok(Some(SavedRuleSelector::Name(name))),
+        (None, None) => Ok(None),
+        (Some(_), Some(_)) => Err(ErrorData::invalid_params(
+            "provide at most one of `rule_id` or `rule_name`, not both",
+            None,
+        )),
+    }
+}
+
+/// Deserialize a draft rule config JSON string into an `UpdateRuleRequest`,
+/// mapping any parse error to `INVALID_PARAMS` so the agent can correct it.
+fn parse_draft_rule_config(draft_rule_config: &str) -> Result<UpdateRuleRequest, ErrorData> {
+    serde_json::from_str::<UpdateRuleRequest>(draft_rule_config).map_err(|e| {
+        ErrorData::invalid_params(
+            format!("`draft_rule_config` is not a valid rule definition: {e}"),
+            None,
+        )
+    })
+}
+
+impl SiftMcpServer {
+    /// Resolve a saved-rule selector to a `rule_id`, going through the existing
+    /// rules service for name lookups so this doesn't duplicate rule lookup logic.
+    async fn resolve_saved_rule_id(
+        &self,
+        selector: SavedRuleSelector,
+    ) -> Result<String, ErrorData> {
+        match selector {
+            SavedRuleSelector::Id(id) => Ok(id),
+            SavedRuleSelector::Name(name) => {
+                let filter = format!("is_archived == false && name == \"{}\"", cel_escape(&name));
+                let rule = self
+                    .rule_service
+                    .list_rules(filter, None, Some(1))
+                    .await
+                    .map_err(from_anyhow)?
+                    .items
+                    .into_iter()
+                    .next()
+                    .ok_or_else(|| {
+                        ErrorData::resource_not_found(format!("rule '{name}' not found"), None)
+                    })?;
+                Ok(rule.rule_id)
+            }
+        }
+    }
+}
diff --git a/rust/crates/sift_mcp/src/tool/rule_evaluation/test.rs b/rust/crates/sift_mcp/src/tool/rule_evaluation/test.rs
new file mode 100644
index 000000000..ac1034f9c
--- /dev/null
+++ b/rust/crates/sift_mcp/src/tool/rule_evaluation/test.rs
@@ -0,0 +1,290 @@
+use rmcp::{handler::server::wrapper::Parameters, model::ErrorCode};
+use sift_rs::{
+    rule_evaluation::v1::{
+        EvaluateRulesPreviewResponse, rule_evaluation_service_server::RuleEvaluationServiceServer,
+    },
+    rules::v1::{
+        DryRunAnnotation, ListRulesResponse, Rule, rule_service_server::RuleServiceServer,
+    },
+};
+use sift_test_util::{
+    grpc::memory_sift_channel,
+    mock::{rule_evaluation::v1::MockRuleEvaluationServiceImpl, rules::v1::MockRuleServiceImpl},
+};
+use tokio::task::JoinHandle;
+use tonic::{Response, Status, transport::Server};
+
+use super::PreviewRuleParams;
+use crate::{server::SiftMcpServer, tool::common::test_support::structured_field};
+
+fn preview_rule_params() -> PreviewRuleParams {
+    PreviewRuleParams {
+        run_id: "run-1".into(),
+        rule_id: None,
+        rule_name: None,
+        draft_rule_config: None,
+        organization_id: None,
+    }
+}
+
+/// Registers only the evaluation mock. Sufficient for tests that never need to
+/// resolve a rule name (rule_id-only or draft-config paths).
+async fn server_with_eval_mock(
+    mock: MockRuleEvaluationServiceImpl,
+) -> (SiftMcpServer, JoinHandle<()>) {
+    let (client, server) = tokio::io::duplex(1024);
+    let channel = memory_sift_channel(client).await;
+
+    let handle = tokio::spawn(async move {
+        Server::builder()
+            .add_service(RuleEvaluationServiceServer::new(mock))
+            .serve_with_incoming(tokio_stream::once(Ok::<_, std::io::Error>(server)))
+            .await
+            .unwrap();
+    });
+
+    (
+        SiftMcpServer::new(channel, String::from("https://app.test.local"), true, true),
+        handle,
+    )
+}
+
+/// Registers both the rule and evaluation mocks, for the rule-name-resolution path.
+async fn server_with_dual_mocks(
+    rule_mock: MockRuleServiceImpl,
+    eval_mock: MockRuleEvaluationServiceImpl,
+) -> (SiftMcpServer, JoinHandle<()>) {
+    let (client, server) = tokio::io::duplex(1024);
+    let channel = memory_sift_channel(client).await;
+
+    let handle = tokio::spawn(async move {
+        Server::builder()
+            .add_service(RuleServiceServer::new(rule_mock))
+            .add_service(RuleEvaluationServiceServer::new(eval_mock))
+            .serve_with_incoming(tokio_stream::once(Ok::<_, std::io::Error>(server)))
+            .await
+            .unwrap();
+    });
+
+    (
+        SiftMcpServer::new(channel, String::from("https://app.test.local"), true, true),
+        handle,
+    )
+}
+
+#[tokio::test]
+async fn preview_rule_saved_by_id_happy_path() {
+    let mut eval_mock = MockRuleEvaluationServiceImpl::new();
+    eval_mock.expect_evaluate_rules_preview().returning(|_| {
+        Ok(Response::new(EvaluateRulesPreviewResponse {
+            created_annotation_count: 2,
+            dry_run_annotations: vec![DryRunAnnotation {
+                condition_id: "cond-1".into(),
+                name: "overtemp".into(),
+                ..Default::default()
+            }],
+        }))
+    });
+
+    let (server, _h) = server_with_eval_mock(eval_mock).await;
+
+    let mut params = preview_rule_params();
+    params.rule_id = Some("rule-1".into());
+
+    let resp = server
+        .preview_rule(Parameters(params))
+        .await
+        .expect("preview_rule failed");
+
+    let count = structured_field(resp.clone(), "created_annotation_count");
+    assert_eq!(count, 2);
+    let annotations = structured_field(resp, "dry_run_annotations");
+    assert_eq!(annotations.as_array().unwrap().len(), 1);
+}
+
+#[tokio::test]
+async fn preview_rule_saved_by_name_resolves_rule_id() {
+    let mut rule_mock = MockRuleServiceImpl::new();
+    rule_mock
+        .expect_list_rules()
+        .withf(|req| req.get_ref().filter == "is_archived == false && name == \"overtemp\"")
+        .returning(|_| {
+            Ok(Response::new(ListRulesResponse {
+                rules: vec![Rule {
+                    rule_id: "rule-resolved".into(),
+                    name: "overtemp".into(),
+                    ..Default::default()
+                }],
+                next_page_token: String::new(),
+            }))
+        });
+
+    let mut eval_mock = MockRuleEvaluationServiceImpl::new();
+    eval_mock.expect_evaluate_rules_preview().returning(|_| {
+        Ok(Response::new(EvaluateRulesPreviewResponse {
+            created_annotation_count: 0,
+            dry_run_annotations: vec![],
+        }))
+    });
+
+    let (server, _h) = server_with_dual_mocks(rule_mock, eval_mock).await;
+
+    let mut params = preview_rule_params();
+    params.rule_name = Some("overtemp".into());
+
+    let resp = server
+        .preview_rule(Parameters(params))
+        .await
+        .expect("preview_rule failed");
+
+    let count = structured_field(resp, "created_annotation_count");
+    assert_eq!(count, 0);
+}
+
+#[tokio::test]
+async fn preview_rule_saved_by_name_not_found() {
+    let mut rule_mock = MockRuleServiceImpl::new();
+    rule_mock.expect_list_rules().returning(|_| {
+        Ok(Response::new(ListRulesResponse {
+            rules: vec![],
+            next_page_token: String::new(),
+        }))
+    });
+
+    let (server, _h) =
+        server_with_dual_mocks(rule_mock, MockRuleEvaluationServiceImpl::new()).await;
+
+    let mut params = preview_rule_params();
+    params.rule_name = Some("does-not-exist".into());
+
+    let err = server
+        .preview_rule(Parameters(params))
+        .await
+        .expect_err("expected error");
+
+    assert_eq!(err.code, ErrorCode::RESOURCE_NOT_FOUND);
+}
+
+#[tokio::test]
+async fn preview_rule_draft_config_happy_path() {
+    let mut eval_mock = MockRuleEvaluationServiceImpl::new();
+    eval_mock.expect_evaluate_rules_preview().returning(|_| {
+        Ok(Response::new(EvaluateRulesPreviewResponse {
+            created_annotation_count: 1,
+            dry_run_annotations: vec![DryRunAnnotation {
+                condition_id: "cond-draft".into(),
+                name: "draft rule".into(),
+                ..Default::default()
+            }],
+        }))
+    });
+
+    let (server, _h) = server_with_eval_mock(eval_mock).await;
+
+    let mut params = preview_rule_params();
+    params.draft_rule_config =
+        Some(r#"{ "name": "draft rule", "description": "ad-hoc" }"#.to_string());
+
+    let resp = server
+        .preview_rule(Parameters(params))
+        .await
+        .expect("preview_rule failed");
+
+    let count = structured_field(resp, "created_annotation_count");
+    assert_eq!(count, 1);
+}
+
+#[tokio::test]
+async fn preview_rule_rejects_malformed_draft_json() {
+    let (server, _h) = server_with_eval_mock(MockRuleEvaluationServiceImpl::new()).await;
+
+    let mut params = preview_rule_params();
+    params.draft_rule_config = Some("not json".to_string());
+
+    let err = server
+        .preview_rule(Parameters(params))
+        .await
+        .expect_err("expected error");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+}
+
+#[tokio::test]
+async fn preview_rule_rejects_both_saved_and_draft() {
+    let (server, _h) = server_with_eval_mock(MockRuleEvaluationServiceImpl::new()).await;
+
+    let mut params = preview_rule_params();
+    params.rule_id = Some("rule-1".into());
+    params.draft_rule_config = Some(r#"{ "name": "x", "description": "y" }"#.to_string());
+
+    let err = server
+        .preview_rule(Parameters(params))
+        .await
+        .expect_err("expected error");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+}
+
+#[tokio::test]
+async fn preview_rule_rejects_neither_saved_nor_draft() {
+    let (server, _h) = server_with_eval_mock(MockRuleEvaluationServiceImpl::new()).await;
+
+    let err = server
+        .preview_rule(Parameters(preview_rule_params()))
+        .await
+        .expect_err("expected error");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+}
+
+#[tokio::test]
+async fn preview_rule_rejects_both_rule_id_and_rule_name() {
+    let (server, _h) = server_with_eval_mock(MockRuleEvaluationServiceImpl::new()).await;
+
+    let mut params = preview_rule_params();
+    params.rule_id = Some("rule-1".into());
+    params.rule_name = Some("overtemp".into());
+
+    let err = server
+        .preview_rule(Parameters(params))
+        .await
+        .expect_err("expected error");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+}
+
+#[tokio::test]
+async fn preview_rule_rejects_empty_run_id() {
+    let (server, _h) = server_with_eval_mock(MockRuleEvaluationServiceImpl::new()).await;
+
+    let mut params = preview_rule_params();
+    params.run_id = String::new();
+    params.rule_id = Some("rule-1".into());
+
+    let err = server
+        .preview_rule(Parameters(params))
+        .await
+        .expect_err("expected error");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+}
+
+#[tokio::test]
+async fn preview_rule_propagates_grpc_error() {
+    let mut eval_mock = MockRuleEvaluationServiceImpl::new();
+    eval_mock
+        .expect_evaluate_rules_preview()
+        .returning(|_| Err(Status::not_found("run missing")));
+
+    let (server, _h) = server_with_eval_mock(eval_mock).await;
+
+    let mut params = preview_rule_params();
+    params.rule_id = Some("rule-1".into());
+
+    let err = server
+        .preview_rule(Parameters(params))
+        .await
+        .expect_err("expected error");
+
+    assert_eq!(err.code, ErrorCode::RESOURCE_NOT_FOUND);
+}
diff --git a/rust/crates/sift_mcp/src/tool/user_defined_functions/mod.rs b/rust/crates/sift_mcp/src/tool/user_defined_functions/mod.rs
new file mode 100644
index 000000000..789f453c2
--- /dev/null
+++ b/rust/crates/sift_mcp/src/tool/user_defined_functions/mod.rs
@@ -0,0 +1,719 @@
+use rmcp::{
+    ErrorData,
+    handler::server::wrapper::Parameters,
+    model::{CallToolResult, ContentBlock},
+    schemars::{self, JsonSchema},
+    tool, tool_router,
+};
+use serde::Deserialize;
+use sift_rs::{
+    common::r#type::v1::{FunctionDataType, FunctionInput},
+    metadata::v1::MetadataValue,
+};
+
+use crate::{
+    error::{self, from_anyhow},
+    server::SiftMcpServer,
+    service::user_defined_functions::UdfUpdate,
+    tool::common::{ListParams, MetadataEntry, list_body, to_values},
+};
+
+#[cfg(test)]
+mod test;
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct UserDefinedFunctionVersionListParams {
+    pub(crate) user_defined_function_id: Option<String>,
+    pub(crate) name: Option<String>,
+    pub(crate) filter: String,
+    pub(crate) order_by: Option<String>,
+    pub(crate) limit: Option<u32>,
+    pub(crate) fields: Option<Vec<String>>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct CreateUserDefinedFunctionParams {
+    pub(crate) name: String,
+    pub(crate) expression: String,
+    pub(crate) function_inputs_json: String,
+    pub(crate) description: Option<String>,
+    pub(crate) user_notes: Option<String>,
+    pub(crate) metadata: Option<Vec<MetadataEntry>>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct UpdateUserDefinedFunctionParams {
+    pub(crate) user_defined_function_id: String,
+    pub(crate) name: Option<String>,
+    pub(crate) description: Option<String>,
+    pub(crate) expression: Option<String>,
+    pub(crate) function_inputs_json: Option<String>,
+    pub(crate) metadata: Option<Vec<MetadataEntry>>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct ArchiveUserDefinedFunctionParams {
+    pub(crate) user_defined_function_id: String,
+}
+
+/// One entry of the `function_inputs_json` array. The proto's `FunctionInput` is
+/// a nested message, so it arrives as a documented JSON string scalar and is
+/// parsed here.
+#[derive(Debug, Deserialize)]
+struct FunctionInputSpec {
+    identifier: String,
+    data_type: String,
+    #[serde(default)]
+    constant: bool,
+}
+
+#[tool_router(router = user_defined_functions_router, vis = "pub(crate)")]
+impl SiftMcpServer {
+    #[tool(
+        name = "list_user_defined_functions",
+        description = "
+            List the latest version of each user defined function in Sift, optionally filtered by a CEL
+            expression and ordered by one or more fields. A user defined function is a named, reusable
+            expression that calculated channels and rules can call.
+
+            Output:
+              - `{ \"user_defined_functions\": [UserDefinedFunction, ...] }`. Each item carries
+                `user_defined_function_id`, `name`, `description`, `expression`, `function_inputs`
+                (`identifier`, `data_type`, `constant`), `function_output_type`, `function_dependencies`
+                (the version ids of other functions this one calls), `user_defined_function_version_id`,
+                `version`, `change_message`, `user_notes`, `metadata`, timestamps, author ids, and archive
+                state.
+              - Fields at their proto3 default are OMITTED from the JSON: a missing `is_archived` or
+                `version` key means `false` / `0`, not \"unknown\".
+              - `count`: how many items THIS response carries — read it instead of
+                counting the array yourself. It is the size of the page you got back, not
+                how many items match `filter`.
+              - `has_more`: `true` when the service hit `limit` with matches left over, so
+                this page is not the whole set. Never report `count` as a total while
+                `has_more` is `true` — narrow `filter` or raise `limit` and ask again.
+
+            Parameters:
+              - `filter`: CEL expression. Pass an empty string to list everything. Filterable fields:
+                `user_defined_function_id`, `name`, `archived_date`, `is_archived`.
+                `name` is the only free-text field. When filtering or searching it, use
+                `name.matches(\"(?i)rms\")`, not `==`. Use `==` only for an exact value from a prior
+                result. `contains`/`startsWith`/`endsWith` are case-SENSITIVE: `contains(\"RMS\")`
+                silently misses `rms_window`.
+              - `order_by`: optional comma-separated `FIELD_NAME[ desc]` list. Orderable fields:
+                `created_date`, `modified_date`, `name`. Default sort is `created_date desc`
+                (newest first). Example: `\"name,modified_date desc\"`.
+              - `limit`: max items to return. Start at 50 and only raise it if the result is capped
+                and you still need more. Values are clamped to `1..=200`; omitting it defaults to 50.
+              - `fields`: optional array of field names to keep on each item, e.g.
+                `[\"name\"]`. Omit it for the full object. Names match case-insensitively
+                and ignore underscores and hyphens, so `asset_id`, `assetId` and
+                `asset-id` all work. Any name that matched nothing on any returned item
+                is listed in `unmatched_fields`; an empty page reports none, since it
+                says nothing about whether a name was spelled right.
+                Reach for this whenever you need only a few fields: full objects are wide,
+                and a large listing can exceed the response size limit without it.
+
+            Errors:
+              - `INVALID_PARAMS` if `filter` is not a valid CEL expression or `order_by` references an
+                unknown field.
+              - `INTERNAL_ERROR` for upstream gRPC failures.
+
+            Guidance:
+              - Call this BEFORE authoring an expression that depends on a user defined function. The
+                function's exact `name`, its `function_inputs` order, and its `function_output_type` are
+                what a caller has to match; guessing them produces an expression the server rejects.
+              - Default add `is_archived == false` to the filter. Include archived functions only when
+                the user explicitly asks for them.
+        ",
+        annotations(
+            title = "user_defined_functions/list_user_defined_functions",
+            read_only_hint = true
+        )
+    )]
+    pub async fn list_user_defined_functions(
+        &self,
+        params: Parameters<ListParams>,
+    ) -> error::McpResult {
+        let Parameters(ListParams {
+            filter,
+            order_by,
+            limit,
+            fields,
+        }) = params;
+
+        let page = self
+            .user_defined_function_service
+            .list_user_defined_functions(filter, order_by, limit)
+            .await
+            .map_err(from_anyhow)?;
+
+        let functions = to_values(&page.items)?;
+
+        Ok(CallToolResult::structured(list_body(
+            "user_defined_functions",
+            functions,
+            fields,
+            page.has_more,
+        )))
+    }
+
+    #[tool(
+        name = "list_user_defined_function_versions",
+        description = "
+            List the version history of one user defined function. Every accepted update creates a new
+            version and leaves the previous one intact, so this is how you read what changed and when.
+
+            Output:
+              - `{ \"user_defined_function_versions\": [UserDefinedFunction, ...] }`. Each item is one
+                version with the same shape `list_user_defined_functions` returns, including
+                `user_defined_function_version_id`, `version`, `expression`, `function_inputs`,
+                `change_message` (server-generated summary of the change), `user_notes`, and
+                `modified_by_user_id`.
+              - `count`: how many items THIS response carries — read it instead of
+                counting the array yourself. It is the size of the page you got back, not
+                how many items match `filter`.
+              - `has_more`: `true` when the service hit `limit` with matches left over, so
+                this page is not the whole set. Never report `count` as a total while
+                `has_more` is `true` — narrow `filter` or raise `limit` and ask again.
+
+            Parameters:
+              - `user_defined_function_id`: optional. The id of the function whose versions to list.
+              - `name`: optional. The name of the function whose versions to list.
+              - Exactly one of `user_defined_function_id` or `name` must be set.
+              - `filter`: CEL expression. Pass an empty string to list every version.
+                Filterable fields: `user_defined_function_id`, `name`, `version`, `archived_date`,
+                `is_archived`. `name` is the only free-text field; when filtering or searching it, use
+                `name.matches(\"(?i)rms\")`, not `==`. Use `==` only for an exact value from a prior
+                result. `contains`/`startsWith`/`endsWith` are case-SENSITIVE: `contains(\"RMS\")`
+                silently misses `rms_window`.
+              - `order_by`: optional comma-separated `FIELD_NAME[ desc]` list. Orderable fields:
+                `created_date`, `modified_date`, `version`. Default sort is `version desc`
+                (newest version first). Example: `\"version desc,modified_date\"`.
+              - `limit`: max items to return. Start at 50 and only raise it if the result is capped
+                and you still need more. Values are clamped to `1..=200`; omitting it defaults to 50.
+              - `fields`: optional array of field names to keep on each item, e.g.
+                `[\"name\"]`. Omit it for the full object. Names match case-insensitively
+                and ignore underscores and hyphens, so `asset_id`, `assetId` and
+                `asset-id` all work. Any name that matched nothing on any returned item
+                is listed in `unmatched_fields`; an empty page reports none, since it
+                says nothing about whether a name was spelled right.
+                Reach for this whenever you need only a few fields: full objects are wide,
+                and a large listing can exceed the response size limit without it.
+
+            Errors:
+              - `INVALID_PARAMS` if neither or both of `user_defined_function_id` and `name` are set, or
+                if `filter` is not a valid CEL expression.
+              - `INTERNAL_ERROR` for upstream gRPC failures.
+
+            Guidance:
+              - Use this to find the `user_defined_function_version_id` a calculated channel or another
+                function pins, or to show the user how an expression evolved. Resolve the id with
+                `list_user_defined_functions` first when you only have a partial name.
+        ",
+        annotations(
+            title = "user_defined_functions/list_user_defined_function_versions",
+            read_only_hint = true
+        )
+    )]
+    pub async fn list_user_defined_function_versions(
+        &self,
+        params: Parameters<UserDefinedFunctionVersionListParams>,
+    ) -> error::McpResult {
+        let Parameters(UserDefinedFunctionVersionListParams {
+            user_defined_function_id,
+            name,
+            filter,
+            order_by,
+            limit,
+            fields,
+        }) = params;
+
+        let (user_defined_function_id, name) = function_identifier(user_defined_function_id, name)?;
+
+        let page = self
+            .user_defined_function_service
+            .list_user_defined_function_versions(
+                user_defined_function_id,
+                name,
+                filter,
+                order_by,
+                limit,
+            )
+            .await
+            .map_err(from_anyhow)?;
+
+        let versions = to_values(&page.items)?;
+
+        Ok(CallToolResult::structured(list_body(
+            "user_defined_function_versions",
+            versions,
+            fields,
+            page.has_more,
+        )))
+    }
+
+    #[tool(
+        name = "create_user_defined_function",
+        description = "
+            Create a user defined function: a named, reusable expression that calculated channels, rules,
+            and other user defined functions can call. This is a WRITE.
+
+            Output:
+              - `{ \"user_defined_function\": UserDefinedFunction, \"user_defined_function_id\": \"<id>\",
+                \"next_step\": \"...\" }`. The returned function is the server's post-create state,
+                including the resolved `function_output_type` and `version` 1.
+
+            Parameters:
+              - `name`: required. The name callers use to reference the function. It must start with a
+                letter, then contain only alphanumeric characters or `_`, and be at most 253 characters.
+              - `expression`: required. The function body. Reference each declared input by its
+                `identifier`. Mirror an existing function retrieved with `list_user_defined_functions`
+                rather than authoring the syntax blind.
+              - `function_inputs_json`: required. A JSON array string declaring the function's inputs, in
+                the order callers pass them. Each element is
+                `{ \"identifier\": \"<name>\", \"data_type\": \"numeric\"|\"string\"|\"bool\",
+                \"constant\": <bool> }`. `data_type` is matched case-insensitively; no other spelling is
+                accepted. `constant` defaults to `false` and marks an input that takes a literal value
+                rather than a channel. Pass `[]` for a function that takes no inputs.
+              - `description`: optional. Human-readable summary.
+              - `user_notes`: optional. Notes recorded against this first version.
+              - `metadata`: optional. Array of `{ \"name\": \"<key>\", \"value\": <scalar> }` where
+                `value` is a string, number, or boolean. A `name` that does not yet exist in the
+                organization's metadata schema is created on the fly with the type inferred from `value`;
+                for an existing key the type must match.
+
+            Errors:
+              - `INVALID_PARAMS` if `name` or `expression` is empty, `function_inputs_json` is not a JSON
+                array of input objects, an `identifier` is empty, a `data_type` is not one of `numeric`,
+                `string`, or `bool`, or the server rejects the expression (unresolved identifier, type
+                mismatch, duplicate function name).
+              - `INTERNAL_ERROR` for upstream gRPC failures.
+
+            Guidance:
+              - This creates a live resource. Confirm the name, the expression, and the input list with
+                the user before calling.
+              - An expression may call other user defined functions. List them first so you match their
+                real names, input order, and output types; the server records the calls as
+                `function_dependencies`, and those dependencies then restrict what can be updated later.
+        ",
+        annotations(
+            title = "user_defined_functions/create_user_defined_function",
+            read_only_hint = false,
+            destructive_hint = false,
+            idempotent_hint = false,
+        )
+    )]
+    pub async fn create_user_defined_function(
+        &self,
+        params: Parameters<CreateUserDefinedFunctionParams>,
+    ) -> error::McpResult {
+        self.require_create()?;
+
+        let Parameters(CreateUserDefinedFunctionParams {
+            name,
+            expression,
+            function_inputs_json,
+            description,
+            user_notes,
+            metadata,
+        }) = params;
+
+        if name.trim().is_empty() {
+            return Err(ErrorData::invalid_params("`name` must not be empty", None));
+        }
+        validate_function_name(&name)?;
+        if expression.trim().is_empty() {
+            return Err(ErrorData::invalid_params(
+                "`expression` must not be empty",
+                None,
+            ));
+        }
+
+        let function_inputs = parse_function_inputs(&function_inputs_json)?;
+        let metadata = metadata_values(metadata).unwrap_or_default();
+
+        let function = self
+            .user_defined_function_service
+            .create_user_defined_function(
+                name,
+                description,
+                expression,
+                function_inputs,
+                user_notes,
+                metadata,
+            )
+            .await
+            .map_err(from_anyhow)?;
+
+        let next_step = format!(
+            "Created user defined function `{}` with id `{}` at version {}. Tell the user the new id \
+             and confirm the expression matches their intent. Reference it from a calculated channel \
+             or rule by name.",
+            function.name, function.user_defined_function_id, function.version,
+        );
+
+        let mut result = CallToolResult::structured(serde_json::json!({
+            "user_defined_function": function,
+            "user_defined_function_id": function.user_defined_function_id,
+            "next_step": next_step,
+        }));
+        result.content = vec![ContentBlock::text(next_step)];
+        Ok(result)
+    }
+
+    #[tool(
+        name = "update_user_defined_function",
+        description = "
+            Update a user defined function. This is a WRITE. Only the fields you set are written; the
+            rest of the function is left as it is. The update creates a NEW version and leaves the
+            previous version intact, so callers pinned to an older version are unaffected.
+
+            Output:
+              - `{ \"user_defined_function\": UserDefinedFunction, \"next_step\": \"...\" }`. The
+                returned function is the newly created version, with its own
+                `user_defined_function_version_id` and incremented `version`.
+
+            Parameters:
+              - `user_defined_function_id`: required. The function to update.
+              - `name`: optional. New name. It must start with a letter, then contain only alphanumeric
+                characters or `_`, and be at most 253 characters. The API applies a rename BY ITSELF and
+                ignores any other field in the same call, so this tool rejects `name` combined with another
+                field — send the rename as its own call.
+              - `description`: optional. New description.
+              - `expression`: optional. New function body.
+              - `function_inputs_json`: optional. REPLACES the declared input list. Same array shape as
+                `create_user_defined_function`.
+              - `metadata`: optional. REPLACES the function's full metadata list. Same entry shape as
+                `create_user_defined_function`; pass `[]` to clear.
+              - At least one field besides `user_defined_function_id` must be set.
+              - Archive state is not settable here. Use `archive_user_defined_function` /
+                `unarchive_user_defined_function`.
+
+            Errors:
+              - `INVALID_PARAMS` if no updatable field is set, `name` is combined with another field, or
+                `function_inputs_json` is not a valid input array. The server also rejects updates that
+                its dependency rules forbid: `name` cannot change once the function has ever had
+                dependencies, `function_inputs` cannot change while any function or calculated channel
+                depends on this one, and `expression` cannot change the output type while dependents
+                exist.
+              - `RESOURCE_NOT_FOUND` if no function matches `user_defined_function_id`.
+              - `INTERNAL_ERROR` for upstream gRPC failures.
+
+            Guidance:
+              - Confirm the target function and the exact changes with the user before calling.
+              - `function_inputs_json` and `metadata` are REPLACE, not merge. Read the current values
+                with `list_user_defined_functions` (filter `user_defined_function_id == \"<id>\"`) and
+                send the full intended list.
+              - There is no version precondition on this RPC, so a concurrent edit is not detected. Read
+                the function immediately before updating when a change may be racing another author.
+        ",
+        annotations(
+            title = "user_defined_functions/update_user_defined_function",
+            read_only_hint = false,
+            destructive_hint = true,
+            idempotent_hint = true,
+        )
+    )]
+    pub async fn update_user_defined_function(
+        &self,
+        params: Parameters<UpdateUserDefinedFunctionParams>,
+    ) -> error::McpResult {
+        self.require_destructive()?;
+
+        let Parameters(UpdateUserDefinedFunctionParams {
+            user_defined_function_id,
+            name,
+            description,
+            expression,
+            function_inputs_json,
+            metadata,
+        }) = params;
+
+        if user_defined_function_id.is_empty() {
+            return Err(ErrorData::invalid_params(
+                "`user_defined_function_id` must not be empty",
+                None,
+            ));
+        }
+        if let Some(name) = &name {
+            validate_function_name(name)?;
+        }
+
+        let function_inputs = function_inputs_json
+            .as_deref()
+            .map(parse_function_inputs)
+            .transpose()?;
+
+        let changes = UdfUpdate {
+            name,
+            description,
+            expression,
+            function_inputs,
+            metadata: metadata_values(metadata),
+        };
+
+        let others_set = changes.description.is_some()
+            || changes.expression.is_some()
+            || changes.function_inputs.is_some()
+            || changes.metadata.is_some();
+
+        if changes.name.is_none() && !others_set {
+            return Err(ErrorData::invalid_params(
+                "at least one of `name`, `description`, `expression`, `function_inputs_json`, or \
+                 `metadata` must be set",
+                None,
+            ));
+        }
+        if changes.name.is_some() && others_set {
+            return Err(ErrorData::invalid_params(
+                "the API applies a `name` change on its own and ignores every other field in the \
+                 same request; send the rename as a separate call",
+                None,
+            ));
+        }
+
+        let function = self
+            .user_defined_function_service
+            .update_user_defined_function(user_defined_function_id, changes)
+            .await
+            .map_err(from_anyhow)?;
+
+        let next_step = format!(
+            "Updated user defined function `{}` ({}); it is now at version {}. Earlier versions are \
+             untouched. Surface the new state to the user and confirm nothing was unintentionally \
+             replaced — input and metadata lists are REPLACE operations.",
+            function.name, function.user_defined_function_id, function.version,
+        );
+
+        let mut result = CallToolResult::structured(serde_json::json!({
+            "user_defined_function": function,
+            "next_step": next_step,
+        }));
+        result.content = vec![ContentBlock::text(next_step)];
+        Ok(result)
+    }
+
+    #[tool(
+        name = "archive_user_defined_function",
+        description = "
+            Archive a user defined function so it stops appearing as an available function. This is a
+            WRITE. Reversible with `unarchive_user_defined_function`.
+
+            Output:
+              - `{ \"archived\": true, \"user_defined_function\": UserDefinedFunction,
+                \"next_step\": \"...\" }`. The returned function is the post-archive state.
+
+            Parameters:
+              - `user_defined_function_id`: required. The function to archive.
+
+            Errors:
+              - `INVALID_PARAMS` if `user_defined_function_id` is empty.
+              - `RESOURCE_NOT_FOUND` if no function matches `user_defined_function_id`.
+              - `INTERNAL_ERROR` for upstream gRPC failures.
+
+            Guidance:
+              - Archiving does not delete the function and does not rewrite anything that already calls
+                it. Calculated channels and rules that call it keep referencing it. Confirm the target
+                with the user before calling.
+              - This toolset cannot enumerate what depends on a function. `function_dependencies` on a
+                `list_user_defined_functions` row is the reverse direction — the functions this one
+                calls. Treat the archive as reversible and let the user tell you what else is affected.
+        ",
+        annotations(
+            title = "user_defined_functions/archive_user_defined_function",
+            read_only_hint = false,
+            destructive_hint = true,
+            idempotent_hint = true,
+        )
+    )]
+    pub async fn archive_user_defined_function(
+        &self,
+        params: Parameters<ArchiveUserDefinedFunctionParams>,
+    ) -> error::McpResult {
+        self.require_destructive()?;
+
+        let Parameters(ArchiveUserDefinedFunctionParams {
+            user_defined_function_id,
+        }) = params;
+
+        let function = self.set_archived(user_defined_function_id, true).await?;
+
+        let next_step = format!(
+            "Archived user defined function `{}` ({}). Tell the user it no longer appears as an \
+             available function and that `unarchive_user_defined_function` restores it.",
+            function.name, function.user_defined_function_id,
+        );
+
+        let mut result = CallToolResult::structured(serde_json::json!({
+            "archived": true,
+            "user_defined_function": function,
+            "next_step": next_step,
+        }));
+        result.content = vec![ContentBlock::text(next_step)];
+        Ok(result)
+    }
+
+    #[tool(
+        name = "unarchive_user_defined_function",
+        description = "
+            Restore a previously archived user defined function. This is a WRITE.
+
+            Output:
+              - `{ \"unarchived\": true, \"user_defined_function\": UserDefinedFunction,
+                \"next_step\": \"...\" }`. The returned function is the post-unarchive state.
+
+            Parameters:
+              - `user_defined_function_id`: required. The function to unarchive.
+
+            Errors:
+              - `INVALID_PARAMS` if `user_defined_function_id` is empty.
+              - `RESOURCE_NOT_FOUND` if no function matches `user_defined_function_id`.
+              - `INTERNAL_ERROR` for upstream gRPC failures.
+
+            Guidance:
+              - Confirm the target function with the user before calling. Find archived functions with
+                `list_user_defined_functions` and filter `is_archived == true`.
+        ",
+        annotations(
+            title = "user_defined_functions/unarchive_user_defined_function",
+            read_only_hint = false,
+            destructive_hint = true,
+            idempotent_hint = true,
+        )
+    )]
+    pub async fn unarchive_user_defined_function(
+        &self,
+        params: Parameters<ArchiveUserDefinedFunctionParams>,
+    ) -> error::McpResult {
+        self.require_destructive()?;
+
+        let Parameters(ArchiveUserDefinedFunctionParams {
+            user_defined_function_id,
+        }) = params;
+
+        let function = self.set_archived(user_defined_function_id, false).await?;
+
+        let next_step = format!(
+            "Unarchived user defined function `{}` ({}). Tell the user it is available again.",
+            function.name, function.user_defined_function_id,
+        );
+
+        let mut result = CallToolResult::structured(serde_json::json!({
+            "unarchived": true,
+            "user_defined_function": function,
+            "next_step": next_step,
+        }));
+        result.content = vec![ContentBlock::text(next_step)];
+        Ok(result)
+    }
+}
+
+impl SiftMcpServer {
+    /// Shared body of the archive and unarchive tools. Both flip the same
+    /// `is_archived` field through the update mask, so only the validation and
+    /// the reported wording differ.
+    async fn set_archived(
+        &self,
+        user_defined_function_id: String,
+        is_archived: bool,
+    ) -> Result<sift_rs::common::r#type::v1::UserDefinedFunction, ErrorData> {
+        if user_defined_function_id.is_empty() {
+            return Err(ErrorData::invalid_params(
+                "`user_defined_function_id` must not be empty",
+                None,
+            ));
+        }
+
+        self.user_defined_function_service
+            .set_user_defined_function_archived(user_defined_function_id, is_archived)
+            .await
+            .map_err(from_anyhow)
+    }
+}
+
+/// Resolve the `(user_defined_function_id, name)` request fields from the
+/// mutually exclusive optional params. The proto silently ignores `name` when an
+/// id is present, so reject the ambiguous call rather than pick for the caller.
+fn function_identifier(
+    user_defined_function_id: Option<String>,
+    name: Option<String>,
+) -> Result<(String, String), ErrorData> {
+    match (user_defined_function_id, name) {
+        (Some(id), None) => Ok((id, String::new())),
+        (None, Some(name)) => Ok((String::new(), name)),
+        (Some(_), Some(_)) => Err(ErrorData::invalid_params(
+            "exactly one of `user_defined_function_id` or `name` must be set, not both",
+            None,
+        )),
+        (None, None) => Err(ErrorData::invalid_params(
+            "one of `user_defined_function_id` or `name` must be set",
+            None,
+        )),
+    }
+}
+
+fn validate_function_name(name: &str) -> Result<(), ErrorData> {
+    let valid = name.len() <= 253
+        && matches!(name.as_bytes().first(), Some(b'A'..=b'Z' | b'a'..=b'z'))
+        && name
+            .bytes()
+            .skip(1)
+            .all(|byte| byte.is_ascii_alphanumeric() || byte == b'_');
+
+    if valid {
+        Ok(())
+    } else {
+        Err(ErrorData::invalid_params(
+            "`name` must start with a letter, contain only alphanumeric characters or `_`, and be at most 253 characters",
+            None,
+        ))
+    }
+}
+
+/// Parse the documented `function_inputs_json` array into proto inputs, mapping
+/// every shape error to `INVALID_PARAMS` so the agent can correct its input.
+fn parse_function_inputs(function_inputs_json: &str) -> Result<Vec<FunctionInput>, ErrorData> {
+    let specs: Vec<FunctionInputSpec> =
+        serde_json::from_str(function_inputs_json).map_err(|e| {
+            ErrorData::invalid_params(
+                format!(
+                    "`function_inputs_json` is not a JSON array of \
+                     {{\"identifier\", \"data_type\", \"constant\"}} objects: {e}"
+                ),
+                None,
+            )
+        })?;
+
+    specs
+        .into_iter()
+        .map(|spec| {
+            if spec.identifier.trim().is_empty() {
+                return Err(ErrorData::invalid_params(
+                    "every `function_inputs_json` entry needs a non-empty `identifier`",
+                    None,
+                ));
+            }
+            Ok(FunctionInput {
+                identifier: spec.identifier,
+                data_type: parse_function_data_type(&spec.data_type)?.into(),
+                constant: spec.constant,
+            })
+        })
+        .collect()
+}
+
+fn parse_function_data_type(data_type: &str) -> Result<FunctionDataType, ErrorData> {
+    match data_type.to_ascii_lowercase().as_str() {
+        "numeric" => Ok(FunctionDataType::Numeric),
+        "string" => Ok(FunctionDataType::String),
+        "bool" => Ok(FunctionDataType::Bool),
+        other => Err(ErrorData::invalid_params(
+            format!("unknown `data_type` `{other}`; expected `numeric`, `string`, or `bool`"),
+            None,
+        )),
+    }
+}
+
+fn metadata_values(metadata: Option<Vec<MetadataEntry>>) -> Option<Vec<MetadataValue>> {
+    metadata.map(|entries| entries.into_iter().map(MetadataValue::from).collect())
+}
diff --git a/rust/crates/sift_mcp/src/tool/user_defined_functions/test.rs b/rust/crates/sift_mcp/src/tool/user_defined_functions/test.rs
new file mode 100644
index 000000000..75233353d
--- /dev/null
+++ b/rust/crates/sift_mcp/src/tool/user_defined_functions/test.rs
@@ -0,0 +1,799 @@
+use rmcp::{handler::server::wrapper::Parameters, model::ErrorCode};
+use sift_rs::{
+    common::r#type::v1::{FunctionDataType, FunctionInput, UserDefinedFunction},
+    user_defined_functions::v1::{
+        CreateUserDefinedFunctionResponse, GetUserDefinedFunctionResponse,
+        ListUserDefinedFunctionVersionsResponse, ListUserDefinedFunctionsResponse,
+        UpdateUserDefinedFunctionResponse,
+        user_defined_function_service_server::UserDefinedFunctionServiceServer,
+    },
+};
+use sift_test_util::{
+    grpc::memory_sift_channel, mock::user_defined_functions::v1::MockUserDefinedFunctionServiceImpl,
+};
+use tokio::task::JoinHandle;
+use tonic::{Response, Status, transport::Server};
+
+use crate::{
+    server::SiftMcpServer,
+    tool::{
+        common::test_support::{list_params, list_params_with_fields, structured},
+        user_defined_functions::{
+            ArchiveUserDefinedFunctionParams, CreateUserDefinedFunctionParams,
+            UpdateUserDefinedFunctionParams, UserDefinedFunctionVersionListParams,
+        },
+    },
+};
+
+async fn server_with_mock(
+    mock: MockUserDefinedFunctionServiceImpl,
+    allow_create: bool,
+    allow_destructive: bool,
+) -> (SiftMcpServer, JoinHandle<()>) {
+    let (client, server) = tokio::io::duplex(1024);
+    let channel = memory_sift_channel(client).await;
+
+    let handle = tokio::spawn(async move {
+        Server::builder()
+            .add_service(UserDefinedFunctionServiceServer::new(mock))
+            .serve_with_incoming(tokio_stream::once(Ok::<_, std::io::Error>(server)))
+            .await
+            .unwrap();
+    });
+
+    (
+        SiftMcpServer::new(
+            channel,
+            String::from("https://app.test.local"),
+            allow_create,
+            allow_destructive,
+        ),
+        handle,
+    )
+}
+
+fn numeric_input(identifier: &str) -> FunctionInput {
+    FunctionInput {
+        identifier: identifier.into(),
+        data_type: FunctionDataType::Numeric.into(),
+        constant: false,
+    }
+}
+
+fn version_list_params(
+    user_defined_function_id: Option<&str>,
+    name: Option<&str>,
+) -> Parameters<UserDefinedFunctionVersionListParams> {
+    Parameters(UserDefinedFunctionVersionListParams {
+        user_defined_function_id: user_defined_function_id.map(str::to_string),
+        name: name.map(str::to_string),
+        filter: String::new(),
+        order_by: None,
+        limit: None,
+        fields: None,
+    })
+}
+
+fn create_params(function_inputs_json: &str) -> Parameters<CreateUserDefinedFunctionParams> {
+    Parameters(CreateUserDefinedFunctionParams {
+        name: "rms".into(),
+        expression: "sqrt(mean($x * $x))".into(),
+        function_inputs_json: function_inputs_json.into(),
+        description: None,
+        user_notes: None,
+        metadata: None,
+    })
+}
+
+fn update_params(
+    name: Option<&str>,
+    description: Option<&str>,
+    function_inputs_json: Option<&str>,
+) -> Parameters<UpdateUserDefinedFunctionParams> {
+    Parameters(UpdateUserDefinedFunctionParams {
+        user_defined_function_id: "f1".into(),
+        name: name.map(str::to_string),
+        description: description.map(str::to_string),
+        expression: None,
+        function_inputs_json: function_inputs_json.map(str::to_string),
+        metadata: None,
+    })
+}
+
+fn archive_params(id: &str) -> Parameters<ArchiveUserDefinedFunctionParams> {
+    Parameters(ArchiveUserDefinedFunctionParams {
+        user_defined_function_id: id.into(),
+    })
+}
+
+fn expect_current_udf(mock: &mut MockUserDefinedFunctionServiceImpl, id: &str) {
+    let id = id.to_string();
+    mock.expect_get_user_defined_function()
+        .times(1)
+        .returning(move |_| {
+            Ok(Response::new(GetUserDefinedFunctionResponse {
+                user_defined_function: Some(UserDefinedFunction {
+                    user_defined_function_id: id.clone(),
+                    ..Default::default()
+                }),
+            }))
+        });
+}
+
+#[tokio::test]
+async fn list_user_defined_functions_returns_structured_rows() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_functions()
+        .withf(|req| req.get_ref().filter == "is_archived == false")
+        .returning(|_| {
+            Ok(Response::new(ListUserDefinedFunctionsResponse {
+                user_defined_functions: vec![UserDefinedFunction {
+                    user_defined_function_id: "f1".into(),
+                    name: "rms".into(),
+                    version: 3,
+                    ..Default::default()
+                }],
+                next_page_token: String::new(),
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock, false, false).await;
+
+    let resp = server
+        .list_user_defined_functions(list_params("is_archived == false", None))
+        .await
+        .expect("list_user_defined_functions failed");
+
+    let body = structured(resp);
+    let functions = body["user_defined_functions"].as_array().expect("array");
+    assert_eq!(functions.len(), 1);
+    assert_eq!(functions[0]["userDefinedFunctionId"], "f1");
+    assert_eq!(functions[0]["name"], "rms");
+    assert_eq!(body["count"], 1);
+}
+
+#[tokio::test]
+async fn list_user_defined_functions_propagates_grpc_error() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_functions()
+        .returning(|_| Err(Status::invalid_argument("bad filter")));
+
+    let (server, _h) = server_with_mock(mock, false, false).await;
+
+    let err = server
+        .list_user_defined_functions(list_params("nope", None))
+        .await
+        .expect_err("expected error");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+    assert!(err.message.contains("bad filter"));
+}
+
+#[tokio::test]
+async fn list_user_defined_functions_projects_requested_fields() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_functions().returning(|_| {
+        Ok(Response::new(ListUserDefinedFunctionsResponse {
+            user_defined_functions: vec![UserDefinedFunction {
+                user_defined_function_id: "f1".into(),
+                name: "rms".into(),
+                description: "root mean square".into(),
+                ..Default::default()
+            }],
+            next_page_token: String::new(),
+        }))
+    });
+
+    let (server, _h) = server_with_mock(mock, false, false).await;
+
+    let resp = server
+        .list_user_defined_functions(list_params_with_fields("", &["name"]))
+        .await
+        .expect("list_user_defined_functions failed");
+
+    let body = structured(resp);
+    assert_eq!(
+        body["user_defined_functions"],
+        serde_json::json!([{ "name": "rms" }])
+    );
+    assert_eq!(body["count"], 1);
+}
+
+#[tokio::test]
+async fn list_versions_returns_structured_rows() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_function_versions()
+        // An empty `filter` lists every version; it is a required String, not an Option.
+        .withf(|req| {
+            let req = req.get_ref();
+            req.user_defined_function_id == "f1" && req.filter.is_empty()
+        })
+        .returning(|_| {
+            Ok(Response::new(ListUserDefinedFunctionVersionsResponse {
+                user_defined_functions: vec![UserDefinedFunction {
+                    user_defined_function_id: "f1".into(),
+                    user_defined_function_version_id: "v2".into(),
+                    version: 2,
+                    ..Default::default()
+                }],
+                next_page_token: String::new(),
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock, false, false).await;
+
+    let resp = server
+        .list_user_defined_function_versions(version_list_params(Some("f1"), None))
+        .await
+        .expect("list_user_defined_function_versions failed");
+
+    let body = structured(resp);
+    let versions = body["user_defined_function_versions"]
+        .as_array()
+        .expect("array");
+    assert_eq!(versions.len(), 1);
+    assert_eq!(versions[0]["userDefinedFunctionVersionId"], "v2");
+    assert_eq!(body["count"], 1);
+}
+
+#[tokio::test]
+async fn list_versions_forwards_the_required_filter() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_function_versions()
+        .times(1)
+        .withf(|req| req.get_ref().filter == "version == 2")
+        .returning(|_| {
+            Ok(Response::new(ListUserDefinedFunctionVersionsResponse {
+                user_defined_functions: vec![UserDefinedFunction {
+                    version: 2,
+                    ..Default::default()
+                }],
+                next_page_token: String::new(),
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock, false, false).await;
+
+    server
+        .list_user_defined_function_versions(Parameters(UserDefinedFunctionVersionListParams {
+            user_defined_function_id: Some("f1".into()),
+            name: None,
+            filter: "version == 2".into(),
+            order_by: None,
+            limit: None,
+            fields: None,
+        }))
+        .await
+        .expect("list_user_defined_function_versions failed");
+}
+
+#[tokio::test]
+async fn list_versions_projects_requested_fields() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_list_user_defined_function_versions()
+        .returning(|_| {
+            Ok(Response::new(ListUserDefinedFunctionVersionsResponse {
+                user_defined_functions: vec![UserDefinedFunction {
+                    user_defined_function_id: "f1".into(),
+                    user_defined_function_version_id: "v2".into(),
+                    version: 2,
+                    name: "rms".into(),
+                    ..Default::default()
+                }],
+                next_page_token: String::new(),
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock, false, false).await;
+
+    let resp = server
+        .list_user_defined_function_versions(Parameters(UserDefinedFunctionVersionListParams {
+            user_defined_function_id: Some("f1".into()),
+            name: None,
+            filter: String::new(),
+            order_by: None,
+            limit: None,
+            fields: Some(vec!["version".into()]),
+        }))
+        .await
+        .expect("list_user_defined_function_versions failed");
+
+    let body = structured(resp);
+    assert_eq!(
+        body["user_defined_function_versions"],
+        serde_json::json!([{ "version": 2 }])
+    );
+    assert_eq!(body["count"], 1);
+}
+
+#[tokio::test]
+async fn list_versions_rejects_both_identifiers() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, false, false).await;
+
+    let err = server
+        .list_user_defined_function_versions(version_list_params(Some("f1"), Some("rms")))
+        .await
+        .expect_err("expected mutually exclusive params to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+    assert!(err.message.contains("exactly one"));
+}
+
+#[tokio::test]
+async fn list_versions_rejects_missing_identifier() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, false, false).await;
+
+    let err = server
+        .list_user_defined_function_versions(version_list_params(None, None))
+        .await
+        .expect_err("expected missing identifier to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+}
+
+#[tokio::test]
+async fn create_blocked_without_allow_create() {
+    // No expectations on the mock: the gate must fire before any RPC.
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, false, false).await;
+
+    let err = server
+        .create_user_defined_function(create_params(
+            "[{\"identifier\":\"x\",\"data_type\":\"numeric\"}]",
+        ))
+        .await
+        .expect_err("expected create gate to reject the call");
+
+    assert_eq!(err.code, ErrorCode::INVALID_REQUEST);
+    assert!(err.message.contains("--allow-create"));
+    let data = err
+        .data
+        .expect("create gate should return remediation data");
+    assert_eq!(
+        data["remediation_command"],
+        "sift-cli agent update --allow-create"
+    );
+}
+
+#[tokio::test]
+async fn create_rejects_malformed_function_inputs_json() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, false).await;
+
+    let err = server
+        .create_user_defined_function(create_params("{not json"))
+        .await
+        .expect_err("expected malformed JSON to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+    assert!(err.message.contains("`function_inputs_json`"));
+}
+
+#[tokio::test]
+async fn create_rejects_unknown_data_type() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, false).await;
+
+    let err = server
+        .create_user_defined_function(create_params(
+            "[{\"identifier\":\"x\",\"data_type\":\"complex\"}]",
+        ))
+        .await
+        .expect_err("expected unknown data_type to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+    assert!(err.message.contains("complex"));
+}
+
+#[tokio::test]
+async fn create_rejects_a_name_that_starts_with_a_digit() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, false).await;
+    let mut params = create_params("[]");
+    params.0.name = "1udf".into();
+
+    let err = server
+        .create_user_defined_function(params)
+        .await
+        .expect_err("expected invalid name to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+    assert!(err.message.contains("start with a letter"));
+}
+
+#[tokio::test]
+async fn update_rejects_a_name_with_a_hyphen() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, true).await;
+
+    let err = server
+        .update_user_defined_function(update_params(Some("udf-name"), None, None))
+        .await
+        .expect_err("expected invalid name to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+    assert!(err.message.contains("alphanumeric characters"));
+}
+
+#[tokio::test]
+async fn create_rejects_a_name_longer_than_253_characters() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, false).await;
+    let mut params = create_params("[]");
+    params.0.name = format!("a{}", "b".repeat(253));
+
+    let err = server
+        .create_user_defined_function(params)
+        .await
+        .expect_err("expected invalid name to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+    assert!(err.message.contains("253 characters"));
+}
+
+#[tokio::test]
+async fn create_returns_the_new_function_and_next_step() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_create_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            req.name == "rms"
+                && req.function_inputs.len() == 1
+                && req.function_inputs[0].identifier == "x"
+                && req.function_inputs[0].data_type == i32::from(FunctionDataType::Numeric)
+                && !req.function_inputs[0].constant
+        })
+        .returning(|req| {
+            let req = req.into_inner();
+            Ok(Response::new(CreateUserDefinedFunctionResponse {
+                user_defined_function: Some(UserDefinedFunction {
+                    user_defined_function_id: "f1".into(),
+                    user_defined_function_version_id: "v1".into(),
+                    version: 1,
+                    name: req.name,
+                    function_inputs: req.function_inputs,
+                    ..Default::default()
+                }),
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock, true, false).await;
+
+    let resp = server
+        .create_user_defined_function(create_params(
+            "[{\"identifier\":\"x\",\"data_type\":\"numeric\",\"constant\":false}]",
+        ))
+        .await
+        .expect("create_user_defined_function failed");
+
+    let body = structured(resp);
+    assert_eq!(body["user_defined_function_id"], "f1");
+    assert_eq!(body["user_defined_function"]["name"], "rms");
+    assert!(
+        body["next_step"]
+            .as_str()
+            .expect("next_step")
+            .contains("f1")
+    );
+}
+
+#[tokio::test]
+async fn update_blocked_without_allow_destructive() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, false, false).await;
+
+    let err = server
+        .update_user_defined_function(update_params(None, Some("updated"), None))
+        .await
+        .expect_err("expected destructive gate to reject the call");
+
+    assert_eq!(err.code, ErrorCode::INVALID_REQUEST);
+    assert!(err.message.contains("--allow-destructive"));
+    let data = err
+        .data
+        .expect("destructive gate should return remediation data");
+    assert_eq!(
+        data["remediation_command"],
+        "sift-cli agent update --allow-destructive"
+    );
+}
+
+#[tokio::test]
+async fn update_rejects_an_empty_mask() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, true).await;
+
+    let err = server
+        .update_user_defined_function(update_params(None, None, None))
+        .await
+        .expect_err("expected an empty update to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+    assert!(err.message.contains("at least one"));
+}
+
+#[tokio::test]
+async fn update_rejects_name_combined_with_other_fields() {
+    // The API applies a name change on its own and ignores the rest, so a mixed
+    // request would silently drop half the caller's intent.
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, true).await;
+
+    let err = server
+        .update_user_defined_function(update_params(Some("rms_v2"), Some("updated"), None))
+        .await
+        .expect_err("expected a mixed name update to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+    assert!(err.message.contains("`name`"));
+}
+
+#[tokio::test]
+async fn update_accepts_a_name_with_a_trailing_digit() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "f1");
+    mock.expect_update_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let function = req
+                .get_ref()
+                .user_defined_function
+                .as_ref()
+                .expect("function present");
+            function.name == "udf_1"
+        })
+        .returning(|req| {
+            Ok(Response::new(UpdateUserDefinedFunctionResponse {
+                user_defined_function: req.into_inner().user_defined_function,
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock, true, true).await;
+
+    server
+        .update_user_defined_function(update_params(Some("udf_1"), None, None))
+        .await
+        .expect("name with trailing digit should be accepted");
+}
+
+#[tokio::test]
+async fn update_rejects_malformed_function_inputs_json() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, true).await;
+
+    let err = server
+        .update_user_defined_function(update_params(None, None, Some("[{\"identifier\":}]")))
+        .await
+        .expect_err("expected malformed JSON to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+    assert!(err.message.contains("`function_inputs_json`"));
+}
+
+#[tokio::test]
+async fn update_returns_the_new_version() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "f1");
+    mock.expect_update_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let mask = req.get_ref().update_mask.as_ref().expect("mask present");
+            mask.paths == vec!["description".to_string()]
+        })
+        .returning(|req| {
+            let req = req.into_inner();
+            let mut function = req.user_defined_function.expect("function present");
+            function.version = 4;
+            function.user_defined_function_version_id = "v4".into();
+            Ok(Response::new(UpdateUserDefinedFunctionResponse {
+                user_defined_function: Some(function),
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock, true, true).await;
+
+    let resp = server
+        .update_user_defined_function(update_params(None, Some("updated"), None))
+        .await
+        .expect("update_user_defined_function failed");
+
+    let body = structured(resp);
+    assert_eq!(body["user_defined_function"]["version"], 4);
+    assert_eq!(
+        body["user_defined_function"]["userDefinedFunctionVersionId"],
+        "v4"
+    );
+    assert!(body["next_step"].as_str().expect("next_step").contains("4"));
+}
+
+#[tokio::test]
+async fn archive_blocked_without_allow_destructive() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, false).await;
+
+    let err = server
+        .archive_user_defined_function(archive_params("f1"))
+        .await
+        .expect_err("expected destructive gate to reject the call");
+
+    assert_eq!(err.code, ErrorCode::INVALID_REQUEST);
+    assert!(err.message.contains("--allow-destructive"));
+}
+
+#[tokio::test]
+async fn unarchive_blocked_without_allow_destructive() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, false).await;
+
+    let err = server
+        .unarchive_user_defined_function(archive_params("f1"))
+        .await
+        .expect_err("expected destructive gate to reject the call");
+
+    assert_eq!(err.code, ErrorCode::INVALID_REQUEST);
+    assert!(err.message.contains("--allow-destructive"));
+}
+
+#[tokio::test]
+async fn archive_rejects_an_empty_id() {
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, true).await;
+
+    let err = server
+        .archive_user_defined_function(archive_params(""))
+        .await
+        .expect_err("expected an empty id to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+}
+
+#[tokio::test]
+async fn archive_sets_the_archive_flag_and_reports_it() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "f1");
+    mock.expect_update_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            let function = req
+                .user_defined_function
+                .as_ref()
+                .expect("function present");
+            let mask = req.update_mask.as_ref().expect("mask present");
+            function.is_archived && mask.paths == vec!["is_archived".to_string()]
+        })
+        .returning(|req| {
+            let req = req.into_inner();
+            Ok(Response::new(UpdateUserDefinedFunctionResponse {
+                user_defined_function: req.user_defined_function,
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock, true, true).await;
+
+    let resp = server
+        .archive_user_defined_function(archive_params("f1"))
+        .await
+        .expect("archive_user_defined_function failed");
+
+    let body = structured(resp);
+    assert_eq!(body["archived"], true);
+    assert_eq!(body["user_defined_function"]["isArchived"], true);
+}
+
+#[tokio::test]
+async fn unarchive_clears_the_archive_flag_and_reports_it() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    expect_current_udf(&mut mock, "f2");
+    mock.expect_update_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let req = req.get_ref();
+            let function = req
+                .user_defined_function
+                .as_ref()
+                .expect("function present");
+            let mask = req.update_mask.as_ref().expect("mask present");
+            !function.is_archived && mask.paths == vec!["is_archived".to_string()]
+        })
+        .returning(|req| {
+            let req = req.into_inner();
+            Ok(Response::new(UpdateUserDefinedFunctionResponse {
+                user_defined_function: req.user_defined_function,
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock, true, true).await;
+
+    let resp = server
+        .unarchive_user_defined_function(archive_params("f2"))
+        .await
+        .expect("unarchive_user_defined_function failed");
+
+    let body = structured(resp);
+    assert_eq!(body["unarchived"], true);
+}
+
+#[tokio::test]
+async fn create_rejects_the_proto_enum_spelling_of_data_type() {
+    // The description documents `numeric`, `string`, and `bool` only. Accepting
+    // the raw proto enum names as well would be undocumented behavior.
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, false).await;
+
+    let err = server
+        .create_user_defined_function(create_params(
+            "[{\"identifier\":\"x\",\"data_type\":\"FUNCTION_DATA_TYPE_NUMERIC\"}]",
+        ))
+        .await
+        .expect_err("expected the proto enum spelling to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+    assert!(
+        err.message
+            .contains("expected `numeric`, `string`, or `bool`")
+    );
+}
+
+#[tokio::test]
+async fn create_rejects_a_camel_case_data_type_key() {
+    // Only the documented `data_type` key is accepted.
+    let mock = MockUserDefinedFunctionServiceImpl::new();
+    let (server, _h) = server_with_mock(mock, true, false).await;
+
+    let err = server
+        .create_user_defined_function(create_params(
+            "[{\"identifier\":\"x\",\"dataType\":\"numeric\"}]",
+        ))
+        .await
+        .expect_err("expected a camelCase key to be rejected");
+
+    assert_eq!(err.code, ErrorCode::INVALID_PARAMS);
+    assert!(err.message.contains("`function_inputs_json`"));
+}
+
+#[tokio::test]
+async fn create_maps_every_documented_data_type() {
+    let mut mock = MockUserDefinedFunctionServiceImpl::new();
+    mock.expect_create_user_defined_function()
+        .times(1)
+        .withf(|req| {
+            let inputs = &req.get_ref().function_inputs;
+            inputs
+                == &vec![
+                    numeric_input("x"),
+                    FunctionInput {
+                        identifier: "label".into(),
+                        data_type: FunctionDataType::String.into(),
+                        constant: true,
+                    },
+                    FunctionInput {
+                        identifier: "flag".into(),
+                        data_type: FunctionDataType::Bool.into(),
+                        constant: false,
+                    },
+                ]
+        })
+        .returning(|_| {
+            Ok(Response::new(CreateUserDefinedFunctionResponse {
+                user_defined_function: Some(UserDefinedFunction {
+                    user_defined_function_id: "f1".into(),
+                    ..Default::default()
+                }),
+            }))
+        });
+
+    let (server, _h) = server_with_mock(mock, true, false).await;
+
+    server
+        .create_user_defined_function(create_params(
+            "[{\"identifier\":\"x\",\"data_type\":\"numeric\"},\
+              {\"identifier\":\"label\",\"data_type\":\"STRING\",\"constant\":true},\
+              {\"identifier\":\"flag\",\"data_type\":\"bool\",\"constant\":false}]",
+        ))
+        .await
+        .expect("create_user_defined_function failed");
+}
diff --git a/rust/crates/sift_mcp/src/tool_events.json b/rust/crates/sift_mcp/src/tool_events.json
index c6b3fb8ca..91334fea0 100644
--- a/rust/crates/sift_mcp/src/tool_events.json
+++ b/rust/crates/sift_mcp/src/tool_events.json
@@ -2,6 +2,7 @@
   "append_test_measurements": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_APPEND_TEST_MEASUREMENTS",
   "archive_calculated_channel": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_ARCHIVE_CALCULATED_CHANNEL",
   "archive_rule": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_ARCHIVE_RULE",
+  "archive_user_defined_function": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_ARCHIVE_USER_DEFINED_FUNCTION",
   "check_for_updates": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_CHECK_FOR_UPDATES",
   "count_test_measurements": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_COUNT_TEST_MEASUREMENTS",
   "count_test_steps": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_COUNT_TEST_STEPS",
@@ -11,6 +12,7 @@
   "create_report_template": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_CREATE_REPORT_TEMPLATE",
   "create_rule": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_CREATE_RULE",
   "create_test_report": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_CREATE_TEST_REPORT",
+  "create_user_defined_function": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_CREATE_USER_DEFINED_FUNCTION",
   "explore_url": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_EXPLORE_URL",
   "get_data": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_GET_DATA",
   "list_annotations": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_LIST_ANNOTATIONS",
@@ -27,12 +29,16 @@
   "list_test_measurements": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_LIST_TEST_MEASUREMENTS",
   "list_test_reports": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_LIST_TEST_REPORTS",
   "list_test_steps": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_LIST_TEST_STEPS",
+  "list_user_defined_function_versions": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_LIST_USER_DEFINED_FUNCTION_VERSIONS",
+  "list_user_defined_functions": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_LIST_USER_DEFINED_FUNCTIONS",
   "list_users": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_LIST_USERS",
   "ping": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_PING",
+  "preview_rule": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_PREVIEW_RULE",
   "search_docs": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_SEARCH_DOCS",
   "sql": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_SQL",
   "unarchive_calculated_channel": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_UNARCHIVE_CALCULATED_CHANNEL",
   "unarchive_rule": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_UNARCHIVE_RULE",
+  "unarchive_user_defined_function": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_UNARCHIVE_USER_DEFINED_FUNCTION",
   "update_annotation": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_UPDATE_ANNOTATION",
   "update_asset": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_UPDATE_ASSET",
   "update_calculated_channel": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_UPDATE_CALCULATED_CHANNEL",
@@ -40,5 +46,6 @@
   "update_report_template": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_UPDATE_REPORT_TEMPLATE",
   "update_rule": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_UPDATE_RULE",
   "update_run": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_UPDATE_RUN",
+  "update_user_defined_function": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_UPDATE_USER_DEFINED_FUNCTION",
   "upload_dataset": "CLIENT_EVENT_USER_CALLED_MCP_TOOL_UPLOAD_DATASET"
 }
diff --git a/rust/crates/sift_test_util/src/mock/mod.rs b/rust/crates/sift_test_util/src/mock/mod.rs
index a7a7c812c..8d9c64c10 100644
--- a/rust/crates/sift_test_util/src/mock/mod.rs
+++ b/rust/crates/sift_test_util/src/mock/mod.rs
@@ -11,6 +11,7 @@ pub mod rule_evaluation;
 pub mod rules;
 pub mod runs;
 pub mod test_reports;
+pub mod user_defined_functions;
 pub mod users;
 
 /// A test demonstrating a little bit of everything of how to leverage the mock API.
diff --git a/rust/crates/sift_test_util/src/mock/user_defined_functions/mod.rs b/rust/crates/sift_test_util/src/mock/user_defined_functions/mod.rs
new file mode 100644
index 000000000..a3a6d96c3
--- /dev/null
+++ b/rust/crates/sift_test_util/src/mock/user_defined_functions/mod.rs
@@ -0,0 +1 @@
+pub mod v1;
diff --git a/rust/crates/sift_test_util/src/mock/user_defined_functions/v1.rs b/rust/crates/sift_test_util/src/mock/user_defined_functions/v1.rs
new file mode 100644
index 000000000..38333df82
--- /dev/null
+++ b/rust/crates/sift_test_util/src/mock/user_defined_functions/v1.rs
@@ -0,0 +1,94 @@
+use async_trait::async_trait;
+use mockall::mock;
+use sift_rs::user_defined_functions::v1::{
+    CheckUpdatableFieldsRequest, CheckUpdatableFieldsResponse, CreateUserDefinedFunctionRequest,
+    CreateUserDefinedFunctionResponse, GetUserDefinedFunctionDependentsRequest,
+    GetUserDefinedFunctionDependentsResponse, GetUserDefinedFunctionRequest,
+    GetUserDefinedFunctionResponse, GetUserDefinedFunctionVersionRequest,
+    GetUserDefinedFunctionVersionResponse, GetUserDefinedFunctionVersionsRequest,
+    GetUserDefinedFunctionVersionsResponse, ListUserDefinedFunctionVersionsRequest,
+    ListUserDefinedFunctionVersionsResponse, ListUserDefinedFunctionsRequest,
+    ListUserDefinedFunctionsResponse, UpdateUserDefinedFunctionRequest,
+    UpdateUserDefinedFunctionResponse, ValidateUserDefinedFunctionRequest,
+    ValidateUserDefinedFunctionResponse,
+    user_defined_function_service_server::UserDefinedFunctionService,
+};
+use tonic::{Request, Response, Status};
+
+mock! {
+    pub UserDefinedFunctionServiceImpl {}
+
+    #[async_trait]
+    impl UserDefinedFunctionService for UserDefinedFunctionServiceImpl {
+        async fn get_user_defined_function(
+            &self,
+            request: Request<GetUserDefinedFunctionRequest>,
+        ) -> std::result::Result<
+            Response<GetUserDefinedFunctionResponse>,
+            Status,
+        >;
+        async fn get_user_defined_function_version(
+            &self,
+            request: Request<GetUserDefinedFunctionVersionRequest>,
+        ) -> std::result::Result<
+            Response<GetUserDefinedFunctionVersionResponse>,
+            Status,
+        >;
+        async fn get_user_defined_function_versions(
+            &self,
+            request: Request<GetUserDefinedFunctionVersionsRequest>,
+        ) -> std::result::Result<
+            Response<GetUserDefinedFunctionVersionsResponse>,
+            Status,
+        >;
+        async fn get_user_defined_function_dependents(
+            &self,
+            request: Request<GetUserDefinedFunctionDependentsRequest>,
+        ) -> std::result::Result<
+            Response<GetUserDefinedFunctionDependentsResponse>,
+            Status,
+        >;
+        async fn create_user_defined_function(
+            &self,
+            request: Request<CreateUserDefinedFunctionRequest>,
+        ) -> std::result::Result<
+            Response<CreateUserDefinedFunctionResponse>,
+            Status,
+        >;
+        async fn validate_user_defined_function(
+            &self,
+            request: Request<ValidateUserDefinedFunctionRequest>,
+        ) -> std::result::Result<
+            Response<ValidateUserDefinedFunctionResponse>,
+            Status,
+        >;
+        async fn update_user_defined_function(
+            &self,
+            request: Request<UpdateUserDefinedFunctionRequest>,
+        ) -> std::result::Result<
+            Response<UpdateUserDefinedFunctionResponse>,
+            Status,
+        >;
+        async fn check_updatable_fields(
+            &self,
+            request: Request<CheckUpdatableFieldsRequest>,
+        ) -> std::result::Result<
+            Response<CheckUpdatableFieldsResponse>,
+            Status,
+        >;
+        async fn list_user_defined_functions(
+            &self,
+            request: Request<ListUserDefinedFunctionsRequest>,
+        ) -> std::result::Result<
+            Response<ListUserDefinedFunctionsResponse>,
+            Status,
+        >;
+        async fn list_user_defined_function_versions(
+            &self,
+            request: Request<ListUserDefinedFunctionVersionsRequest>,
+        ) -> std::result::Result<
+            Response<ListUserDefinedFunctionVersionsResponse>,
+            Status,
+        >;
+    }
+}