diff --git a/cedar-policy-core/src/ast.rs b/cedar-policy-core/src/ast.rs
index c987c18f2..9a827dcc9 100644
--- a/cedar-policy-core/src/ast.rs
+++ b/cedar-policy-core/src/ast.rs
@@ -22,6 +22,8 @@ mod entity;
 pub use entity::*;
 mod extension;
 pub use extension::*;
+mod id;
+pub use id::*;
 mod integer;
 pub use integer::{InputInteger, Integer};
 mod literal;
diff --git a/cedar-policy-core/src/ast/id.rs b/cedar-policy-core/src/ast/id.rs
new file mode 100644
index 000000000..80a6d980f
--- /dev/null
+++ b/cedar-policy-core/src/ast/id.rs
@@ -0,0 +1,217 @@
+use serde::{Deserialize, Serialize};
+use smol_str::SmolStr;
+
+use crate::{parser::err::ParseErrors, FromNormalizedStr};
+
+/// Identifiers. Anything in `Id` should be a valid identifier, this means it
+/// does not contain, for instance, spaces or characters like '+'; and also is
+/// not one of the Cedar reserved identifiers (at time of writing,
+/// `true | false | if | then | else | in | is | like | has`).
+//
+// For now, internally, `Id`s are just owned `SmolString`s.
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone, Hash, PartialOrd, Ord)]
+pub struct Id(SmolStr);
+
+impl Id {
+    /// Create a new `Id` from a `String`, where it is the caller's
+    /// responsibility to ensure that the string is indeed a valid identifier.
+    ///
+    /// When possible, callers should not use this, and instead use `s.parse()`,
+    /// which checks that `s` is a valid identifier, and returns a parse error
+    /// if not.
+    ///
+    /// This method was created for the `From<cst::Ident> for Id` impl to use.
+    /// Since `parser::parse_ident()` implicitly uses that `From` impl itself,
+    /// if we tried to make that `From` impl go through `.parse()` like everyone
+    /// else, we'd get infinite recursion.  And, we assert that `cst::Ident` is
+    /// always already checked to contain a valid identifier, otherwise it would
+    /// never have been created.
+    pub(crate) fn new_unchecked(s: impl Into<SmolStr>) -> Id {
+        Id(s.into())
+    }
+
+    /// Get the underlying string
+    pub fn into_smolstr(self) -> SmolStr {
+        self.0
+    }
+}
+
+impl AsRef<str> for Id {
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
+
+impl std::fmt::Display for Id {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+
+// allow `.parse()` on a string to make an `Id`
+impl std::str::FromStr for Id {
+    type Err = ParseErrors;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        crate::parser::parse_ident(s)
+    }
+}
+
+impl FromNormalizedStr for Id {
+    fn describe_self() -> &'static str {
+        "Id"
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> arbitrary::Arbitrary<'a> for Id {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        // identifier syntax:
+        // IDENT     := ['_''a'-'z''A'-'Z']['_''a'-'z''A'-'Z''0'-'9']* - RESERVED
+        // BOOL      := 'true' | 'false'
+        // RESERVED  := BOOL | 'if' | 'then' | 'else' | 'in' | 'is' | 'like' | 'has'
+
+        let construct_list = |s: &str| s.chars().collect::<Vec<char>>();
+        let list_concat = |s1: &[char], s2: &[char]| [s1, s2].concat();
+        // the set of the first character of an identifier
+        let head_letters = construct_list("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_");
+        // the set of the remaining characters of an identifier
+        let tail_letters = list_concat(&construct_list("0123456789"), &head_letters);
+        // identifier character count minus 1
+        let remaining_length = u.int_in_range(0..=16)?;
+        let mut cs = vec![*u.choose(&head_letters)?];
+        cs.extend(
+            (0..remaining_length)
+                .map(|_| u.choose(&tail_letters))
+                .collect::<Result<Vec<&char>, _>>()?,
+        );
+        let mut s: String = cs.into_iter().collect();
+        // Should the parsing fails, the string should be reserved word.
+        // Append a `_` to create a valid Id.
+        if crate::parser::parse_ident(&s).is_err() {
+            s.push('_');
+        }
+        Ok(Self::new_unchecked(s))
+    }
+
+    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+        arbitrary::size_hint::and_all(&[
+            // for arbitrary length
+            <usize as arbitrary::Arbitrary>::size_hint(depth),
+            // for arbitrary choices
+            // we use the size hint of a vector of `u8` to get an underestimate of bytes required by the sequence of choices.
+            <Vec<u8> as arbitrary::Arbitrary>::size_hint(depth),
+        ])
+    }
+}
+
+/// Like `Id`, except this specifically _can_ contain Cedar reserved identifiers.
+/// (It still can't contain, for instance, spaces or characters like '+'.)
+//
+// For now, internally, `AnyId`s are just owned `SmolString`s.
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone, Hash, PartialOrd, Ord)]
+pub struct AnyId(SmolStr);
+
+impl AnyId {
+    /// Create a new `AnyId` from a `String`, where it is the caller's
+    /// responsibility to ensure that the string is indeed a valid `AnyId`.
+    ///
+    /// When possible, callers should not use this, and instead use `s.parse()`,
+    /// which checks that `s` is a valid `AnyId`, and returns a parse error
+    /// if not.
+    ///
+    /// This method was created for the `From<cst::Ident> for AnyId` impl to use.
+    /// See notes on `Id::new_unchecked()`.
+    pub(crate) fn new_unchecked(s: impl Into<SmolStr>) -> AnyId {
+        AnyId(s.into())
+    }
+
+    /// Get the underlying string
+    pub fn into_smolstr(self) -> SmolStr {
+        self.0
+    }
+}
+
+impl AsRef<str> for AnyId {
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
+
+impl std::fmt::Display for AnyId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+
+// allow `.parse()` on a string to make an `AnyId`
+impl std::str::FromStr for AnyId {
+    type Err = ParseErrors;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        crate::parser::parse_anyid(s)
+    }
+}
+
+impl FromNormalizedStr for AnyId {
+    fn describe_self() -> &'static str {
+        "AnyId"
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> arbitrary::Arbitrary<'a> for AnyId {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        // AnyId syntax:
+        // ['_''a'-'z''A'-'Z']['_''a'-'z''A'-'Z''0'-'9']*
+
+        let construct_list = |s: &str| s.chars().collect::<Vec<char>>();
+        let list_concat = |s1: &[char], s2: &[char]| [s1, s2].concat();
+        // the set of the first character of an AnyId
+        let head_letters = construct_list("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_");
+        // the set of the remaining characters of an AnyId
+        let tail_letters = list_concat(&construct_list("0123456789"), &head_letters);
+        // identifier character count minus 1
+        let remaining_length = u.int_in_range(0..=16)?;
+        let mut cs = vec![*u.choose(&head_letters)?];
+        cs.extend(
+            (0..remaining_length)
+                .map(|_| u.choose(&tail_letters))
+                .collect::<Result<Vec<&char>, _>>()?,
+        );
+        let s: String = cs.into_iter().collect();
+        debug_assert!(
+            crate::parser::parse_ident(&s).is_ok(),
+            "all strings constructed this way should be valid AnyIds, but this one is not: {s:?}"
+        );
+        Ok(Self::new_unchecked(s))
+    }
+
+    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+        arbitrary::size_hint::and_all(&[
+            // for arbitrary length
+            <usize as arbitrary::Arbitrary>::size_hint(depth),
+            // for arbitrary choices
+            // we use the size hint of a vector of `u8` to get an underestimate of bytes required by the sequence of choices.
+            <Vec<u8> as arbitrary::Arbitrary>::size_hint(depth),
+        ])
+    }
+}
+
+// PANIC SAFETY: unit-test code
+#[allow(clippy::panic)]
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn normalized_id() {
+        Id::from_normalized_str("foo").expect("should be OK");
+        Id::from_normalized_str("foo::bar").expect_err("shouldn't be OK");
+        Id::from_normalized_str(r#"foo::"bar""#).expect_err("shouldn't be OK");
+        Id::from_normalized_str(" foo").expect_err("shouldn't be OK");
+        Id::from_normalized_str("foo ").expect_err("shouldn't be OK");
+        Id::from_normalized_str("foo\n").expect_err("shouldn't be OK");
+        Id::from_normalized_str("foo//comment").expect_err("shouldn't be OK");
+    }
+}
diff --git a/cedar-policy-core/src/ast/name.rs b/cedar-policy-core/src/ast/name.rs
index 871547376..8cc8c23e0 100644
--- a/cedar-policy-core/src/ast/name.rs
+++ b/cedar-policy-core/src/ast/name.rs
@@ -14,11 +14,10 @@
  * limitations under the License.
  */
 
