@@ -15,7 +15,7 @@ from typing import Annotated, Literal
 import dspy
 from dspy.experimental import Choice, Decide, Noul, Score, TypeSafe
 
-Severity = Score[(0, "Minor"), (2, "Disruptive"), (10, "Blocking")]
+Severity = Score["Minor", "Disruptive", "Blocking"]
 Category = Choice[("billing", "Payment issue"), ("technical", "Product malfunction")]
 
 class Assess(dspy.Signature):
@@ -42,8 +42,9 @@ and Jev to obtain probability evidence, then decodes it locally.
 ## Native and rich types
 
 Native outputs return only the value. Bare `float` works with Predict but needs
-a Score rubric for Decide. Score anchors must be finite and strictly increasing;
-Decide supports 2–10 levels. Choice preserves string, integer, Boolean, and None
+a Score rubric for Decide. Declare Score descriptions in increasing level order;
+the value ranges from 0 to N−1, and Decide supports 2–10 levels.
+Choice preserves string, integer, Boolean, and None
 member types; colliding string labels such as `1` and `"1"` are rejected.
 Bracket configuration is a runtime convention, not a standard static generic.
 
@@ -63,8 +64,8 @@ messages. Predict's adapter adds the field markers; Decide nests values under
 | --- | --- | --- |
 | `bool` | `True` | `true` |
 | `Noul` | `{"value": true, "confidence": 0.6}` | Same JSON object |
-| `Annotated[float, Severity]` | `6.6` | `6.6` |
-| `Severity` | `{"value": 6.6, "confidence": 0.61}` | Same JSON object |
+| `Annotated[float, Severity]` | `1.5` | `1.5` |
+| `Severity` | `{"value": 1.5, "confidence": 0.61}` | Same JSON object |
 | `Literal["billing", "technical"]` | `technical` | `"technical"` |
 | `Category` | `{"value": "technical", "confidence": 0.73}` | Same JSON object |
 
@@ -75,13 +76,13 @@ present. Use `.value` explicitly when passing a rich result to a native input.
 
 Predict uses the annotation's schema to parse the generated value. Decide maps
 native and rich forms to the same Jev primitive, then returns either the decoded
-native value or a rich object. Numeric anchors stay local; descriptions go to Jev.
+native value or a rich object. Ordered Score descriptions go to Jev as criteria.
 
 | Annotation | Predict requests → returns | Decide question → returns |
 | --- | --- | --- |
 | `bool` | Boolean → `bool` | `type: "noul"` → thresholded `bool` |
 | `Noul` | JSON `{value: bool, confidence: number}` → `Noul` | Same noul question → `Noul` with derived value/confidence and raw probability |
-| `Annotated[float, Severity]` | Number in `[0, 10]`, with rubric → `float` | `type: "score"`, criteria `["Minor", "Disruptive", "Blocking"]` → expected anchor value as `float` |
+| `Annotated[float, Severity]` | Number in `[0, 2]`, with rubric → `float` | `type: "score"`, criteria `["Minor", "Disruptive", "Blocking"]` → expected level index as `float` |
 | `Severity` | JSON `{value: number, confidence: number}`, same range/rubric → `Severity` | Same score question → `Severity` with value, provider confidence, probabilities, and cut-selected level |
 | `Literal["billing", "technical"]` | One allowed member → native member | `type: "choice"`, criteria `{"billing": null, "technical": null}` → native member |
 | `Category` | JSON `{value: allowed member, confidence: number}`, with option descriptions → `Category` | Choice criteria `{"billing": "Payment issue", "technical": "Product malfunction"}` → `Category` with value, provider confidence, probabilities |
@@ -116,10 +117,11 @@ inference or save/load. No Jev-specific `OutputField` arguments are added.
 | Score `cuts` | `[0.5, 1.5, …]` | Select `.level` from mean level index; N−1 increasing boundaries inside `(0, N−1)` |
 | Choice `weights` | All `1.0` | Nonnegative, finite probability multipliers keyed by string labels; omitted options default to `1.0` |
 
-**Score has no tunable weights.** Its continuous value is
-`sum(p[i] * anchors[i]) / sum(p)`. Its zero-based `.level` counts the cuts less than
-or equal to `sum(i * p[i]) / sum(p)`. Equality selects the higher level; cuts do
+**Score has no anchors or weights.** Its continuous `.value` is
+`sum(i * p[i]) / sum(p)`, the mean level index. Its zero-based `.level` counts the
+cuts less than or equal to that value. Equality selects the higher level; cuts do
 not change `.value`. Native float outputs expose only the continuous value.
