diff --git a/.changeset/lucky-seas-tickle.md b/.changeset/lucky-seas-tickle.md
new file mode 100644
index 0000000000..01c3ec8bf7
--- /dev/null
+++ b/.changeset/lucky-seas-tickle.md
@@ -0,0 +1,6 @@
+---
+"@khanacademy/perseus": patch
+"@khanacademy/perseus-editor": patch
+---
+
+Remove the locked-[figureName]-labels flags
diff --git a/packages/perseus-editor/src/__stories__/flags-for-api-options.ts b/packages/perseus-editor/src/__stories__/flags-for-api-options.ts
index a6b5dcbd39..915c147365 100644
--- a/packages/perseus-editor/src/__stories__/flags-for-api-options.ts
+++ b/packages/perseus-editor/src/__stories__/flags-for-api-options.ts
@@ -15,14 +15,6 @@ export const flags = {
         point: true,
         "unlimited-point": true,
         none: true,
-
-        // Locked figures flags
-        "locked-point-labels": true,
-        "locked-line-labels": true,
-        "locked-vector-labels": true,
-        "locked-ellipse-labels": true,
-        "locked-polygon-labels": true,
-        "locked-function-labels": true,
     },
 } satisfies APIOptions["flags"];
 
diff --git a/packages/perseus-editor/src/__stories__/interactive-graph-editor.stories.tsx b/packages/perseus-editor/src/__stories__/interactive-graph-editor.stories.tsx
index 6c7d4f2ea4..27af40c769 100644
--- a/packages/perseus-editor/src/__stories__/interactive-graph-editor.stories.tsx
+++ b/packages/perseus-editor/src/__stories__/interactive-graph-editor.stories.tsx
@@ -153,163 +153,7 @@ export const InteractiveGraphNone = (): React.ReactElement => {
     );
 };
 