-use std::sync::Arc;
-
+use super::id::Id;
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};
-use smol_str::SmolStr;
+use std::sync::Arc;
 
 use crate::parser::err::ParseErrors;
 use crate::FromNormalizedStr;
@@ -197,122 +196,11 @@ mod vars_test {
     }
 }
 
-/// Identifiers. Anything in `Id` should be a valid identifier (and not contain,
-/// for instance, spaces or characters like '+').
-//
-// For now, internally, `Id`s are just owned `SmolString`s.
-#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone, Hash, PartialOrd, Ord)]
-pub struct Id(SmolStr);
-
-impl Id {
-    /// Create a new `Id` from a `String`, where it is the caller's
-    /// responsibility to ensure that the string is indeed a valid identifier.
-    ///
-    /// When possible, callers should not use this, and instead use `s.parse()`,
-    /// which checks that `s` is a valid identifier, and returns a parse error
-    /// if not.
-    ///
-    /// This method was created for the `From<cst::Ident> for Id` impl to use.
-    /// Since `parser::parse_ident()` implicitly uses that `From` impl itself,
-    /// if we tried to make that `From` impl go through `.parse()` like everyone
-    /// else, we'd get infinite recursion.  And, we assert that `cst::Ident` is
-    /// always already checked to contain a valid identifier, otherwise it would
-    /// never have been created.
-    pub(crate) fn new_unchecked(s: impl Into<SmolStr>) -> Id {
-        Id(s.into())
-    }
-
-    /// Get the underlying string
-    pub fn to_smolstr(self) -> SmolStr {
-        self.0
-    }
-}
-
-impl AsRef<str> for Id {
-    fn as_ref(&self) -> &str {
-        &self.0
-    }
-}
-
-impl std::fmt::Display for Id {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", &self.0)
-    }
-}
-
-// allow `.parse()` on a string to make an `Id`
-impl std::str::FromStr for Id {
-    type Err = ParseErrors;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        crate::parser::parse_ident(s)
-    }
-}
-
-impl FromNormalizedStr for Id {
-    fn describe_self() -> &'static str {
-        "Id"
-    }
-}
-
-#[cfg(feature = "arbitrary")]
-impl<'a> arbitrary::Arbitrary<'a> for Id {
-    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
-        // identifier syntax:
-        // IDENT     := ['_''a'-'z''A'-'Z']['_''a'-'z''A'-'Z''0'-'9']* - RESERVED
-        // BOOL      := 'true' | 'false'
-        // RESERVED  := BOOL | 'if' | 'then' | 'else' | 'in' | 'like' | 'has'
-
-        let construct_list = |s: &str| s.chars().collect::<Vec<char>>();
-        let list_concat = |s1: &[char], s2: &[char]| [s1, s2].concat();
-        // the set of the first character of an identifier
-        let head_letters = construct_list("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_");
-        // the set of the remaining characters of an identifier
-        let tail_letters = list_concat(&construct_list("0123456789"), &head_letters);
-        // identifier character count minus 1
-        let remaining_length = u.int_in_range(0..=16)?;
-        let mut cs = vec![*u.choose(&head_letters)?];
-        cs.extend(
-            (0..remaining_length)
-                .map(|_| u.choose(&tail_letters))
-                .collect::<Result<Vec<&char>, _>>()?,
-        );
-        let mut s: String = cs.into_iter().collect();
-        // Should the parsing fails, the string should be reserved word.
-        // Append a `_` to create a valid Id.
-        if crate::parser::parse_ident(&s).is_err() {
-            s.push('_');
-        }
-        Ok(Self::new_unchecked(s))
-    }
-
-    fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        arbitrary::size_hint::and_all(&[
-            // for arbitrary length
-            <usize as arbitrary::Arbitrary>::size_hint(depth),
-            // for arbitrary choices
-            // we use the size hint of a vector of `u8` to get an underestimate of bytes required by the sequence of choices.
-            <Vec<u8> as arbitrary::Arbitrary>::size_hint(depth),
-        ])
-    }
-}
-
 #[cfg(test)]
 mod test {
 
     use super::*;
 
-    #[test]
-    fn normalized_id() {
-        Id::from_normalized_str("foo").expect("should be OK");
-        Id::from_normalized_str("foo::bar").expect_err("shouldn't be OK");
-        Id::from_normalized_str(r#"foo::"bar""#).expect_err("shouldn't be OK");
-        Id::from_normalized_str(" foo").expect_err("shouldn't be OK");
-        Id::from_normalized_str("foo ").expect_err("shouldn't be OK");
-        Id::from_normalized_str("foo\n").expect_err("shouldn't be OK");
-        Id::from_normalized_str("foo//comment").expect_err("shouldn't be OK");
-    }
-
     #[test]
     fn normalized_name() {
         Name::from_normalized_str("foo").expect("should be OK");
diff --git a/cedar-policy-core/src/ast/policy.rs b/cedar-policy-core/src/ast/policy.rs
index 03ebd3b9a..5a7b8a945 100644
--- a/cedar-policy-core/src/ast/policy.rs
+++ b/cedar-policy-core/src/ast/policy.rs
@@ -63,7 +63,7 @@ impl Template {
     /// Construct a `Template` from its components
     pub fn new(
         id: PolicyID,
-        annotations: BTreeMap<Id, SmolStr>,
+        annotations: BTreeMap<AnyId, SmolStr>,
         effect: Effect,
         principal_constraint: PrincipalConstraint,
         action_constraint: ActionConstraint,
@@ -123,12 +123,12 @@ impl Template {
     }
 
     /// Get data from an annotation.
-    pub fn annotation(&self, key: &Id) -> Option<&SmolStr> {
+    pub fn annotation(&self, key: &AnyId) -> Option<&SmolStr> {
         self.body.annotation(key)
     }
 
     /// Get all annotation data.
-    pub fn annotations(&self) -> impl Iterator<Item = (&Id, &SmolStr)> {
+    pub fn annotations(&self) -> impl Iterator<Item = (&AnyId, &SmolStr)> {
         self.body.annotations()
     }
 
@@ -366,12 +366,12 @@ impl Policy {
     }
 
     /// Get data from an annotation.
-    pub fn annotation(&self, key: &Id) -> Option<&SmolStr> {
+    pub fn annotation(&self, key: &AnyId) -> Option<&SmolStr> {
         self.template.annotation(key)
     }
 
     /// Get all annotation data.
-    pub fn annotations(&self) -> impl Iterator<Item = (&Id, &SmolStr)> {
+    pub fn annotations(&self) -> impl Iterator<Item = (&AnyId, &SmolStr)> {
         self.template.annotations()
     }
 
@@ -672,12 +672,12 @@ impl StaticPolicy {
     }
 
     /// Get data from an annotation.
-    pub fn annotation(&self, key: &Id) -> Option<&SmolStr> {
+    pub fn annotation(&self, key: &AnyId) -> Option<&SmolStr> {
         self.0.annotation(key)
     }
 
     /// Get all annotation data.
-    pub fn annotations(&self) -> impl Iterator<Item = (&Id, &SmolStr)> {
+    pub fn annotations(&self) -> impl Iterator<Item = (&AnyId, &SmolStr)> {
         self.0.annotations()
     }
 
@@ -734,10 +734,10 @@ impl StaticPolicy {
         self.0.condition()
     }
 
-    /// Construct a `Policy` from its components
+    /// Construct a `StaticPolicy` from its components
     pub fn new(
         id: PolicyID,
-        annotations: BTreeMap<Id, SmolStr>,
+        annotations: BTreeMap<AnyId, SmolStr>,
         effect: Effect,
         principal_constraint: PrincipalConstraint,
         action_constraint: ActionConstraint,
@@ -789,16 +789,16 @@ impl From<StaticPolicy> for Arc<Template> {
     }
 }
 
-/// Policy datatype.
-///
-/// This will also represent the serialized form of policies on disk
-/// and on the network.
+/// Policy datatype. This is used for both templates (in which case it contains
+/// slots) and static policies (in which case it contains zero slots).
 #[derive(Serialize, Deserialize, Clone, Hash, Eq, PartialEq, Debug)]
 pub struct TemplateBody {
     /// ID of this policy
     id: PolicyID,
-    /// Annotations available for external applications, as key-value store
-    annotations: BTreeMap<Id, SmolStr>,
+    /// Annotations available for external applications, as key-value store.
+    /// Note that the keys are `AnyId`, so Cedar reserved words like `if` and `has`
+    /// are explicitly allowed as annotations.
+    annotations: BTreeMap<AnyId, SmolStr>,
     /// `Effect` of this policy
     effect: Effect,
     /// Head constraint for principal. This will be a boolean-valued expression:
@@ -839,12 +839,12 @@ impl TemplateBody {
     }
 
     /// Get data from an annotation.
-    pub fn annotation(&self, key: &Id) -> Option<&SmolStr> {
+    pub fn annotation(&self, key: &AnyId) -> Option<&SmolStr> {
         self.annotations.get(key)
     }
 
     /// Get all annotation data.
-    pub fn annotations(&self) -> impl Iterator<Item = (&Id, &SmolStr)> {
+    pub fn annotations(&self) -> impl Iterator<Item = (&AnyId, &SmolStr)> {
         self.annotations.iter()
     }
 
@@ -913,7 +913,7 @@ impl TemplateBody {
     /// Construct a `Policy` from its components
     pub fn new(
         id: PolicyID,
-        annotations: BTreeMap<Id, SmolStr>,
+        annotations: BTreeMap<AnyId, SmolStr>,
         effect: Effect,
         principal_constraint: PrincipalConstraint,
         action_constraint: ActionConstraint,
@@ -1657,7 +1657,7 @@ mod test {
 
     use super::{test_generators::*, *};
     use crate::{
-        ast::{entity, name, EntityUID},
+        ast::{entity, id, name, EntityUID},
         parser::{
             err::{ParseError, ParseErrors, ToASTError, ToASTErrorKind},
             parse_policy, Loc,
@@ -1948,7 +1948,7 @@ mod test {
     #[test]
     fn test_iter_once() {
         let id = EntityUID::from_components(
-            name::Name::unqualified_name(name::Id::new_unchecked("s")),
+            name::Name::unqualified_name(id::Id::new_unchecked("s")),
             entity::Eid::new("eid"),
         );
         let mut i = EntityIterator::One(&id);
@@ -1959,11 +1959,11 @@ mod test {
     #[test]
     fn test_iter_mult() {
         let id1 = EntityUID::from_components(
-            name::Name::unqualified_name(name::Id::new_unchecked("s")),
+            name::Name::unqualified_name(id::Id::new_unchecked("s")),
             entity::Eid::new("eid1"),
         );
         let id2 = EntityUID::from_components(
-            name::Name::unqualified_name(name::Id::new_unchecked("s")),
+            name::Name::unqualified_name(id::Id::new_unchecked("s")),
             entity::Eid::new("eid2"),
         );
         let v = vec![&id1, &id2];
diff --git a/cedar-policy-core/src/ast/value.rs b/cedar-policy-core/src/ast/value.rs
index 7ae3c140c..26bae906f 100644
--- a/cedar-policy-core/src/ast/value.rs
+++ b/cedar-policy-core/src/ast/value.rs
@@ -404,7 +404,7 @@ impl Eq for ValueKind {}
 // The implementation of `PartialEq` for `Value` ignores the `Loc` of the values.
 impl PartialEq for Value {
     fn eq(&self, other: &Value) -> bool {
-        &self.value == &other.value
+        self.value == other.value
     }
 }
 
diff --git a/cedar-policy-core/src/entities/conformance.rs b/cedar-policy-core/src/entities/conformance.rs
index 1a9f15c68..43abe3715 100644
--- a/cedar-policy-core/src/entities/conformance.rs
+++ b/cedar-policy-core/src/entities/conformance.rs
@@ -148,7 +148,7 @@ impl<'a, S: Schema> EntitySchemaConformanceChecker<'a, S> {
         if etype.is_action() {
             let schema_action = self
                 .schema
-                .action(&uid)
+                .action(uid)
                 .ok_or(EntitySchemaConformanceError::UndeclaredAction { uid: uid.clone() })?;
             // check that the action exactly matches the schema's definition
             if !entity.deep_eq(&schema_action) {
diff --git a/cedar-policy-core/src/est.rs b/cedar-policy-core/src/est.rs
index 1c96d215a..db51b6b23 100644
--- a/cedar-policy-core/src/est.rs
+++ b/cedar-policy-core/src/est.rs
@@ -51,7 +51,7 @@ pub struct Policy {
     #[serde(default)]
     #[serde(skip_serializing_if = "HashMap::is_empty")]
     #[serde_as(as = "serde_with::MapPreventDuplicates<_,_>")]
-    annotations: HashMap<ast::Id, SmolStr>,
+    annotations: HashMap<ast::AnyId, SmolStr>,
 }
 
 /// Serde JSON structure for a `when` or `unless` clause in the EST format
@@ -576,6 +576,82 @@ mod test {
         );
     }
 
+    /// Test that we can use Cedar reserved words like `if` and `has` as annotation keys
+    #[test]
+    fn reserved_words_as_annotations() {
+        let policy = r#"
+            @if("this is the annotation for `if`")
+            @then("this is the annotation for `then`")
+            @else("this is the annotation for `else`")
+            @true("this is the annotation for `true`")
+            @false("this is the annotation for `false`")
+            @in("this is the annotation for `in`")
+            @is("this is the annotation for `is`")
+            @like("this is the annotation for `like`")
+            @has("this is the annotation for `has`")
+            @principal("this is the annotation for `principal`") // not reserved at time of this writing, but we test it anyway
+            permit(principal, action, resource) when { 2 == 2 };
+        "#;
+
+        let cst = parser::text_to_cst::parse_policy(policy)
+            .unwrap()
+            .node
+            .unwrap();
+        let est: Policy = cst.try_into().unwrap();
+        let expected_json = json!(
+            {
+                "effect": "permit",
+                "principal": {
+                    "op": "All",
+                },
+                "action": {
+                    "op": "All",
+                },
+                "resource": {
+                    "op": "All",
+                },
+                "conditions": [
+                    {
+                        "kind": "when",
+                        "body": {
+                            "==": {
+                                "left": { "Value": 2 },
+                                "right": { "Value": 2 },
+                            }
+                        }
+                    }
+                ],
+                "annotations": {
+                    "if": "this is the annotation for `if`",
+                    "then": "this is the annotation for `then`",
+                    "else": "this is the annotation for `else`",
+                    "true": "this is the annotation for `true`",
+                    "false": "this is the annotation for `false`",
+                    "in": "this is the annotation for `in`",
+                    "is": "this is the annotation for `is`",
+                    "like": "this is the annotation for `like`",
+                    "has": "this is the annotation for `has`",
+                    "principal": "this is the annotation for `principal`",
+                }
+            }
+        );
+        assert_eq!(
+            serde_json::to_value(&est).unwrap(),
+            expected_json,
+            "\nExpected:\n{}\n\nActual:\n{}\n\n",
+            serde_json::to_string_pretty(&expected_json).unwrap(),
+            serde_json::to_string_pretty(&est).unwrap()
+        );
+        let old_est = est.clone();
+        let roundtripped = est_roundtrip(est);
+        assert_eq!(&old_est, &roundtripped);
+        let est = text_roundtrip(&old_est);
+        assert_eq!(&old_est, &est);
+
+        assert_eq!(ast_roundtrip(est.clone()), est);
+        assert_eq!(circular_roundtrip(est.clone()), est);
+    }
+
     #[test]
     fn rbac_policy() {
         let policy = r#"
diff --git a/cedar-policy-core/src/parser.rs b/cedar-policy-core/src/parser.rs
index 0c6061ee3..0cc798292 100644
--- a/cedar-policy-core/src/parser.rs
+++ b/cedar-policy-core/src/parser.rs
@@ -347,6 +347,23 @@ pub(crate) fn parse_ident(id: &str) -> Result<ast::Id, err::ParseErrors> {
     }
 }
 
+/// parse an `AnyId`
+///
+/// Private to this crate. Users outside Core should use `AnyId`'s `FromStr` impl
+/// or its constructors
+pub(crate) fn parse_anyid(id: &str) -> Result<ast::AnyId, err::ParseErrors> {
+    let mut errs = err::ParseErrors::new();
+    let cst = text_to_cst::parse_ident(id)?;
+    let Some(ast) = cst.to_any_ident(&mut errs) else {
+        return Err(errs);
+    };
+    if errs.is_empty() {
+        Ok(ast)
+    } else {
+        Err(errs)
+    }
+}
+
 /// Utilities used in tests in this file
 #[cfg(test)]
 mod test_utils {
diff --git a/cedar-policy-core/src/parser/cst_to_ast.rs b/cedar-policy-core/src/parser/cst_to_ast.rs
index 51ec93612..075977e9a 100644
--- a/cedar-policy-core/src/parser/cst_to_ast.rs
+++ b/cedar-policy-core/src/parser/cst_to_ast.rs
@@ -348,13 +348,13 @@ impl cst::Policy {
 impl Node<Option<cst::Annotation>> {
     /// Get the (k, v) pair for the annotation. Critically, this checks validity
     /// for the strings and does unescaping
-    pub fn to_kv_pair(&self, errs: &mut ParseErrors) -> Option<(ast::Id, SmolStr)> {
+    pub fn to_kv_pair(&self, errs: &mut ParseErrors) -> Option<(ast::AnyId, SmolStr)> {
         // if `self` doesn't have data, nothing we can do here, just propagate
         // the `None`; we don't need to signal an error, because one was already
         // signaled when the `Node` without data was created
         let anno = self.as_inner()?;
 
-        let maybe_key = anno.key.to_valid_ident(errs);
+        let maybe_key = anno.key.to_any_ident(errs);
         let maybe_value = anno.value.as_valid_string(errs);
         let maybe_value = match maybe_value.map(|s| to_unescaped_string(s)).transpose() {
             Ok(maybe_value) => maybe_value,
@@ -396,7 +396,27 @@ impl Node<Option<cst::Ident>> {
                 errs.push(self.to_ast_err(ToASTErrorKind::InvalidIdentifier(i.clone())));
                 None
             }
-            _ => Some(construct_id(format!("{ident}"))),
+            _ => Some(ast::Id::new_unchecked(format!("{ident}"))),
+        }
+    }
+
+    /// Convert [`cst::Ident`] to [`ast::AnyId`]. This method does not fail for
+    /// reserved identifiers; see notes on [`ast::AnyId`].
+    /// (It does fail for invalid identifiers, but there are no invalid
+    /// identifiers at the time of this writing; see notes on
+    /// [`cst::Ident::Invalid`])
+    pub fn to_any_ident(&self, errs: &mut ParseErrors) -> Option<ast::AnyId> {
+        // if `self` doesn't have data, nothing we can do here, just propagate
+        // the `None`; we don't need to signal an error, because one was already
+        // signaled when the `Node` without data was created
+        let ident = self.as_inner()?;
+
+        match ident {
+            cst::Ident::Invalid(i) => {
+                errs.push(self.to_ast_err(ToASTErrorKind::InvalidIdentifier(i.clone())));
+                None
+            }
+            _ => Some(ast::AnyId::new_unchecked(format!("{ident}"))),
         }
     }
 
@@ -1770,7 +1790,7 @@ impl Node<Option<cst::Member>> {
                     head = Some(Expr {
                         expr: construct_expr_attr(
                             construct_expr_var(var, var_loc.clone()),
-                            id.to_smolstr(),
+                            id.into_smolstr(),
                             self.loc.clone(),
                         ),
                         loc: self.loc.clone(),
@@ -1782,7 +1802,7 @@ impl Node<Option<cst::Member>> {
                     let expr = mem::replace(expr, ast::Expr::val(false));
                     let id = mem::replace(i, ast::Id::new_unchecked(""));
                     head = Some(Expr {
-                        expr: construct_expr_attr(expr, id.to_smolstr(), self.loc.clone()),
+                        expr: construct_expr_attr(expr, id.into_smolstr(), self.loc.clone()),
                         loc: self.loc.clone(),
                     });
                     tail = rest;
@@ -1802,7 +1822,7 @@ impl Node<Option<cst::Member>> {
                         }
                     };
                     head = maybe_expr.map(|e| Expr {
-                        expr: construct_expr_attr(e, id.to_smolstr(), self.loc.clone()),
+                        expr: construct_expr_attr(e, id.into_smolstr(), self.loc.clone()),
                         loc: self.loc.clone(),
                     });
                     tail = rest;
@@ -2152,7 +2172,7 @@ impl ast::Name {
             ));
             None
         } else {
-            Some(self.id.to_smolstr())
+            Some(self.id.into_smolstr())
         }
     }
 
@@ -2287,7 +2307,7 @@ impl Node<Option<cst::RecInit>> {
 #[allow(clippy::too_many_arguments)]
 fn construct_template_policy(
     id: ast::PolicyID,
-    annotations: BTreeMap<ast::Id, SmolStr>,
+    annotations: BTreeMap<ast::AnyId, SmolStr>,
     effect: ast::Effect,
     principal: ast::PrincipalConstraint,
     action: ast::ActionConstraint,
@@ -2319,9 +2339,6 @@ fn construct_template_policy(
         construct_template(construct_expr_bool(true, loc.clone()))
     }
 }
-fn construct_id(s: String) -> ast::Id {
-    ast::Id::new_unchecked(s)
-}
 fn construct_string_from_var(v: ast::Var) -> SmolStr {
     match v {
         ast::Var::Principal => "principal".into(),
@@ -2854,7 +2871,7 @@ mod tests {
         .to_policy(ast::PolicyID::from_string("id"), &mut errs)
         .expect("should be valid");
         assert_eq!(
-            policy.annotation(&ast::Id::new_unchecked("anno")),
+            policy.annotation(&ast::AnyId::new_unchecked("anno")),
             Some(&"good annotation".into())
         );
 
@@ -2896,42 +2913,42 @@ mod tests {
             policyset
                 .get(&ast::PolicyID::from_string("policy0"))
                 .expect("should be a policy")
-                .annotation(&ast::Id::new_unchecked("anno0")),
+                .annotation(&ast::AnyId::new_unchecked("anno0")),
             None
         );
         assert_eq!(
             policyset
                 .get(&ast::PolicyID::from_string("policy0"))
                 .expect("should be a policy")
-                .annotation(&ast::Id::new_unchecked("anno1")),
+                .annotation(&ast::AnyId::new_unchecked("anno1")),
             Some(&"first".into())
         );
         assert_eq!(
             policyset
                 .get(&ast::PolicyID::from_string("policy1"))
                 .expect("should be a policy")
-                .annotation(&ast::Id::new_unchecked("anno2")),
+                .annotation(&ast::AnyId::new_unchecked("anno2")),
             Some(&"second".into())
         );
         assert_eq!(
             policyset
                 .get(&ast::PolicyID::from_string("policy2"))
                 .expect("should be a policy")
-                .annotation(&ast::Id::new_unchecked("anno3a")),
+                .annotation(&ast::AnyId::new_unchecked("anno3a")),
             Some(&"third-a".into())
         );
         assert_eq!(
             policyset
                 .get(&ast::PolicyID::from_string("policy2"))
                 .expect("should be a policy")
-                .annotation(&ast::Id::new_unchecked("anno3b")),
+                .annotation(&ast::AnyId::new_unchecked("anno3b")),
             Some(&"third-b".into())
         );
         assert_eq!(
             policyset
                 .get(&ast::PolicyID::from_string("policy2"))
                 .expect("should be a policy")
-                .annotation(&ast::Id::new_unchecked("anno3c")),
+                .annotation(&ast::AnyId::new_unchecked("anno3c")),
             None
         );
         assert_eq!(
@@ -2942,6 +2959,89 @@ mod tests {
                 .count(),
             2
         );
+
+        // can't have spaces or '+' in annotation keys
+        assert_matches!(
+            text_to_cst::parse_policy(
+                r#"
+            @hi mom("this should be invalid")
+            permit(principal, action, resource);
+            "#,
+            ),
+            Err(_)
+        );
+        assert_matches!(
+            text_to_cst::parse_policy(
+                r#"
+            @hi+mom("this should be invalid")
+            permit(principal, action, resource);
+            "#,
+            ),
+            Err(_)
+        );
+
+        // can have Cedar reserved words as annotation keys
+        let mut errs = ParseErrors::new();
+        let policyset = text_to_cst::parse_policies(
+            r#"
+            @if("this is the annotation for `if`")
+            @then("this is the annotation for `then`")
+            @else("this is the annotation for `else`")
+            @true("this is the annotation for `true`")
+            @false("this is the annotation for `false`")
+            @in("this is the annotation for `in`")
+            @is("this is the annotation for `is`")
+            @like("this is the annotation for `like`")
+            @has("this is the annotation for `has`")
+            @principal("this is the annotation for `principal`") // not reserved at time of this writing, but we test it anyway
+            permit(principal, action, resource);
+            "#,
+        ).expect("should parse")
+        .to_policyset(&mut errs)
+        .expect("should be valid");
+        let policy0 = policyset
+            .get(&ast::PolicyID::from_string("policy0"))
+            .expect("should be the right policy ID");
+        assert_eq!(
+            policy0.annotation(&ast::AnyId::new_unchecked("if")),
+            Some(&"this is the annotation for `if`".into())
+        );
+        assert_eq!(
+            policy0.annotation(&ast::AnyId::new_unchecked("then")),
+            Some(&"this is the annotation for `then`".into())
+        );
+        assert_eq!(
+            policy0.annotation(&ast::AnyId::new_unchecked("else")),
+            Some(&"this is the annotation for `else`".into())
+        );
+        assert_eq!(
+            policy0.annotation(&ast::AnyId::new_unchecked("true")),
+            Some(&"this is the annotation for `true`".into())
+        );
+        assert_eq!(
+            policy0.annotation(&ast::AnyId::new_unchecked("false")),
+            Some(&"this is the annotation for `false`".into())
+        );
+        assert_eq!(
+            policy0.annotation(&ast::AnyId::new_unchecked("in")),
+            Some(&"this is the annotation for `in`".into())
+        );
+        assert_eq!(
+            policy0.annotation(&ast::AnyId::new_unchecked("is")),
+            Some(&"this is the annotation for `is`".into())
+        );
+        assert_eq!(
+            policy0.annotation(&ast::AnyId::new_unchecked("like")),
+            Some(&"this is the annotation for `like`".into())
+        );
+        assert_eq!(
+            policy0.annotation(&ast::AnyId::new_unchecked("has")),
+            Some(&"this is the annotation for `has`".into())
+        );
+        assert_eq!(
+            policy0.annotation(&ast::AnyId::new_unchecked("principal")),
+            Some(&"this is the annotation for `principal`".into())
+        );
     }
 
     #[test]
diff --git a/cedar-policy/CHANGELOG.md b/cedar-policy/CHANGELOG.md
index 52b06b95c..1f520d540 100644
--- a/cedar-policy/CHANGELOG.md
+++ b/cedar-policy/CHANGELOG.md
@@ -31,6 +31,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   For more details, see `miette`'s
   [documentation](https://docs.rs/miette/latest/miette/index.html). (#477)
 - Moved `<PolicyId as FromStr>::Err` to `Infallible` (#588, resolving #551)
+- Cedar reserved words like `if`, `has`, and `true` are now allowed as policy
+  annotation keys. (#634, resolving #623)
 - Add hints suggesting how to fix some type errors. (#513)
 - The `ValidationResult` returned from `Validator::validate` now has a static
   lifetime, allowing it to be used in more contexts. The lifetime parameter