+For probabilities `[0.1, 0.3, 0.6]`, `.value` is `1.5`; cuts `[0.5, 1.6]` select `.level = 1`.
 
 Choice selects by `probability[label] * weight[label]`; raw probabilities are
 unchanged. All-unit weights retain the provider choice. Weighted ties prefer the
@@ -139,12 +141,12 @@ evidence without changing shared types or previous results.
 | Validated runtime inputs | JSON under `state.inputs`; explicit paths use `inputs.ticket` |
 | Each output name and type | `questions[name]` with `type: "noul"`, `"score"`, or `"choice"` |
 | Field description / module override | `questions[name].instructions` |
-| Type rubric/options / module override | `questions[name].criteria`; numeric anchors remain local |
+| Type rubric/options / module override | `questions[name].criteria` |
 
 Overrides apply only to Decide; Predict continues to render the signature and type
 descriptions. Per-call `signature=` may change instructions/descriptions or switch
 between equivalent native/rich types, but must preserve output names and answer
-spaces. Use a new Decide for different options or anchors.
+spaces. Use a new Decide for different options or ordered levels.
 
 ## Confidence depends on its source
 
@@ -179,7 +181,7 @@ restored.load("assess.json")
 | `client` | Explicit TypeSafe model, endpoint, cache setting, timeout; otherwise null |
 | `metadata` | DSPy's dependency versions |
 
-State-only JSON excludes signature architecture/types/anchors, inputs, results,
+State-only JSON excludes signature architecture/types/declared levels, inputs, results,
 history, and API keys. Credentials come from the environment. Loading invalid
 configuration leaves the module unchanged; earlier unreleased PR formats are not
 migrated. Saved endpoints require `allow_unsafe_lm_state=True` for trusted files.
 
@@ -1,8 +1,6 @@
 """Decision values shared by System One predictors and generative LMs."""
 
-import itertools
 import json
-import math
 from functools import lru_cache
 from typing import Annotated, ClassVar, Literal, get_args, get_origin
 
@@ -53,9 +51,9 @@ def __bool__(self):
 class Score(_Decision):
     """A continuous score with a declared rubric and confidence.
 
-    Declare ``Score[(0, "poor"), (2, "fair"), (10, "excellent")]``. Anchors must
-    be finite and strictly increasing. Predict generates value and confidence;
-    Decide averages the fixed declared anchors using provider probabilities.
+    Declare ``Score["poor", "fair", "excellent"]`` in increasing order.
+    Predict generates a continuous value from 0 to N-1 and confidence;
+    Decide averages the level indices using provider probabilities.
     ``probabilities`` retains the raw distribution, keyed by rubric index.
     ``level`` is the zero-based ordinal selected by Decide's cuts on the mean
     level index. It does not change the continuous value or provider confidence.
@@ -72,27 +70,24 @@ class Score(_Decision):
 
     @classmethod
     def __class_getitem__(cls, options):
-        options = _option_pairs(options)
-        anchors = [value for value, _ in options]
-        if (
-            len(anchors) < 2
-            or any(type(v) not in (int, float) or not math.isfinite(v) for v in anchors)
-            or any(a >= b for a, b in itertools.pairwise(anchors))
-        ):
-            raise ValueError("Score requires at least two finite, strictly increasing numeric anchors.")
+        if not isinstance(options, tuple) or len(options) < 2 or any(not isinstance(v, str) for v in options):
+            raise ValueError("Score requires at least two ordered level descriptions, e.g. Score['poor', 'excellent'].")
         return _score_type(options)
 
     @classmethod
     def description(cls):
-        return "Continuous score; intermediate values are allowed. Rubric: " + json.dumps(cls.options) + "."
+        return (
+            f"Continuous score from 0 to {len(cls.options) - 1}; intermediate values are allowed. "
+            "Rubric (level index, description): " + json.dumps(list(enumerate(cls.options))) + "."
+        )
 
     @classmethod
     def __get_pydantic_core_schema__(cls, source, handler):
         if source is float:
             # Pydantic calls this hook when this configured type is Annotated metadata.
             if not cls.options:
                 raise ValueError("A native Score requires a configured rubric.")
-            return core_schema.float_schema(ge=cls.options[0][0], le=cls.options[-1][0], allow_inf_nan=False)
+            return core_schema.float_schema(ge=0, le=len(cls.options) - 1, allow_inf_nan=False)
         return handler(source)
 
     @classmethod
@@ -152,9 +147,9 @@ def _option_pairs(options):
 @lru_cache(maxsize=256)
 def _score_type(options):
     result = create_model(
-        f"Score[{', '.join(repr(pair) for pair in options)}]",
+        f"Score[{', '.join(repr(description) for description in options)}]",
         __base__=Score,
-        value=(float, Field(ge=options[0][0], le=options[-1][0], allow_inf_nan=False)),
+        value=(float, Field(ge=0, le=len(options) - 1, allow_inf_nan=False)),
     )
     result.options = options
     return result
 
@@ -24,14 +24,14 @@
 class Decide(Module, Parameter):
     """Answer a signature's closed-set outputs in one System One request.
 