-export const MafsWithLockedFiguresCurrent = (): React.ReactElement => {
-    return (
-        <EditorPageWithStorybookPreview
-            apiOptions={{
-                isMobile: false,
-                flags: {
-                    mafs: {
-                        ...flags.mafs,
-                        "locked-point-labels": false,
-                        "locked-line-labels": false,
-                        "locked-vector-labels": false,
-                        "locked-ellipse-labels": false,
-                        "locked-polygon-labels": false,
-                        "locked-function-labels": false,
-                    },
-                },
-            }}
-            question={segmentWithLockedFigures}
-        />
-    );
-};
-
-MafsWithLockedFiguresCurrent.parameters = {
-    chromatic: {
-        // Disabling because this isn't visually testing anything on the
-        // initial load of the editor page.
-        disableSnapshot: true,
-    },
-};
-
-export const MafsWithLockedPointLabelsFlag = (): React.ReactElement => {
-    return (
-        <EditorPageWithStorybookPreview
-            apiOptions={{
-                flags: {
-                    mafs: {
-                        ...flags.mafs,
-                        "locked-point-labels": true,
-                        "locked-line-labels": false,
-                        "locked-vector-labels": false,
-                        "locked-ellipse-labels": false,
-                        "locked-polygon-labels": false,
-                        "locked-function-labels": false,
-                    },
-                },
-            }}
-            question={segmentWithLockedFigures}
-        />
-    );
-};
-
-export const MafsWithLockedLineLabelsFlag = (): React.ReactElement => {
-    return (
-        <EditorPageWithStorybookPreview
-            apiOptions={{
-                flags: {
-                    mafs: {
-                        ...flags.mafs,
-                        "locked-point-labels": false,
-                        "locked-line-labels": true,
-                        "locked-vector-labels": false,
-                        "locked-ellipse-labels": false,
-                        "locked-polygon-labels": false,
-                        "locked-function-labels": false,
-                    },
-                },
-            }}
-            question={segmentWithLockedFigures}
-        />
-    );
-};
-
-export const MafsWithLockedVectorLabelsFlag = (): React.ReactElement => {
-    return (
-        <EditorPageWithStorybookPreview
-            apiOptions={{
-                flags: {
-                    mafs: {
-                        ...flags.mafs,
-                        "locked-point-labels": false,
-                        "locked-line-labels": false,
-                        "locked-vector-labels": true,
-                        "locked-ellipse-labels": false,
-                        "locked-polygon-labels": false,
-                        "locked-function-labels": false,
-                    },
-                },
-            }}
-            question={segmentWithLockedFigures}
-        />
-    );
-};
-
-export const MafsWithLockedEllipseLabelsFlag = (): React.ReactElement => {
-    return (
-        <EditorPageWithStorybookPreview
-            apiOptions={{
-                flags: {
-                    mafs: {
-                        ...flags.mafs,
-                        "locked-point-labels": false,
-                        "locked-line-labels": false,
-                        "locked-vector-labels": false,
-                        "locked-ellipse-labels": true,
-                        "locked-polygon-labels": false,
-                        "locked-function-labels": false,
-                    },
-                },
-            }}
-            question={segmentWithLockedFigures}
-        />
-    );
-};
-
-export const MafsWithLockedPolygonLabelsFlag = (): React.ReactElement => {
-    return (
-        <EditorPageWithStorybookPreview
-            apiOptions={{
-                flags: {
-                    mafs: {
-                        ...flags.mafs,
-                        "locked-point-labels": false,
-                        "locked-line-labels": false,
-                        "locked-vector-labels": false,
-                        "locked-ellipse-labels": false,
-                        "locked-polygon-labels": true,
-                        "locked-function-labels": false,
-                    },
-                },
-            }}
-            question={segmentWithLockedFigures}
-        />
-    );
-};
-
-export const MafsWithLockedFunctionLabelsFlag = (): React.ReactElement => {
-    return (
-        <EditorPageWithStorybookPreview
-            apiOptions={{
-                flags: {
-                    mafs: {
-                        ...flags.mafs,
-                        "locked-point-labels": false,
-                        "locked-line-labels": false,
-                        "locked-vector-labels": false,
-                        "locked-ellipse-labels": false,
-                        "locked-polygon-labels": false,
-                        "locked-function-labels": true,
-                    },
-                },
-            }}
-            question={segmentWithLockedFigures}
-        />
-    );
-};
-
-export const MafsWithLockedFigureLabelsAllFlags = (): React.ReactElement => {
+export const MafsWithLockedFigures = (): React.ReactElement => {
     return (
         <EditorPageWithStorybookPreview question={segmentWithLockedFigures} />
     );
diff --git a/packages/perseus-editor/src/widgets/interactive-graph-editor/interactive-graph-editor.tsx b/packages/perseus-editor/src/widgets/interactive-graph-editor/interactive-graph-editor.tsx
index 26d517627f..bd763c9530 100644
--- a/packages/perseus-editor/src/widgets/interactive-graph-editor/interactive-graph-editor.tsx
+++ b/packages/perseus-editor/src/widgets/interactive-graph-editor/interactive-graph-editor.tsx
@@ -852,7 +852,6 @@ class InteractiveGraphEditor extends React.Component<Props> {
                             this.props.graph.type
                         ] && (
                             <LockedFiguresSection
-                                flags={this.props.apiOptions.flags}
                                 figures={this.props.lockedFigures}
                                 onChange={this.props.onChange}
                             />
diff --git a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-ellipse-settings.test.tsx b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-ellipse-settings.test.tsx
index 5f20a34d33..665b8943d6 100644
--- a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-ellipse-settings.test.tsx
+++ b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-ellipse-settings.test.tsx
@@ -14,13 +14,7 @@ import {
 import type {UserEvent} from "@testing-library/user-event";
 
 const defaultProps = {
-    flags: {
-        ...flags,
-        mafs: {
-            ...flags.mafs,
-            "locked-ellipse-settings": true,
-        },
-    },
+    flags: flags,
     ...getDefaultFigureForType("ellipse"),
     onChangeProps: () => {},
     onMove: () => {},
diff --git a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-ellipse-settings.tsx b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-ellipse-settings.tsx
index 79213f1048..9b4b1eda27 100644
--- a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-ellipse-settings.tsx
+++ b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-ellipse-settings.tsx
@@ -47,7 +47,6 @@ export type Props = LockedFigureSettingsCommonProps &
 
 const LockedEllipseSettings = (props: Props) => {
     const {
-        flags,
         center,
         radius,
         angle,
@@ -256,55 +255,48 @@ const LockedEllipseSettings = (props: Props) => {
             />
 
             {/* Visible Labels */}
-            {flags?.["mafs"]?.["locked-ellipse-labels"] && (
-                <>
-                    <Strut size={spacing.xxxSmall_4} />
-                    <View style={styles.horizontalRule} />
-                    <Strut size={spacing.small_12} />
-
-                    <LabelMedium>Visible labels</LabelMedium>
-
-                    {labels?.map((label, labelIndex) => (
-                        <LockedLabelSettings
-                            {...label}
-                            key={labelIndex}
-                            expanded={true}
-                            onChangeProps={(newLabel) => {
-                                handleLabelChange(newLabel, labelIndex);
-                            }}
-                            onRemove={() => {
-                                handleLabelRemove(labelIndex);
-                            }}
-                            containerStyle={styles.labelContainer}
-                        />
-                    ))}
-
-                    <Button
-                        kind="tertiary"
-                        startIcon={plusCircle}
-                        onClick={() => {
-                            const newLabel = {
-                                ...getDefaultFigureForType("label"),
-                                coord: [
-                                    center[0],
-                                    // Additional vertical offset for each
-                                    // label so they don't overlap.
-                                    center[1] - (labels?.length ?? 0),
-                                ],
-                                // Default to the same color as the ellipse
-                                color: color,
-                            } satisfies LockedLabelType;
-
-                            onChangeProps({
-                                labels: [...(labels ?? []), newLabel],
-                            });
-                        }}
-                        style={styles.addButton}
-                    >
-                        Add visible label
-                    </Button>
-                </>
-            )}
+            <Strut size={spacing.xxxSmall_4} />
+            <View style={styles.horizontalRule} />
+            <Strut size={spacing.small_12} />
+            <LabelMedium>Visible labels</LabelMedium>
+            {labels?.map((label, labelIndex) => (
+                <LockedLabelSettings
+                    {...label}
+                    key={labelIndex}
+                    expanded={true}
+                    onChangeProps={(newLabel) => {
+                        handleLabelChange(newLabel, labelIndex);
+                    }}
+                    onRemove={() => {
+                        handleLabelRemove(labelIndex);
+                    }}
+                    containerStyle={styles.labelContainer}
+                />
+            ))}
+            <Button
+                kind="tertiary"
+                startIcon={plusCircle}
+                onClick={() => {
+                    const newLabel = {
+                        ...getDefaultFigureForType("label"),
+                        coord: [
+                            center[0],
+                            // Additional vertical offset for each
+                            // label so they don't overlap.
+                            center[1] - (labels?.length ?? 0),
+                        ],
+                        // Default to the same color as the ellipse
+                        color: color,
+                    } satisfies LockedLabelType;
+
+                    onChangeProps({
+                        labels: [...(labels ?? []), newLabel],
+                    });
+                }}
+                style={styles.addButton}
+            >
+                Add visible label
+            </Button>
 
             {/* Actions */}
             <LockedFigureSettingsActions
diff --git a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-figure-settings.tsx b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-figure-settings.tsx
index 0d18961dac..7a66ab0ecc 100644
--- a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-figure-settings.tsx
+++ b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-figure-settings.tsx
@@ -24,11 +24,8 @@ import type {Props as LockedLineProps} from "./locked-line-settings";
 import type {Props as LockedPointProps} from "./locked-point-settings";
 import type {Props as LockedPolygonProps} from "./locked-polygon-settings";
 import type {Props as LockedVectorProps} from "./locked-vector-settings";
-import type {APIOptions} from "@khanacademy/perseus";
 
 export type LockedFigureSettingsCommonProps = {
-    flags?: APIOptions["flags"];
-
     // Movement props
     /**
      * Called when a movement button (top, up, down, bottom) is pressed.
diff --git a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-figures-section.tsx b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-figures-section.tsx
index a380c250fb..463eda5609 100644
--- a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-figures-section.tsx
+++ b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-figures-section.tsx
@@ -19,14 +19,9 @@ import {getDefaultFigureForType} from "./util";
 
 import type {LockedFigureSettingsMovementType} from "./locked-figure-settings-actions";
 import type {Props as InteractiveGraphEditorProps} from "../interactive-graph-editor";
-import type {
-    APIOptions,
-    LockedFigure,
-    LockedFigureType,
-} from "@khanacademy/perseus";
+import type {LockedFigure, LockedFigureType} from "@khanacademy/perseus";
 
 type Props = {
-    flags?: APIOptions["flags"];
     figures?: Array<LockedFigure>;
     onChange: (props: Partial<InteractiveGraphEditorProps>) => void;
 };
@@ -165,7 +160,6 @@ const LockedFiguresSection = (props: Props) => {
                         return (
                             <LockedFigureSettings
                                 key={`${uniqueId}-locked-${figure}-${index}`}
-                                flags={props.flags}
                                 expanded={expandedStates[index]}
                                 onToggle={(newValue) => {
                                     const newExpanded = [...expandedStates];
diff --git a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-function-settings.tsx b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-function-settings.tsx
index 984891ad3b..5bc77571ba 100644
--- a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-function-settings.tsx
+++ b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-function-settings.tsx
@@ -52,7 +52,6 @@ export type Props = LockedFunctionType &
 
 const LockedFunctionSettings = (props: Props) => {
     const {
-        flags,
         color: lineColor,
         strokeStyle,
         equation,
@@ -337,52 +336,45 @@ const LockedFunctionSettings = (props: Props) => {
             />
 
             {/* Visible Labels */}
-            {flags?.["mafs"]?.["locked-function-labels"] && (
-                <>
-                    <Strut size={spacing.xxxSmall_4} />
-                    <View style={styles.horizontalRule} />
-                    <Strut size={spacing.small_12} />
-
-                    <LabelMedium>Visible labels</LabelMedium>
-
-                    {labels?.map((label, labelIndex) => (
-                        <LockedLabelSettings
-                            key={labelIndex}
-                            {...label}
-                            expanded={true}
-                            onChangeProps={(newLabel) => {
-                                handleLabelChange(newLabel, labelIndex);
-                            }}
-                            onRemove={() => {
-                                handleLabelRemove(labelIndex);
-                            }}
-                            containerStyle={styles.labelContainer}
-                        />
-                    ))}
-
-                    <Button
-                        kind="tertiary"
-                        startIcon={plusCircle}
-                        onClick={() => {
-                            const newLabel = {
-                                ...getDefaultFigureForType("label"),
-                                // Vertical offset for each label so they
-                                // don't overlap.
-                                coord: [0, -(labels?.length ?? 0)],
-                                // Default to the same color as the function
-                                color: lineColor,
-                            } satisfies LockedLabelType;
-
-                            onChangeProps({
-                                labels: [...(labels ?? []), newLabel],
-                            });
-                        }}
-                        style={styles.addButton}
-                    >
-                        Add visible label
-                    </Button>
-                </>
-            )}
+            <Strut size={spacing.xxxSmall_4} />
+            <View style={styles.horizontalRule} />
+            <Strut size={spacing.small_12} />
+            <LabelMedium>Visible labels</LabelMedium>
+            {labels?.map((label, labelIndex) => (
+                <LockedLabelSettings
+                    key={labelIndex}
+                    {...label}
+                    expanded={true}
+                    onChangeProps={(newLabel) => {
+                        handleLabelChange(newLabel, labelIndex);
+                    }}
+                    onRemove={() => {
+                        handleLabelRemove(labelIndex);
+                    }}
+                    containerStyle={styles.labelContainer}
+                />
+            ))}
+            <Button
+                kind="tertiary"
+                startIcon={plusCircle}
+                onClick={() => {
+                    const newLabel = {
+                        ...getDefaultFigureForType("label"),
+                        // Vertical offset for each label so they
+                        // don't overlap.
+                        coord: [0, -(labels?.length ?? 0)],
+                        // Default to the same color as the function
+                        color: lineColor,
+                    } satisfies LockedLabelType;
+
+                    onChangeProps({
+                        labels: [...(labels ?? []), newLabel],
+                    });
+                }}
+                style={styles.addButton}
+            >
+                Add visible label
+            </Button>
 
             {/* Actions */}
             <LockedFigureSettingsActions
diff --git a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-line-settings.tsx b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-line-settings.tsx
index 738d659a42..2a1ac90666 100644
--- a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-line-settings.tsx
+++ b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-line-settings.tsx
@@ -53,7 +53,6 @@ export type Props = LockedLineType &
 
 const LockedLineSettings = (props: Props) => {
     const {
-        flags,
         kind,
         points,
         color: lineColor,
@@ -247,7 +246,6 @@ const LockedLineSettings = (props: Props) => {
 
             {/* Defining points settings */}
             <LockedPointSettings
-                flags={flags}
                 headerLabel="Point 1"
                 expanded={true}
                 showPoint={showPoint1}
@@ -259,7 +257,6 @@ const LockedLineSettings = (props: Props) => {
                 onChangeProps={(newProps) => handleChangePoint(newProps, 0)}
             />
             <LockedPointSettings
-                flags={flags}
                 headerLabel="Point 2"
                 expanded={true}
                 showPoint={showPoint2}
@@ -282,58 +279,53 @@ const LockedLineSettings = (props: Props) => {
                 }}
             />
 
-            {flags?.["mafs"]?.["locked-line-labels"] && (
-                <>
-                    <Strut size={spacing.xxxSmall_4} />
-                    <View style={styles.horizontalRule} />
-                    <Strut size={spacing.small_12} />
-
-                    <LabelMedium>Visible labels</LabelMedium>
-
-                    {labels?.map((label, labelIndex) => (
-                        <LockedLabelSettings
-                            {...label}
-                            key={labelIndex}
-                            expanded={true}
-                            onChangeProps={(newLabel) => {
-                                handleLabelChange(newLabel, labelIndex);
-                            }}
-                            onRemove={() => {
-                                handleLabelRemove(labelIndex);
-                            }}
-                            containerStyle={styles.labelContainer}
-                        />
-                    ))}
-
-                    <Button
-                        kind="tertiary"
-                        startIcon={plusCircle}
-                        onClick={() => {
-                            // Additional vertical offset for each label so
-                            // they don't overlap.
-                            const offsetPerLabel: vec.Vector2 = [0, -1];
-                            const labelLocation = vec.add(
-                                vec.scale(offsetPerLabel, labels?.length ?? 0),
-                                vec.midpoint(points[0].coord, points[1].coord),
-                            );
-
-                            const newLabel = {
-                                ...getDefaultFigureForType("label"),
-                                coord: labelLocation,
-                                // Default to the same color as the line
-                                color: lineColor,
-                            } satisfies LockedLabelType;
-
-                            onChangeProps({
-                                labels: [...(labels ?? []), newLabel],
-                            });
-                        }}
-                        style={styles.addButton}
-                    >
-                        Add visible label
-                    </Button>
-                </>
-            )}
+            {/* Visible labels */}
+            <Strut size={spacing.xxxSmall_4} />
+            <View style={styles.horizontalRule} />
+            <Strut size={spacing.small_12} />
+            <LabelMedium>Visible labels</LabelMedium>
+
+            {labels?.map((label, labelIndex) => (
+                <LockedLabelSettings
+                    {...label}
+                    key={labelIndex}
+                    expanded={true}
+                    onChangeProps={(newLabel) => {
+                        handleLabelChange(newLabel, labelIndex);
+                    }}
+                    onRemove={() => {
+                        handleLabelRemove(labelIndex);
+                    }}
+                    containerStyle={styles.labelContainer}
+                />
+            ))}
+            <Button
+                kind="tertiary"
+                startIcon={plusCircle}
+                onClick={() => {
+                    // Additional vertical offset for each label so
+                    // they don't overlap.
+                    const offsetPerLabel: vec.Vector2 = [0, -1];
+                    const labelLocation = vec.add(
+                        vec.scale(offsetPerLabel, labels?.length ?? 0),
+                        vec.midpoint(points[0].coord, points[1].coord),
+                    );
+
+                    const newLabel = {
+                        ...getDefaultFigureForType("label"),
+                        coord: labelLocation,
+                        // Default to the same color as the line
+                        color: lineColor,
+                    } satisfies LockedLabelType;
+
+                    onChangeProps({
+                        labels: [...(labels ?? []), newLabel],
+                    });
+                }}
+                style={styles.addButton}
+            >
+                Add visible label
+            </Button>
 
             {/* Actions */}
             <LockedFigureSettingsActions
diff --git a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-point-settings.tsx b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-point-settings.tsx
index 903a931796..ec5e9c2c00 100644
--- a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-point-settings.tsx
+++ b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-point-settings.tsx
@@ -29,17 +29,9 @@ import {
 } from "./util";
 
 import type {LockedFigureSettingsMovementType} from "./locked-figure-settings-actions";
-import type {
-    APIOptions,
-    LockedLabelType,
-    LockedPointType,
-} from "@khanacademy/perseus";
+import type {LockedLabelType, LockedPointType} from "@khanacademy/perseus";
 
 export type Props = LockedPointType & {
-    /**
-     * Optional flags to determine which features are enabled.
-     */
-    flags?: APIOptions["flags"];
     /**
      * Optional label for the point to display in the header summary.
      * Defaults to "Point".
@@ -86,7 +78,6 @@ export type Props = LockedPointType & {
 
 const LockedPointSettings = (props: Props) => {
     const {
-        flags,
         headerLabel,
         coord,
         color: pointColor,
@@ -257,62 +248,54 @@ const LockedPointSettings = (props: Props) => {
                 </>
             )}
 
-            {((!isDefiningPoint && flags?.["mafs"]?.["locked-point-labels"]) ||
-                (isDefiningPoint &&
-                    flags?.["mafs"]?.["locked-line-labels"])) && (
-                <>
-                    <Strut size={spacing.xxxSmall_4} />
-                    <View style={styles.horizontalRule} />
-                    <Strut size={spacing.small_12} />
-
-                    <LabelMedium>Visible labels</LabelMedium>
-
-                    {labels?.map((label, labelIndex) => (
-                        <LockedLabelSettings
-                            {...label}
-                            key={labelIndex}
-                            containerStyle={
-                                !isDefiningPoint &&
-                                styles.lockedPointLabelContainer
-                            }
-                            expanded={true}
-                            onChangeProps={(newLabel) => {
-                                handleLabelChange(newLabel, labelIndex);
-                            }}
-                            onRemove={() => {
-                                handleLabelRemove(labelIndex);
-                            }}
-                        />
-                    ))}
-                    <Button
-                        kind="tertiary"
-                        startIcon={plusCircle}
-                        onClick={() => {
-                            const newLabel = {
-                                ...getDefaultFigureForType("label"),
-                                // Place the label at the same position
-                                // as the point. Add a small offset to
-                                // avoid crowding.
-                                coord: [
-                                    coord[0] + 0.5,
-                                    // Additional offset for each label so
-                                    // they don't overlap.
-                                    coord[1] - 1 * (labels?.length ?? 0),
-                                ],
-                                // Default to the same color as the point
-                                color: pointColor,
-                            } satisfies LockedLabelType;
-
-                            onChangeProps({
-                                labels: [...(labels ?? []), newLabel],
-                            });
-                        }}
-                        style={styles.addButton}
-                    >
-                        Add visible label
-                    </Button>
-                </>
-            )}
+            {/* Visible labels */}
+            <Strut size={spacing.xxxSmall_4} />
+            <View style={styles.horizontalRule} />
+            <Strut size={spacing.small_12} />
+            <LabelMedium>Visible labels</LabelMedium>
+            {labels?.map((label, labelIndex) => (
+                <LockedLabelSettings
+                    {...label}
+                    key={labelIndex}
+                    containerStyle={
+                        !isDefiningPoint && styles.lockedPointLabelContainer
+                    }
+                    expanded={true}
+                    onChangeProps={(newLabel) => {
+                        handleLabelChange(newLabel, labelIndex);
+                    }}
+                    onRemove={() => {
+                        handleLabelRemove(labelIndex);
+                    }}
+                />
+            ))}
+            <Button
+                kind="tertiary"
+                startIcon={plusCircle}
+                onClick={() => {
+                    const newLabel = {
+                        ...getDefaultFigureForType("label"),
+                        // Place the label at the same position
+                        // as the point. Add a small offset to
+                        // avoid crowding.
+                        coord: [
+                            coord[0] + 0.5,
+                            // Additional offset for each label so
+                            // they don't overlap.
+                            coord[1] - 1 * (labels?.length ?? 0),
+                        ],
+                        // Default to the same color as the point
+                        color: pointColor,
+                    } satisfies LockedLabelType;
+
+                    onChangeProps({
+                        labels: [...(labels ?? []), newLabel],
+                    });
+                }}
+                style={styles.addButton}
+            >
+                Add visible label
+            </Button>
 
             {onRemove && (
                 <LockedFigureSettingsActions
diff --git a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-polygon-settings.tsx b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-polygon-settings.tsx
index e805294ade..bb83372ac8 100644
--- a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-polygon-settings.tsx
+++ b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-polygon-settings.tsx
@@ -50,7 +50,6 @@ export type Props = LockedFigureSettingsCommonProps &
 
 const LockedPolygonSettings = (props: Props) => {
     const {
-        flags,
         points,
         color,
         showVertices,
@@ -349,55 +348,48 @@ const LockedPolygonSettings = (props: Props) => {
             />
 
             {/* Visible Labels */}
-            {flags?.["mafs"]?.["locked-polygon-labels"] && (
-                <>
-                    <Strut size={spacing.xxxSmall_4} />
-                    <View style={styles.horizontalRule} />
-                    <Strut size={spacing.small_12} />
-
-                    <LabelMedium>Visible labels</LabelMedium>
-
-                    {labels?.map((label, labelIndex) => (
-                        <LockedLabelSettings
-                            {...label}
-                            key={labelIndex}
-                            expanded={true}
-                            onChangeProps={(newLabel) => {
-                                handleLabelChange(newLabel, labelIndex);
-                            }}
-                            onRemove={() => {
-                                handleLabelRemove(labelIndex);
-                            }}
-                            containerStyle={styles.labelContainer}
-                        />
-                    ))}
-
-                    <Button
-                        kind="tertiary"
-                        startIcon={plusCircle}
-                        onClick={() => {
-                            const newLabel = {
-                                ...getDefaultFigureForType("label"),
-                                coord: [
-                                    points[0][0],
-                                    // Additional vertical offset for each
-                                    // label so they don't overlap.
-                                    points[0][1] - (labels?.length ?? 0),
-                                ],
-                                // Default to the same color as the ellipse
-                                color: color,
-                            } satisfies LockedLabelType;
-
-                            onChangeProps({
-                                labels: [...(labels ?? []), newLabel],
-                            });
-                        }}
-                        style={styles.addButton}
-                    >
-                        Add visible label
-                    </Button>
-                </>
-            )}
+            <Strut size={spacing.xxxSmall_4} />
+            <View style={styles.horizontalRule} />
+            <Strut size={spacing.small_12} />
+            <LabelMedium>Visible labels</LabelMedium>
+            {labels?.map((label, labelIndex) => (
+                <LockedLabelSettings
+                    {...label}
+                    key={labelIndex}
+                    expanded={true}
+                    onChangeProps={(newLabel) => {
+                        handleLabelChange(newLabel, labelIndex);
+                    }}
+                    onRemove={() => {
+                        handleLabelRemove(labelIndex);
+                    }}
+                    containerStyle={styles.labelContainer}
+                />
+            ))}
+            <Button
+                kind="tertiary"
+                startIcon={plusCircle}
+                onClick={() => {
+                    const newLabel = {
+                        ...getDefaultFigureForType("label"),
+                        coord: [
+                            points[0][0],
+                            // Additional vertical offset for each
+                            // label so they don't overlap.
+                            points[0][1] - (labels?.length ?? 0),
+                        ],
+                        // Default to the same color as the ellipse
+                        color: color,
+                    } satisfies LockedLabelType;
+
+                    onChangeProps({
+                        labels: [...(labels ?? []), newLabel],
+                    });
+                }}
+                style={styles.addButton}
+            >
+                Add visible label
+            </Button>
 
             {/* Actions */}
             <LockedFigureSettingsActions
diff --git a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-vector-settings.tsx b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-vector-settings.tsx
index a13cc03811..1c0c26ce79 100644
--- a/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-vector-settings.tsx
+++ b/packages/perseus-editor/src/widgets/interactive-graph-editor/locked-figures/locked-vector-settings.tsx
@@ -50,7 +50,6 @@ export type Props = LockedVectorType &
 
 const LockedVectorSettings = (props: Props) => {
     const {
-        flags,
         points,
         color: lineColor,
         labels,
@@ -220,58 +219,52 @@ const LockedVectorSettings = (props: Props) => {
                 }}
             />
 
-            {flags?.["mafs"]?.["locked-vector-labels"] && (
-                <>
-                    <Strut size={spacing.xxxSmall_4} />
-                    <View style={styles.horizontalRule} />
-                    <Strut size={spacing.small_12} />
-
-                    <LabelMedium>Visible labels</LabelMedium>
-
-                    {labels?.map((label, labelIndex) => (
-                        <LockedLabelSettings
-                            {...label}
-                            key={labelIndex}
-                            expanded={true}
-                            onChangeProps={(newLabel) => {
-                                handleLabelChange(newLabel, labelIndex);
-                            }}
-                            onRemove={() => {
-                                handleLabelRemove(labelIndex);
-                            }}
-                            containerStyle={styles.labelContainer}
-                        />
-                    ))}
-
-                    <Button
-                        kind="tertiary"
-                        startIcon={plusCircle}
-                        onClick={() => {
-                            // Additional vertical offset for each label so
-                            // they don't overlap.
-                            const offsetPerLabel: vec.Vector2 = [0, -1];
-                            const labelLocation = vec.add(
-                                vec.scale(offsetPerLabel, labels?.length ?? 0),
-                                vec.midpoint(tail, tip),
-                            );
-
-                            const newLabel = {
-                                ...getDefaultFigureForType("label"),
-                                coord: labelLocation,
-                                // Default to the same color as the vector
-                                color: lineColor,
-                            } satisfies LockedLabelType;
-
-                            onChangeProps({
-                                labels: [...(labels ?? []), newLabel],
-                            });
-                        }}
-                        style={styles.addButton}
-                    >
-                        Add visible label
-                    </Button>
-                </>
-            )}
+            {/* Visible labels */}
+            <Strut size={spacing.xxxSmall_4} />
+            <View style={styles.horizontalRule} />
+            <Strut size={spacing.small_12} />
+            <LabelMedium>Visible labels</LabelMedium>
+            {labels?.map((label, labelIndex) => (
+                <LockedLabelSettings
+                    {...label}
+                    key={labelIndex}
+                    expanded={true}
+                    onChangeProps={(newLabel) => {
+                        handleLabelChange(newLabel, labelIndex);
+                    }}
+                    onRemove={() => {
+                        handleLabelRemove(labelIndex);
+                    }}
+                    containerStyle={styles.labelContainer}
+                />
+            ))}
+            <Button
+                kind="tertiary"
+                startIcon={plusCircle}
+                onClick={() => {
+                    // Additional vertical offset for each label so
+                    // they don't overlap.
+                    const offsetPerLabel: vec.Vector2 = [0, -1];
+                    const labelLocation = vec.add(
+                        vec.scale(offsetPerLabel, labels?.length ?? 0),
+                        vec.midpoint(tail, tip),
+                    );
+
+                    const newLabel = {
+                        ...getDefaultFigureForType("label"),
+                        coord: labelLocation,
+                        // Default to the same color as the vector
+                        color: lineColor,
+                    } satisfies LockedLabelType;
+
+                    onChangeProps({
+                        labels: [...(labels ?? []), newLabel],
+                    });
+                }}
+                style={styles.addButton}
+            >
+                Add visible label
+            </Button>
 
             {/* Actions */}
             <LockedFigureSettingsActions
diff --git a/packages/perseus/src/types.ts b/packages/perseus/src/types.ts
index 96ef6e5dea..1626674b6c 100644
--- a/packages/perseus/src/types.ts
+++ b/packages/perseus/src/types.ts
@@ -208,39 +208,6 @@ export const MafsGraphTypeFlags = [
     "none",
 ] as const;
 
-export const InteractiveGraphLockedFeaturesFlags = [
-    /**
-     * Enables/disables the labels associated with locked points in the
-     * updated Interactive Graph widget.
-     */
-    "locked-point-labels",
-    /**
-     * Enables/disables the labels associated with locked lines in the
-     * updated Interactive Graph widget.
-     */
-    "locked-line-labels",
-    /**
-     * enables/disables the labels associated with locked vectors in the
-     * updated Interactive Graph widget.
-     */
-    "locked-vector-labels",
-    /**
-     * Enables/disables the labels associated with locked ellipses in the
-     * updated Interactive Graph widget.
-     */
-    "locked-ellipse-labels",
-    /**
-     * Enables/disables the labels associated with locked polygons in the
-     * updated Interactive Graph widget.
-     */
-    "locked-polygon-labels",
-    /**
-     * Enables/disables the labels associated with locked functions in the
-     * updated Interactive Graph widget.
-     */
-    "locked-function-labels",
-] as const;
-
 /**
  * APIOptions provides different ways to customize the behaviour of Perseus.
  *
@@ -370,11 +337,7 @@ export type APIOptions = Readonly<{
          *
          * Add values to the relevant array to create new flags.
          */
-        mafs?:
-            | false
-            | ({[Key in (typeof MafsGraphTypeFlags)[number]]?: boolean} & {
-                  [Key in (typeof InteractiveGraphLockedFeaturesFlags)[number]]?: boolean;
-              });
+        mafs?: false | {[Key in (typeof MafsGraphTypeFlags)[number]]?: boolean};
     };
     /**
      * This is a callback function that returns all of the Widget props
diff --git a/packages/perseus/src/widgets/interactive-graphs/graph-locked-labels-layer.tsx b/packages/perseus/src/widgets/interactive-graphs/graph-locked-labels-layer.tsx
index a434e0b33b..e7e8fdeef6 100644
--- a/packages/perseus/src/widgets/interactive-graphs/graph-locked-labels-layer.tsx
+++ b/packages/perseus/src/widgets/interactive-graphs/graph-locked-labels-layer.tsx
@@ -3,70 +3,45 @@ import * as React from "react";
 import LockedLabel from "./locked-figures/locked-label";
 
 import type {LockedFigure} from "../../perseus-types";
-import type {APIOptions} from "../../types";
 
 type Props = {
-    flags?: APIOptions["flags"];
     lockedFigures: ReadonlyArray<LockedFigure>;
 };
 
 export default function GraphLockedLabelsLayer(props: Props) {
-    const {flags, lockedFigures} = props;
+    const {lockedFigures} = props;
 
     return lockedFigures.map((figure, i) => {
         if (figure.type === "label") {
             return <LockedLabel key={`label-${i}`} {...figure} />;
         }
 
-        if (
-            // Point flag + point type
-            (flags?.["mafs"]?.["locked-point-labels"] &&
-                figure.type === "point") ||
-            // Line flag + line type
-            (flags?.["mafs"]?.["locked-line-labels"] &&
-                figure.type === "line") ||
-            // Vector flag + vector type
-            (flags?.["mafs"]?.["locked-vector-labels"] &&
-                figure.type === "vector") ||
-            // Ellipse flag + ellipse type
-            (flags?.["mafs"]?.["locked-ellipse-labels"] &&
-                figure.type === "ellipse") ||
-            // Polygon flag + polygon type
-            (flags?.["mafs"]?.["locked-polygon-labels"] &&
-                figure.type === "polygon") ||
-            // Function flag + function type
-            (flags?.["mafs"]?.["locked-function-labels"] &&
-                figure.type === "function")
-        ) {
-            return (
-                <React.Fragment key={i}>
-                    {figure.labels?.map((label, j) => (
-                        <LockedLabel key={`${i}-label-${j}`} {...label} />
-                    ))}
-
-                    {/* Account for the labels within the lines' defining points */}
-                    {figure.type === "line" && (
-                        <>
-                            {/* Point 1 labels */}
-                            {figure.points[0].labels?.map((label, k) => (
-                                <LockedLabel
-                                    key={`locked-figure-${i}-point-1-label-${k}`}
-                                    {...label}
-                                />
-                            ))}
-                            {/* Point 2 labels */}
-                            {figure.points[1].labels?.map((label, k) => (
-                                <LockedLabel
-                                    key={`locked-figure-${i}-point-2-label-${k}`}
-                                    {...label}
-                                />
-                            ))}
-                        </>
-                    )}
-                </React.Fragment>
-            );
-        }
-
-        return null;
+        return (
+            <React.Fragment key={i}>
+                {figure.labels?.map((label, j) => (
+                    <LockedLabel key={`${i}-label-${j}`} {...label} />
+                ))}
+
+                {/* Account for the labels within the lines' defining points */}
+                {figure.type === "line" && (
+                    <>
+                        {/* Point 1 labels */}
+                        {figure.points[0].labels?.map((label, k) => (
+                            <LockedLabel
+                                key={`locked-figure-${i}-point-1-label-${k}`}
+                                {...label}
+                            />
+                        ))}
+                        {/* Point 2 labels */}
+                        {figure.points[1].labels?.map((label, k) => (
+                            <LockedLabel
+                                key={`locked-figure-${i}-point-2-label-${k}`}
+                                {...label}
+                            />
+                        ))}
+                    </>
+                )}
+            </React.Fragment>
+        );
     });
 }
diff --git a/packages/perseus/src/widgets/interactive-graphs/interactive-graph.test.tsx b/packages/perseus/src/widgets/interactive-graphs/interactive-graph.test.tsx
index 2b7fb03595..399401e411 100644
--- a/packages/perseus/src/widgets/interactive-graphs/interactive-graph.test.tsx
+++ b/packages/perseus/src/widgets/interactive-graphs/interactive-graph.test.tsx
@@ -991,14 +991,10 @@ describe("Interactive Graph", function () {
 
         it("should render a locked label within a locked polygon", async () => {
             // Arrange
-            const {container} = renderQuestion(graphWithLabeledPolygon, {
-                flags: {
-                    mafs: {
-                        segment: true,
-                        "locked-polygon-labels": true,
-                    },
-                },
-            });
+            const {container} = renderQuestion(
+                graphWithLabeledPolygon,
+                apiOptions,
+            );
 
             // Act
             // eslint-disable-next-line testing-library/no-container, testing-library/no-node-access
@@ -1212,14 +1208,10 @@ describe("Interactive Graph", function () {
 
         it("should render a locked label within a locked point", async () => {
             // Arrange
-            const {container} = renderQuestion(graphWithLabeledPoint, {
-                flags: {
-                    mafs: {
-                        segment: true,
-                        "locked-point-labels": true,
-                    },
-                },
-            });
+            const {container} = renderQuestion(
+                graphWithLabeledPoint,
+                apiOptions,
+            );
 
             // Act
             // eslint-disable-next-line testing-library/no-container, testing-library/no-node-access
@@ -1238,14 +1230,10 @@ describe("Interactive Graph", function () {
         });
 
         it("should render a locked label within a locked line", async () => {
-            const {container} = renderQuestion(graphWithLabeledLine, {
-                flags: {
-                    mafs: {
-                        segment: true,
-                        "locked-line-labels": true,
-                    },
-                },
-            });
+            const {container} = renderQuestion(
+                graphWithLabeledLine,
+                apiOptions,
+            );
 
             // Act
             // eslint-disable-next-line testing-library/no-container, testing-library/no-node-access
@@ -1285,15 +1273,10 @@ describe("Interactive Graph", function () {
                     ],
                 },
             ];
-            const {container} = renderQuestion(graphWithLabeledLine, {
-                flags: {
-                    mafs: {
-                        segment: true,
-                        "locked-line-labels": true,
-                        "locked-point-labels": true,
-                    },
-                },
-            });
+            const {container} = renderQuestion(
+                graphWithLabeledLine,
+                apiOptions,
+            );
 
             // Act
             // eslint-disable-next-line testing-library/no-container, testing-library/no-node-access
@@ -1311,14 +1294,10 @@ describe("Interactive Graph", function () {
 
         it("should render a locked label within a locked vector", async () => {
             // Arrange
-            const {container} = renderQuestion(graphWithLabeledVector, {
-                flags: {
-                    mafs: {
-                        segment: true,
-                        "locked-vector-labels": true,
-                    },
-                },
-            });
+            const {container} = renderQuestion(
+                graphWithLabeledVector,
+                apiOptions,
+            );
 
             // Act
             // eslint-disable-next-line testing-library/no-container, testing-library/no-node-access
@@ -1338,14 +1317,10 @@ describe("Interactive Graph", function () {
 
         it("should render a locked label within a locked ellipse", async () => {
             // Arrange
-            const {container} = renderQuestion(graphWithLabeledEllipse, {
-                flags: {
-                    mafs: {
-                        segment: true,
-                        "locked-ellipse-labels": true,
-                    },
-                },
-            });
+            const {container} = renderQuestion(
+                graphWithLabeledEllipse,
+                apiOptions,
+            );
 
             // Act
             // eslint-disable-next-line testing-library/no-container, testing-library/no-node-access
@@ -1365,14 +1340,10 @@ describe("Interactive Graph", function () {
 
         it("should render a locked label within a locked function", async () => {
             // Arrange
-            const {container} = renderQuestion(graphWithLabeledFunction, {
-                flags: {
-                    mafs: {
-                        segment: true,
-                        "locked-function-labels": true,
-                    },
-                },
-            });
+            const {container} = renderQuestion(
+                graphWithLabeledFunction,
+                apiOptions,
+            );
 
             // Act
             // eslint-disable-next-line testing-library/no-container, testing-library/no-node-access
diff --git a/packages/perseus/src/widgets/interactive-graphs/mafs-graph.tsx b/packages/perseus/src/widgets/interactive-graphs/mafs-graph.tsx
index 0ec7ae4724..6ede95dab0 100644
--- a/packages/perseus/src/widgets/interactive-graphs/mafs-graph.tsx
+++ b/packages/perseus/src/widgets/interactive-graphs/mafs-graph.tsx
@@ -271,7 +271,6 @@ export const MafsGraph = (props: MafsGraphProps) => {
                         </Mafs>
                         {props.lockedFigures && (
                             <GraphLockedLabelsLayer
-                                flags={props.flags}
                                 lockedFigures={props.lockedFigures}
                             />
                         )}