-    Declare outputs using Noul, Score[(number, description), ...], and
+    Declare outputs using Noul, Score["low", "medium", "high"], and
     Choice[(value, description), ...]. Native bool, Literal, and
     Annotated[float, Score[...]] return only the value. Bare float has no rubric.
     Unsupported outputs raise; Decide never falls back to a generative LM.
 
     Each instance owns ``fields[name]`` configuration: a Boolean ``threshold``
     (initially 0.5), or ``cuts`` for Score level selection, halfway between level
-    indices. Score values use the fixed declared anchors; cuts affect only .level.
+    indices. Score values average those indices; cuts affect only .level.
     Choice weights are nonnegative probability multipliers keyed by string
     option labels, initially 1.0. Missing option weights also default to 1.0.
     Weighted Choice selection preserves raw probabilities and provider confidence;
@@ -165,7 +165,7 @@ def _questions(self, signature, types):
             if kind is Noul:
                 question["type"] = "noul"
             elif issubclass(kind, Score):
-                question.update(type="score", criteria=[desc for _, desc in kind.options])
+                question.update(type="score", criteria=list(kind.options))
             else:
                 question.update(type="choice", criteria={str(v): desc or None for v, desc in kind.options})
             if "criteria" in config:
@@ -228,16 +228,14 @@ def _decode(self, answers, signature, types, inputs, trace):
                 )
             elif issubclass(kind, Score):
                 probabilities = answer["probabilities"]
-                anchors = [v for v, _ in kind.options]
-                if set(probabilities) != set(range(len(anchors))) or sum(probabilities.values()) <= 0:
+                if set(probabilities) != set(range(len(kind.options))) or sum(probabilities.values()) <= 0:
                     raise ValueError(f"Invalid Score distribution for {name!r}.")
-                value = sum(anchors[i] * p for i, p in probabilities.items()) / sum(probabilities.values())
-                position = sum(i * p for i, p in probabilities.items()) / sum(probabilities.values())
+                value = sum(i * p for i, p in probabilities.items()) / sum(probabilities.values())
                 result = kind(
                     value=value,
                     confidence=answer["confidence"],
                     probabilities=probabilities,
-                    level=sum(position >= cut for cut in self.fields[name]["cuts"]),
+                    level=sum(value >= cut for cut in self.fields[name]["cuts"]),
                 )
             else:
                 options = {str(v): v for v, _ in kind.options}
 
@@ -10,7 +10,7 @@
 from dspy.utils.dummies import DummyLM
 from tests.predict.test_decide import FakeClient
 
-Severity = Score[(0, "Minor"), (2, "Disruptive"), (10, "Blocking")]
+Severity = Score["Minor", "Disruptive", "Blocking"]
 Category = Choice[("billing", "Payment issue"), ("technical", "Product malfunction")]
 
 
@@ -45,11 +45,11 @@ def decision_signature(rich, direction):
 
 def decision_values(rich, evidence=False):
     if not rich:
-        return {"urgent": True, "severity": 6.6, "category": "technical"}
+        return {"urgent": True, "severity": 1.5, "category": "technical"}
     return {
         "urgent": Noul(value=True, confidence=0.6, **({"probability": 0.8} if evidence else {})),
         "severity": Severity(
-            value=6.6, confidence=0.61, **({"probabilities": {0: 0.1, 1: 0.3, 2: 0.6}} if evidence else {})
+            value=1.5, confidence=0.61, **({"probabilities": {0: 0.1, 1: 0.3, 2: 0.6}} if evidence else {})
         ),
         "category": Category(
             value="technical",
@@ -83,7 +83,7 @@ def test_predict_outputs_and_generated_schema(adapter, rich):
     else:
         assert "confidence" not in json.dumps(schema)
         assert schema["properties"]["severity"]["minimum"] == 0
-        assert schema["properties"]["severity"]["maximum"] == 10
+        assert schema["properties"]["severity"]["maximum"] == 2
         assert schema["properties"]["category"]["enum"] == ["billing", "technical"]
 
 
@@ -102,7 +102,7 @@ def test_inputs_to_both_modules_preserve_values_and_context(rich, evidence):
         prompt = messages[-1]["content"]
         assert ('"confidence"' in prompt) is rich
         assert ('"probabilities"' in prompt) is (rich and evidence)
-        assert "6.6" in prompt
+        assert "1.5" in prompt
         assert "technical" in prompt
     client = FakeClient()
     module = Decide(signature, client=client)
@@ -117,10 +117,11 @@ def test_inputs_to_both_modules_preserve_values_and_context(rich, evidence):
 
 @pytest.mark.parametrize("rich", [False, True])
 @pytest.mark.parametrize("adapter", [dspy.ChatAdapter(), dspy.JSONAdapter()])
-def test_score_range_is_enforced_for_native_and_rich(adapter, rich):
+@pytest.mark.parametrize("invalid", [-0.1, 2.1])
+def test_score_range_is_enforced_for_native_and_rich(adapter, rich, invalid):
     sig = decision_signature(rich, "output")
     values = decision_values(False)
-    values["severity"] = 11
+    values["severity"] = invalid
     if rich:
         values = {name: {"value": value, "confidence": 0.7} for name, value in values.items()}
     completion = adapter.format_assistant_message_content(sig, values)
@@ -131,10 +132,10 @@ def test_score_range_is_enforced_for_native_and_rich(adapter, rich):
 @pytest.mark.parametrize(
     "kind,options",
     [
-        (Score, ((2, "a"), (1, "b"))),
-        (Score, ((1, "a"), (1, "b"))),
-        (Score, ((0, "a"), (float("nan"), "b"))),
-        (Score, ((0, "a"),)),
+        (Score, ((0, "a"), (1, "b"))),  # Removed anchor syntax.
+        (Score, ("a", 1)),
+        (Score, ("a",)),
+        (Score, "a"),
         (Choice, ((1, "a"), ("1", "b"))),
         (Choice, (([], "bad"),)),
     ],
@@ -144,6 +145,24 @@ def test_invalid_options(kind, options):
         kind[options]
 
 
+@pytest.mark.parametrize("levels,maximum", [(("Low", "High"), 1), (("Last", "Second", "Third", "First"), 3)])
+def test_score_level_order_bounds_and_fractional_values(levels, maximum):
+    score = Score[levels]
+    assert score.options == levels
+    assert json.dumps(list(enumerate(levels))) in score.description()
+    for rich in (False, True):
+        adapter = TypeAdapter(score if rich else Annotated[float, score])
+        schema = adapter.json_schema()
+        value_schema = schema["properties"]["value"] if rich else schema
+        assert value_schema["minimum"] == 0
+        assert value_schema["maximum"] == maximum
+        for value in (0, 0.25, maximum):
+            result = adapter.validate_python({"value": value, "confidence": 0.7} if rich else value)
+            assert (result.value if rich else result) == value
+        with pytest.raises(ValidationError):
+            adapter.validate_python({"value": maximum + 0.1, "confidence": 0.7} if rich else maximum + 0.1)
+
+
 def test_choice_type_cache_preserves_bool_vs_int():
     boolean = Choice[(True, "yes"), (False, "no")]
     integer = Choice[(1, "yes"), (0, "no")]
@@ -152,7 +171,7 @@ def test_choice_type_cache_preserves_bool_vs_int():
     assert type(boolean(value=True, confidence=0.5).value) is bool
 
 
-@pytest.mark.parametrize("kind,value", [(Noul, True), (Severity, 4.2), (Category, "technical")])
+@pytest.mark.parametrize("kind,value", [(Noul, True), (Severity, 1.2), (Category, "technical")])
 def test_rich_confidence_required_and_serialization(kind, value):
     with pytest.raises(ValidationError):
         kind(value=value)
 
@@ -62,7 +62,7 @@ def test_real_sdk_request_cache_usage_and_local_parameters(transport):
     assert second.flag.value is False
     assert first.flag.confidence == pytest.approx(0.6)
     assert second.flag.confidence == pytest.approx(1 / 9)
-    assert first.rating.value == pytest.approx(6.7)
+    assert first.rating.value == pytest.approx(1.5)
     assert second.rating.value == first.rating.value
     assert first.rating.level == 2
     assert second.rating.level == 1
@@ -99,7 +99,7 @@ async def test_async_sdk_and_shared_cache(transport):
     module.fields["label"]["weights"] = {"2": 0.1}
     assert (await module.acall(text="x")).label == "other"
     assert len(transport) == 1
-    assert synchronous.rating == pytest.approx(6.7)
+    assert synchronous.rating == pytest.approx(1.5)
 
 
 def test_cache_identity_and_controls(transport):