diff --git a/bindings/pydrake/examples/gym/envs/cart_pole.py b/bindings/pydrake/examples/gym/envs/cart_pole.py
index 1448d9e0067a..0f10ddf7787b 100644
--- a/bindings/pydrake/examples/gym/envs/cart_pole.py
+++ b/bindings/pydrake/examples/gym/envs/cart_pole.py
@@ -1,5 +1,4 @@
 import gymnasium as gym
-import matplotlib.pyplot as plt
 import numpy as np
 
 from pydrake.common import FindResourceOrThrow
@@ -82,7 +81,7 @@ def make_sim(meshcat=None,
         time_step=sim_time_step,
         contact_model=contact_model,
         discrete_contact_approximation=contact_approximation,
-        )
+    )
 
     plant, scene_graph = AddMultibodyPlant(multibody_plant_config, builder)
 
@@ -125,6 +124,7 @@ def make_sim(meshcat=None,
         print("Actuation view: ", actuation_view(np.ones(na)), '\n')
 
         # Visualize the plant.
+        import matplotlib.pyplot as plt
         plt.figure()
         plot_graphviz(plant.GetTopologyGraphvizString())
         plt.plot(1)
@@ -371,6 +371,12 @@ def reset_handler(simulator, diagram_context, seed):
         body.SetMass(plant_context, mass+pair[1])
 
 
+def info_handler(simulator: Simulator) -> dict:
+    info = dict()
+    info["timestamp"] = simulator.get_context().get_time()
+    return info
+
+
 def DrakeCartPoleEnv(
         meshcat=None,
         time_limit=gym_time_limit,
@@ -415,6 +421,7 @@ def DrakeCartPoleEnv(
         action_port_id="actions",
         observation_port_id="observations",
         reset_handler=reset_handler,
+        info_handler=info_handler,
         render_rgb_port_id="color_image" if monitoring_camera else None)
 
     # Expose parameters that could be useful for learning.
diff --git a/bindings/pydrake/examples/gym/play_cart_pole.py b/bindings/pydrake/examples/gym/play_cart_pole.py
index 21f57b06f865..58e6f842d5da 100644
--- a/bindings/pydrake/examples/gym/play_cart_pole.py
+++ b/bindings/pydrake/examples/gym/play_cart_pole.py
@@ -2,7 +2,6 @@
 Play a policy for //bindings/pydrake/examples/gym/envs:cart_pole.
 """
 import argparse
-import sys
 import warnings
 
 import gymnasium as gym
@@ -71,12 +70,6 @@ def _main():
     parser.add_argument('--log_path', help="path to the logs directory.")
     args = parser.parse_args()
 
-    if args.test and (sys.platform == "darwin"):
-        # TODO(#21577) Importing Gym on macOS Homebrew goes up in flames.
-        # We need to skip this test in Drake CI.
-        print("Testing is disabled when on macOS")
-        return
-
     if not args.debug:
         warnings.filterwarnings("ignore")
     gym.envs.register(id="DrakeCartPole-v0",
diff --git a/bindings/pydrake/geometry/geometry_py_common.cc b/bindings/pydrake/geometry/geometry_py_common.cc
index abb79b102668..7f7f56fb5ae0 100644
--- a/bindings/pydrake/geometry/geometry_py_common.cc
+++ b/bindings/pydrake/geometry/geometry_py_common.cc
@@ -322,24 +322,27 @@ void DefineGeometryPropertiesSubclasses(py::module m) {
   {
     py::class_<IllustrationProperties, GeometryProperties> cls(
         m, "IllustrationProperties", doc.IllustrationProperties.doc);
-    cls.def(py::init(), doc.IllustrationProperties.ctor.doc)
-        .def(py::init<const IllustrationProperties&>(), py::arg("other"),
+    cls  // BR
+        .def(py::init(), doc.IllustrationProperties.ctor.doc)
+        .def(py::init<const GeometryProperties&>(), py::arg("other"),
             "Creates a copy of the properties");
     DefCopyAndDeepCopy(&cls);
   }
   {
     py::class_<PerceptionProperties, GeometryProperties> cls(
         m, "PerceptionProperties", doc.PerceptionProperties.doc);
-    cls.def(py::init(), doc.PerceptionProperties.ctor.doc)
-        .def(py::init<const PerceptionProperties&>(), py::arg("other"),
+    cls  // BR
+        .def(py::init(), doc.PerceptionProperties.ctor.doc)
+        .def(py::init<const GeometryProperties&>(), py::arg("other"),
             "Creates a copy of the properties");
     DefCopyAndDeepCopy(&cls);
   }
   {
     py::class_<ProximityProperties, GeometryProperties> cls(
         m, "ProximityProperties", doc.ProximityProperties.doc);
-    cls.def(py::init(), doc.ProximityProperties.ctor.doc)
-        .def(py::init<const ProximityProperties&>(), py::arg("other"),
+    cls  // BR
+        .def(py::init(), doc.ProximityProperties.ctor.doc)
+        .def(py::init<const GeometryProperties&>(), py::arg("other"),
             "Creates a copy of the properties");
     DefCopyAndDeepCopy(&cls);
   }
diff --git a/bindings/pydrake/geometry/geometry_py_optimization.cc b/bindings/pydrake/geometry/geometry_py_optimization.cc
index e1f4e9c3689c..e8ed64ce96ae 100644
--- a/bindings/pydrake/geometry/geometry_py_optimization.cc
+++ b/bindings/pydrake/geometry/geometry_py_optimization.cc
@@ -740,6 +740,10 @@ void DefineGraphOfConvexSetsAndRelated(py::module m) {
                       std::move(preprocessing_solver_options);
                 }),
             cls_doc.preprocessing_solver_options.doc)
+        .def_readwrite("preprocessing_parallelism",
+            &GraphOfConvexSetsOptions::preprocessing_parallelism)
+        .def_readwrite("preprocessing_parallel_batch_size",
+            &GraphOfConvexSetsOptions::preprocessing_parallel_batch_size)
         .def("__repr__", [](const GraphOfConvexSetsOptions& self) {
           return py::str(
               "GraphOfConvexSetsOptions("
@@ -755,13 +759,15 @@ void DefineGraphOfConvexSetsAndRelated(py::module m) {
               "solver_options={}, "
               "restriction_solver_options={}, "
               "preprocessing_solver_options={}, "
+              "preprocessing_parallel_batch_size={}, "
               ")")
               .format(self.convex_relaxation, self.preprocessing,
                   self.max_rounded_paths, self.max_rounding_trials,
                   self.flow_tolerance, self.rounding_seed, self.solver,
                   self.restriction_solver, self.preprocessing_solver,
                   self.solver_options, self.restriction_solver_options,
-                  self.preprocessing_solver_options);
+                  self.preprocessing_solver_options,
+                  self.preprocessing_parallel_batch_size);
         });
 
     DefReadWriteKeepAlive(&gcs_options, "solver",
diff --git a/bindings/pydrake/geometry/test/common_test.py b/bindings/pydrake/geometry/test/common_test.py
index d676e98d7a02..ca1e6e584181 100644
--- a/bindings/pydrake/geometry/test/common_test.py
+++ b/bindings/pydrake/geometry/test/common_test.py
@@ -157,6 +157,17 @@ def test_geometry_properties_api(self):
             props_copy3 = copy.deepcopy(props)
             self.assertTrue(props_copy3.HasProperty("g", "p"))
 
+        # Cross-property-set copying. We don't do all cross possibilities.
+        # Merely confirm that each set can be copied from another set.
+        source = mut.PerceptionProperties()
+        source.AddProperty("a", "b", 10)
+        illustration = mut.IllustrationProperties(source)
+        self.assertEqual(illustration.GetProperty("a", "b"), 10)
+        proximity = mut.ProximityProperties(illustration)
+        self.assertEqual(proximity.GetProperty("a", "b"), 10)
+        perception = mut.PerceptionProperties(proximity)
+        self.assertEqual(perception.GetProperty("a", "b"), 10)
+
     def test_geometry_properties_cpp_types(self):
         """
         Confirms that types stored in properties in python, resolve to expected
diff --git a/bindings/pydrake/geometry/test/optimization_test.py b/bindings/pydrake/geometry/test/optimization_test.py
index 789d6e85b08a..d6846af05914 100644
--- a/bindings/pydrake/geometry/test/optimization_test.py
+++ b/bindings/pydrake/geometry/test/optimization_test.py
@@ -796,6 +796,8 @@ def test_graph_of_convex_sets(self):
         options.preprocessing_solver_options = SolverOptions()
         options.preprocessing_solver_options.SetOption(
             ClpSolver.id(), "log_level", 3)
+        options.preprocessing_parallelism = True
+        options.preprocessing_parallel_batch_size = 1000
         self.assertIn("scaling",
                       options.solver_options.GetOptions(ClpSolver.id()))
         self.assertIn("log_level",
diff --git a/bindings/pydrake/gym/_drake_gym_env.py b/bindings/pydrake/gym/_drake_gym_env.py
index a7ef44986f77..5deae892d9ae 100644
--- a/bindings/pydrake/gym/_drake_gym_env.py
+++ b/bindings/pydrake/gym/_drake_gym_env.py
@@ -36,6 +36,7 @@ def __init__(self,
                  render_rgb_port_id: Union[OutputPortIndex, str] = None,
                  render_mode: str = 'human',
                  reset_handler: Callable[[Simulator, Context], None] = None,
+                 info_handler: Callable[[Simulator], dict] = None,
                  hardware: bool = False):
         """
         Args:
@@ -87,6 +88,12 @@ def __init__(self,
                 (e.g. ``joint.set_random_pose_distribution()``
                 using the ``reset()`` seed), (otherwise) using
                 ``reset_handler()``.
+            info_handler: A function that returns a ``dict[str, Any]``
+                containing auxiliary diagnostic information (helpful for
+                debugging, learning, and logging). Note: if ``step()``
+                terminates with a ``RuntimeError``, then, to avoid
+                unexpected behavior, `info_handler()`` will not be called
+                and an empty info will be returned instead.
             hardware: If True, it prevents from setting random context at
                 ``reset()`` when using ``random_generator``, but it does
                 execute ``reset_handler()`` if given.
@@ -158,6 +165,12 @@ def __init__(self,
         else:
             raise ValueError("reset_handler is not callable.")
 
+        # Default return value of `info_handler()` is an empty `dict`.
+        if info_handler is callable(info_handler):
+            self.info_handler = info_handler
+        else:
+            self.info_handler = lambda _: dict()
+
         self.hardware = hardware
 
         if self.simulator:
@@ -223,7 +236,6 @@ def step(self, action):
         truncated = False
         # Observation prior to advancing the simulation.
         prev_observation = self.observation_port.Eval(context)
-        info = dict()
         try:
             status = self.simulator.AdvanceTo(time + self.time_step)
         except RuntimeError as e:
@@ -245,6 +257,9 @@ def step(self, action):
             truncated = True
             terminated = False
             reward = 0
+            # Do not call info handler, as the simulator has faulted.
+            info = dict()
+
             return prev_observation, reward, terminated, truncated, info
 
         observation = self.observation_port.Eval(context)
@@ -253,6 +268,7 @@ def step(self, action):
             not truncated
             and (status.reason()
                  == SimulatorStatus.ReturnReason.kReachedTerminationCondition))
+        info = self.info_handler(self.simulator)
 
         return observation, reward, terminated, truncated, info
 
@@ -293,7 +309,9 @@ def reset(self, *,
         # Note: The output port will be evaluated without fixing the input
         # port.
         observations = self.observation_port.Eval(context)
-        return observations, dict()
+        info = self.info_handler(self.simulator)
+
+        return observations, info
 
     def render(self):
         """
diff --git a/bindings/pydrake/gym/test/drake_gym_test.py b/bindings/pydrake/gym/test/drake_gym_test.py
index 7e83fc38c795..69658f0472bc 100644
--- a/bindings/pydrake/gym/test/drake_gym_test.py
+++ b/bindings/pydrake/gym/test/drake_gym_test.py
@@ -1,4 +1,3 @@
-import sys
 import unittest
 
 import gymnasium as gym
@@ -26,13 +25,9 @@ def setUpClass(cls):
     def make_env(self):
         return gym.make("DrakeCartPole-v0")
 
-    # TODO(#21577) Importing Gym on macOS Homebrew goes up in flames.
-    @unittest.skipIf(sys.platform == "darwin", "Disabled macOS")
     def test_make_env(self):
         self.make_env()
 
-    # TODO(#21577) Importing Gym on macOS Homebrew goes up in flames.
-    @unittest.skipIf(sys.platform == "darwin", "Disabled macOS")
     def test_sb3_check_env(self):
         """Run stable-baselines's built-in test suite for our env."""
         dut = self.make_env()
@@ -45,8 +40,6 @@ def test_sb3_check_env(self):
     # supported versions of `gymnasium` and `stable_baselines3`, stable
     # baselines vector envs do not pass stable baselines' `check_env` tests.
 
-    # TODO(#21577) Importing Gym on macOS Homebrew goes up in flames.
-    @unittest.skipIf(sys.platform == "darwin", "Disabled macOS")
     def test_reset(self):
         # reset(int) sets a deterministic seed.
         dut = self.make_env()
@@ -68,8 +61,6 @@ def test_reset(self):
         self.assertIsInstance(opts, dict)
         self.assertTrue(dut.observation_space.contains(observation))
 
-    # TODO(#21577) Importing Gym on macOS Homebrew goes up in flames.
-    @unittest.skipIf(sys.platform == "darwin", "Disabled macOS")
     def test_step(self):
         dut = self.make_env()
         dut.reset()
diff --git a/bindings/pydrake/multibody/plant_py.cc b/bindings/pydrake/multibody/plant_py.cc
index 73e4dd04bc54..3204186e5e19 100644
--- a/bindings/pydrake/multibody/plant_py.cc
+++ b/bindings/pydrake/multibody/plant_py.cc
@@ -977,6 +977,12 @@ void DoScalarDependentDefinitions(py::module m, T) {
             py::arg("diffuse_color"),
             cls_doc.RegisterVisualGeometry
                 .doc_5args_body_X_BG_shape_name_diffuse_color)
+        .def("RegisterVisualGeometry",
+            py::overload_cast<const RigidBody<T>&,
+                std::unique_ptr<geometry::GeometryInstance>>(
+                &Class::RegisterVisualGeometry),
+            py::arg("body"), py::arg("geometry_instance"),
+            cls_doc.RegisterVisualGeometry.doc_2args_body_geometry_instance)
         .def("RegisterCollisionGeometry",
             py::overload_cast<const RigidBody<T>&,
                 const RigidTransform<double>&, const geometry::Shape&,
diff --git a/bindings/pydrake/multibody/test/plant_test.py b/bindings/pydrake/multibody/test/plant_test.py
index a0d8f2d6d39f..d3dd9a0faaef 100644
--- a/bindings/pydrake/multibody/test/plant_test.py
+++ b/bindings/pydrake/multibody/test/plant_test.py
@@ -232,6 +232,11 @@ def test_multibody_plant_construction_api(self, T):
             plant.RegisterVisualGeometry(
                 body=body, X_BG=body_X_BG, shape=box, name="new_body_visual",
                 diffuse_color=[1., 0.64, 0.0, 0.5])
+            plant.RegisterVisualGeometry(
+                body=body,
+                geometry_instance=GeometryInstance(X_PG=body_X_BG,
+                                                   shape=Sphere(1.0),
+                                                   name="from_instance"))
             plant.RegisterCollisionGeometry(
                 body=body, X_BG=body_X_BG, shape=box,
                 name="new_body_collision", coulomb_friction=body_friction)
diff --git a/common/schema/rotation.cc b/common/schema/rotation.cc
index bda53d781135..84d8b9096356 100644
--- a/common/schema/rotation.cc
+++ b/common/schema/rotation.cc
@@ -87,5 +87,12 @@ math::RotationMatrix<Expression> Rotation::ToSymbolic() const {
   }, value);
 }
 
+math::RotationMatrixd Rotation::Sample(RandomGenerator* generator) const {
+  const math::RotationMatrix<Expression> symbolic_rotation = this->ToSymbolic();
+  const math::RotationMatrixd concrete_rotation(
+      symbolic::Evaluate(symbolic_rotation.matrix(), {}, generator));
+  return concrete_rotation;
+}
+
 }  // namespace schema
 }  // namespace drake
diff --git a/common/schema/rotation.h b/common/schema/rotation.h
index 02f58007ff33..f2428b9b97d4 100644
--- a/common/schema/rotation.h
+++ b/common/schema/rotation.h
@@ -94,6 +94,10 @@ class Rotation {
   /// contain one or more random variables, based on the distributions in use.
   math::RotationMatrix<symbolic::Expression> ToSymbolic() const;
 
+  /// Samples this Rotation.  If this is deterministic, the result is the same
+  /// as GetDeterministicValue.
+  math::RotationMatrixd Sample(RandomGenerator* generator) const;
+
   /// Sets this value to the given deterministic RPY, in degrees.
   void set_rpy_deg(const Eigen::Vector3d& rpy_deg) {
     value.emplace<Rotation::Rpy>().deg = rpy_deg;
diff --git a/common/schema/test/rotation_test.cc b/common/schema/test/rotation_test.cc
index 701a49b28402..867607c9bcbe 100644
--- a/common/schema/test/rotation_test.cc
+++ b/common/schema/test/rotation_test.cc
@@ -97,6 +97,25 @@ GTEST_TEST(RotationTest, RpyToYaml) {
             "root:\n  value: !Rpy\n    deg: [1.0, 2.0, 3.0]\n");
 }
 
+GTEST_TEST(RotationTest, Sample) {
+  constexpr const char* const yaml_data = R"""(
+  value: !Rpy { deg: !UniformVector { min: [0, 10, 20], max: [30, 40, 50] } }
+  )""";
+  const auto rotation = LoadYamlString<Rotation>(yaml_data);
+  drake::RandomGenerator generator(0);
+  const RollPitchYawd sample{rotation.Sample(&generator)};
+  const Vector3d rpy = sample.vector() * 180 / M_PI;
+  EXPECT_GE(rpy[0], 0);
+  EXPECT_GE(rpy[1], 10);
+  EXPECT_GE(rpy[2], 20);
+  EXPECT_LE(rpy[0], 30);
+  EXPECT_LE(rpy[1], 40);
+  EXPECT_LE(rpy[2], 50);
+
+  const RollPitchYawd sample2{rotation.Sample(&generator)};
+  EXPECT_NE(sample.vector(), sample2.vector());
+}
+
 }  // namespace
 }  // namespace schema
 }  // namespace drake
diff --git a/geometry/BUILD.bazel b/geometry/BUILD.bazel
index 0c057b6cbbdf..4fa6cca2470f 100644
--- a/geometry/BUILD.bazel
+++ b/geometry/BUILD.bazel
@@ -962,6 +962,13 @@ drake_cc_googletest(
     ],
 )
 
+drake_cc_googletest(
+    name = "geometry_roles_test",
+    deps = [
+        ":geometry_roles",
+    ],
+)
+
 drake_cc_googletest(
     name = "geometry_version_test",
     deps = [
diff --git a/geometry/geometry_roles.cc b/geometry/geometry_roles.cc
index 04dea0017292..4034ca747c2d 100644
--- a/geometry/geometry_roles.cc
+++ b/geometry/geometry_roles.cc
@@ -5,10 +5,19 @@
 namespace drake {
 namespace geometry {
 
+ProximityProperties::ProximityProperties(const GeometryProperties& other)
+    : GeometryProperties(other) {}
+
 ProximityProperties::~ProximityProperties() = default;
 
+PerceptionProperties::PerceptionProperties(const GeometryProperties& other)
+    : GeometryProperties(other) {}
+
 PerceptionProperties::~PerceptionProperties() = default;
 
+IllustrationProperties::IllustrationProperties(const GeometryProperties& other)
+    : GeometryProperties(other) {}
+
 IllustrationProperties::~IllustrationProperties() = default;
 
 std::string to_string(const Role& role) {
diff --git a/geometry/geometry_roles.h b/geometry/geometry_roles.h
index d11948fca1d7..c39d4d370401 100644
--- a/geometry/geometry_roles.h
+++ b/geometry/geometry_roles.h
@@ -142,6 +142,17 @@ namespace geometry {
  type of role that it depends on, and the properties (if any) associated with
  that role that it requires/prefers.
 
+ There are times where different roles may have common properties (e.g., when
+ visualizing proximity geometries, we can specify their appearance in the
+ visualizer, or the appearance of a geometry should be the same for both
+ perception and illustration roles). To ease the sharing of these property
+ values, one set of properties can be instantiated as a copy of any other
+ set of geometry properties -- regardless of role. Doing so indiscriminately
+ may introduce meaningless properties, so use this power judiciously. A
+ property would be meaningless if there is no consumer that would use it. This
+ isn't an error, but it does mean that property values would be copied and
+ persisted without value.
+
  Next topic: @ref proximity_queries  */
 
 /** The set of properties for geometry used in a _proximity_ role.
@@ -155,8 +166,8 @@ namespace geometry {
 class ProximityProperties final : public GeometryProperties {
  public:
   DRAKE_DEFAULT_COPY_AND_MOVE_AND_ASSIGN(ProximityProperties);
-  // TODO(SeanCurtis-TRI): Should this have the physical properties built in?
   ProximityProperties() = default;
+  explicit ProximityProperties(const GeometryProperties& other);
   ~ProximityProperties() final;
 };
 
@@ -168,8 +179,8 @@ class ProximityProperties final : public GeometryProperties {
 class PerceptionProperties final : public GeometryProperties {
  public:
   DRAKE_DEFAULT_COPY_AND_MOVE_AND_ASSIGN(PerceptionProperties);
-  // TODO(SeanCurtis-TRI): Should this have a render label built in?
   PerceptionProperties() = default;
+  explicit PerceptionProperties(const GeometryProperties& other);
   ~PerceptionProperties() final;
 };
 
@@ -182,6 +193,7 @@ class IllustrationProperties final : public GeometryProperties {
  public:
   DRAKE_DEFAULT_COPY_AND_MOVE_AND_ASSIGN(IllustrationProperties);
   IllustrationProperties() = default;
+  explicit IllustrationProperties(const GeometryProperties& other);
   ~IllustrationProperties() final;
 };
 
diff --git a/geometry/optimization/BUILD.bazel b/geometry/optimization/BUILD.bazel
index 998d016a5c0a..f7e4802b3c69 100644
--- a/geometry/optimization/BUILD.bazel
+++ b/geometry/optimization/BUILD.bazel
@@ -201,6 +201,7 @@ drake_cc_library(
         "//solvers:get_program_type",
         "//solvers:mathematical_program_result",
         "//solvers:mosek_solver",
+        "//solvers:solve",
         "//solvers:solver_interface",
     ],
 )
diff --git a/geometry/optimization/graph_of_convex_sets.cc b/geometry/optimization/graph_of_convex_sets.cc
index e07e9c725edb..d9ff373598ca 100644
--- a/geometry/optimization/graph_of_convex_sets.cc
+++ b/geometry/optimization/graph_of_convex_sets.cc
@@ -13,12 +13,14 @@
 
 #include <fmt/format.h>
 
+#include "drake/common/parallelism.h"
 #include "drake/math/quadratic_form.h"
 #include "drake/solvers/choose_best_solver.h"
 #include "drake/solvers/create_constraint.h"
 #include "drake/solvers/create_cost.h"
 #include "drake/solvers/get_program_type.h"
 #include "drake/solvers/mosek_solver.h"
+#include "drake/solvers/solve.h"
 
 namespace drake {
 namespace geometry {
@@ -55,6 +57,7 @@ using solvers::ProgramType;
 using solvers::QuadraticCost;
 using solvers::RotatedLorentzConeConstraint;
 using solvers::SolutionResult;
+using solvers::SolveInParallel;
 using solvers::VariableRefList;
 using solvers::VectorXDecisionVariable;
 using solvers::internal::CreateBinding;
@@ -63,25 +66,6 @@ using symbolic::Variable;
 using symbolic::Variables;
 
 namespace {
-MathematicalProgramResult SolvePreprocessingProgram(
-    const MathematicalProgram& prog, const GraphOfConvexSetsOptions& options) {
-  MathematicalProgramResult result;
-  solvers::SolverOptions preprocessing_solver_options =
-      options.preprocessing_solver_options.value_or(options.solver_options);
-  if (options.preprocessing_solver) {
-    options.preprocessing_solver->Solve(prog, {}, preprocessing_solver_options,
-                                        &result);
-  } else if (options.solver) {
-    options.solver->Solve(prog, {}, preprocessing_solver_options, &result);
-  } else {
-    solvers::SolverId solver_id = solvers::ChooseBestSolver(prog);
-    auto solver = solvers::MakeSolver(solver_id);
-    DRAKE_DEMAND(solver != nullptr);
-    solver->Solve(prog, {}, preprocessing_solver_options, &result);
-  }
-  return result;
-}
-
 MathematicalProgramResult SolveMainProgram(
     const MathematicalProgram& prog, const GraphOfConvexSetsOptions& options) {
   MathematicalProgramResult result;
@@ -688,60 +672,35 @@ std::string GraphOfConvexSets::GetGraphvizString(
   return graphviz.str();
 }
 
-// Implements the preprocessing scheme put forth in Appendix A.2 of
-// "Motion Planning around Obstacles with Convex Optimization":
-// https://arxiv.org/abs/2205.04422
-std::set<EdgeId> GraphOfConvexSets::PreprocessShortestPath(
-    VertexId source_id, VertexId target_id,
-    const GraphOfConvexSetsOptions& options) const {
-  if (vertices_.find(source_id) == vertices_.end()) {
-    throw std::runtime_error(fmt::format(
-        "Source vertex {} is not a vertex in this GraphOfConvexSets.",
-        source_id));
-  }
-  if (vertices_.find(target_id) == vertices_.end()) {
-    throw std::runtime_error(fmt::format(
-        "Target vertex {} is not a vertex in this GraphOfConvexSets.",
-        target_id));
-  }
-
-  std::map<VertexId, std::vector<int>> incoming_edges;
-  std::map<VertexId, std::vector<int>> outgoing_edges;
-  std::set<EdgeId> unusable_edges;
-
-  int edge_count = 0;
-  for (const auto& [edge_id, e] : edges_) {
-    // Turn off edges into source or out of target
-    if (e->v().id() == source_id || e->u().id() == target_id) {
-      unusable_edges.insert(edge_id);
-    } else {
-      outgoing_edges[e->u().id()].push_back(edge_count);
-      incoming_edges[e->v().id()].push_back(edge_count);
-    }
-
-    edge_count++;
-  }
-
+copyable_unique_ptr<MathematicalProgram>
+GraphOfConvexSets::ConstructPreprocessingProgram(
+    EdgeId edge_id, const std::map<VertexId, std::vector<int>>& incoming_edges,
+    const std::map<VertexId, std::vector<int>>& outgoing_edges,
+    VertexId source_id, VertexId target_id) const {
+  const auto& e = edges_.at(edge_id);
   int nE = edges_.size();
-
-  // Given an edge (u,v) check if a path from source to u and another from v to
-  // target exist without sharing edges.
-  MathematicalProgram prog;
+  copyable_unique_ptr<MathematicalProgram> prog(MathematicalProgram{});
 
   // Flow for each edge is between 0 and 1 for both paths.
-  VectorXDecisionVariable f = prog.NewContinuousVariables(nE, "flow_su");
+  VectorXDecisionVariable f = prog->NewContinuousVariables(nE, "flow_su");
   Binding<solvers::BoundingBoxConstraint> f_limits =
-      prog.AddBoundingBoxConstraint(0, 1, f);
-  VectorXDecisionVariable g = prog.NewContinuousVariables(nE, "flow_vt");
+      prog->AddBoundingBoxConstraint(0, 1, f);
+  VectorXDecisionVariable g = prog->NewContinuousVariables(nE, "flow_vt");
   Binding<solvers::BoundingBoxConstraint> g_limits =
-      prog.AddBoundingBoxConstraint(0, 1, g);
+      prog->AddBoundingBoxConstraint(0, 1, g);
 
   std::map<VertexId, Binding<LinearEqualityConstraint>> conservation_f;
   std::map<VertexId, Binding<LinearEqualityConstraint>> conservation_g;
   std::map<VertexId, Binding<LinearConstraint>> degree;
   for (const auto& [vertex_id, v] : vertices_) {
-    std::vector<int> Ev_in = incoming_edges[vertex_id];
-    std::vector<int> Ev_out = outgoing_edges[vertex_id];
+    auto maybe_Ev_in = incoming_edges.find(vertex_id);
+    std::vector<int> Ev_in = maybe_Ev_in != incoming_edges.end()
+                                 ? maybe_Ev_in->second
+                                 : std::vector<int>{};
+    auto maybe_Ev_out = outgoing_edges.find(vertex_id);
+    std::vector<int> Ev_out = maybe_Ev_out != outgoing_edges.end()
+                                  ? maybe_Ev_out->second
+                                  : std::vector<int>{};
     std::vector<int> Ev = Ev_in;
     Ev.insert(Ev.end(), Ev_out.begin(), Ev_out.end());
 
@@ -759,19 +718,19 @@ std::set<EdgeId> GraphOfConvexSets::PreprocessShortestPath(
       // Conservation of flow for f: ∑ f_in - ∑ f_out = -δ(is_source).
       if (vertex_id == source_id) {
         conservation_f.insert(
-            {vertex_id, prog.AddLinearEqualityConstraint(A_flow, -1, fv)});
+            {vertex_id, prog->AddLinearEqualityConstraint(A_flow, -1, fv)});
       } else {
         conservation_f.insert(
-            {vertex_id, prog.AddLinearEqualityConstraint(A_flow, 0, fv)});
+            {vertex_id, prog->AddLinearEqualityConstraint(A_flow, 0, fv)});
       }
 
       // Conservation of flow for g: ∑ g_in - ∑ g_out = δ(is_target).
       if (vertex_id == target_id) {
         conservation_g.insert(
-            {vertex_id, prog.AddLinearEqualityConstraint(A_flow, 1, gv)});
+            {vertex_id, prog->AddLinearEqualityConstraint(A_flow, 1, gv)});
       } else {
         conservation_g.insert(
-            {vertex_id, prog.AddLinearEqualityConstraint(A_flow, 0, gv)});
+            {vertex_id, prog->AddLinearEqualityConstraint(A_flow, 0, gv)});
       }
     }
 
@@ -785,72 +744,145 @@ std::set<EdgeId> GraphOfConvexSets::PreprocessShortestPath(
         fgin(Ev_in.size() + ii) = g(Ev_in[ii]);
       }
       degree.insert(
-          {vertex_id, prog.AddLinearConstraint(A_degree, 0, 1, fgin)});
+          {vertex_id, prog->AddLinearConstraint(A_degree, 0, 1, fgin)});
     }
   }
 
-  for (const auto& [edge_id, e] : edges_) {
-    if (unusable_edges.contains(edge_id)) {
-      continue;
-    }
+  // Update bounds of conservation of flow:
+  // ∑ f_in,u - ∑ f_out,u = 1 - δ(is_source).
+  if (e->u().id() == source_id) {
+    f_limits.evaluator()->set_bounds(VectorXd::Zero(nE), VectorXd::Zero(nE));
+    conservation_f.at(e->u().id())
+        .evaluator()
+        ->set_bounds(Vector1d(0), Vector1d(0));
+  } else {
+    conservation_f.at(e->u().id())
+        .evaluator()
+        ->set_bounds(Vector1d(1), Vector1d(1));
+  }
+  // ∑ g_in,v - ∑ f_out,v = δ(is_target) - 1.
+  if (e->v().id() == target_id) {
+    g_limits.evaluator()->set_bounds(VectorXd::Zero(nE), VectorXd::Zero(nE));
+    conservation_g.at(e->v().id())
+        .evaluator()
+        ->set_bounds(Vector1d(0), Vector1d(0));
+  } else {
+    conservation_g.at(e->v().id())
+        .evaluator()
+        ->set_bounds(Vector1d(-1), Vector1d(-1));
+  }
 
-    // Update bounds of conservation of flow:
-    // ∑ f_in,u - ∑ f_out,u = 1 - δ(is_source).
-    if (e->u().id() == source_id) {
-      f_limits.evaluator()->set_bounds(VectorXd::Zero(nE), VectorXd::Zero(nE));
-      conservation_f.at(e->u().id())
-          .evaluator()
-          ->set_bounds(Vector1d(0), Vector1d(0));
-    } else {
-      conservation_f.at(e->u().id())
-          .evaluator()
-          ->set_bounds(Vector1d(1), Vector1d(1));
-    }
-    // ∑ g_in,v - ∑ f_out,v = δ(is_target) - 1.
-    if (e->v().id() == target_id) {
-      g_limits.evaluator()->set_bounds(VectorXd::Zero(nE), VectorXd::Zero(nE));
-      conservation_g.at(e->v().id())
-          .evaluator()
-          ->set_bounds(Vector1d(0), Vector1d(0));
+  // Update bounds of degree constraints:
+  // ∑ f_in,v + ∑ g_in,v = 0.
+  if (degree.contains(e->v().id())) {
+    degree.at(e->v().id()).evaluator()->set_bounds(Vector1d(0), Vector1d(0));
+  }
+
+  return prog;
+}
+
+// Implements the preprocessing scheme put forth in Appendix A.2 of
+// "Motion Planning around Obstacles with Convex Optimization":
+// https://arxiv.org/abs/2205.04422
+std::set<EdgeId> GraphOfConvexSets::PreprocessShortestPath(
+    VertexId source_id, VertexId target_id,
+    const GraphOfConvexSetsOptions& options) const {
+  if (vertices_.find(source_id) == vertices_.end()) {
+    throw std::runtime_error(fmt::format(
+        "Source vertex {} is not a vertex in this GraphOfConvexSets.",
+        source_id));
+  }
+  if (vertices_.find(target_id) == vertices_.end()) {
+    throw std::runtime_error(fmt::format(
+        "Target vertex {} is not a vertex in this GraphOfConvexSets.",
+        target_id));
+  }
+
+  std::vector<EdgeId> edge_id_list;
+  std::map<VertexId, std::vector<int>> incoming_edges;
+  std::map<VertexId, std::vector<int>> outgoing_edges;
+  std::set<EdgeId> unusable_edges;
+
+  int edge_count = 0;
+  for (const auto& [edge_id, e] : edges_) {
+    // Turn off edges into source or out of target
+    if (e->v().id() == source_id || e->u().id() == target_id) {
+      unusable_edges.insert(edge_id);
     } else {
-      conservation_g.at(e->v().id())
-          .evaluator()
-          ->set_bounds(Vector1d(-1), Vector1d(-1));
+      outgoing_edges[e->u().id()].push_back(edge_count);
+      incoming_edges[e->v().id()].push_back(edge_count);
+
+      // Note: we only add the edge id to this list if we still need to check
+      // it.
+      edge_id_list.push_back(edge_id);
     }
 
-    // Update bounds of degree constraints:
-    // ∑ f_in,v + ∑ g_in,v = 0.
-    degree.at(e->v().id()).evaluator()->set_bounds(Vector1d(0), Vector1d(0));
+    edge_count++;
+  }
 
-    // Check if edge e = (u,v) could be on a path from start to goal.
-    auto result = SolvePreprocessingProgram(prog, options);
-    if (!result.is_success()) {
-      unusable_edges.insert(edge_id);
+  // edge_id_list is now the canonical list of edges we will check in the
+  // remainder of the function.
+  int nE = edge_id_list.size();
+
+  // TODO(cohnt): Rewrite with a parallel for loop where each thread creates and
+  // solves the preprocessing program, to avoid having to use batching together
+  // with SolveInParallel.
+
+  // Given an edge (u,v) check if a path from source to u and another from v to
+  // target exist without sharing edges.
+
+  int num_batches = 1 + (nE / options.preprocessing_parallel_batch_size);
+  for (int batch_idx = 0; batch_idx < num_batches; ++batch_idx) {
+    int this_batch_start =
+        batch_idx * options.preprocessing_parallel_batch_size;
+    int this_batch_end = std::min(
+        (batch_idx + 1) * options.preprocessing_parallel_batch_size, nE);
+    // TODO(cohnt): No longer use pointers here.
+    std::vector<copyable_unique_ptr<MathematicalProgram>> progs;
+    std::vector<EdgeId> idx_to_edge_id;
+
+    int this_batch_nE = this_batch_end - this_batch_start;
+    progs.reserve(this_batch_nE);
+    idx_to_edge_id.reserve(this_batch_nE);
+
+    for (int i = this_batch_start; i < this_batch_end; ++i) {
+      idx_to_edge_id.push_back(edge_id_list.at(i));
     }
 
-    // Reset constraint bounds.
-    if (e->u().id() == source_id) {
-      f_limits.evaluator()->set_bounds(VectorXd::Zero(nE), VectorXd::Ones(nE));
-      conservation_f.at(e->u().id())
-          .evaluator()
-          ->set_bounds(Vector1d(-1), Vector1d(-1));
-    } else {
-      conservation_f.at(e->u().id())
-          .evaluator()
-          ->set_bounds(Vector1d(0), Vector1d(0));
+    for (int i = 0; i < this_batch_nE; ++i) {
+      EdgeId edge_id = idx_to_edge_id.at(i);
+      progs.emplace_back(ConstructPreprocessingProgram(
+          edge_id, incoming_edges, outgoing_edges, source_id, target_id));
     }
-    if (e->v().id() == target_id) {
-      g_limits.evaluator()->set_bounds(VectorXd::Zero(nE), VectorXd::Ones(nE));
-      conservation_g.at(e->v().id())
-          .evaluator()
-          ->set_bounds(Vector1d(1), Vector1d(1));
+
+    // Check if edge e = (u,v) could be on a path from start to goal.
+    std::vector<const MathematicalProgram*> prog_ptrs(progs.size());
+    for (int i = 0; i < ssize(progs); ++i) {
+      prog_ptrs[i] = progs[i].get();
+    }
+    std::optional<solvers::SolverId> maybe_solver_id;
+    solvers::SolverOptions preprocessing_solver_options =
+        options.preprocessing_solver_options.value_or(options.solver_options);
+    if (options.preprocessing_solver) {
+      maybe_solver_id = options.preprocessing_solver->solver_id();
+    } else if (options.solver) {
+      maybe_solver_id = options.solver->solver_id();
     } else {
-      conservation_g.at(e->v().id())
-          .evaluator()
-          ->set_bounds(Vector1d(0), Vector1d(0));
+      maybe_solver_id = std::nullopt;
+    }
+
+    std::vector<MathematicalProgramResult> results = SolveInParallel(
+        prog_ptrs, nullptr, &preprocessing_solver_options, maybe_solver_id,
+        options.preprocessing_parallelism, false);
+
+    for (int i = 0; i < this_batch_nE; ++i) {
+      const auto& result = results.at(i);
+      if (!result.is_success()) {
+        unusable_edges.insert(idx_to_edge_id.at(i));
+      }
     }
-    degree.at(e->v().id()).evaluator()->set_bounds(Vector1d(0), Vector1d(1));
   }
+
   return unusable_edges;
 }
 
diff --git a/geometry/optimization/graph_of_convex_sets.h b/geometry/optimization/graph_of_convex_sets.h
index b404c3276c41..e6088bf35bb2 100644
--- a/geometry/optimization/graph_of_convex_sets.h
+++ b/geometry/optimization/graph_of_convex_sets.h
@@ -12,6 +12,7 @@
 #include <vector>
 
 #include "drake/common/eigen_types.h"
+#include "drake/common/parallelism.h"
 #include "drake/common/symbolic/expression.h"
 #include "drake/geometry/optimization/convex_set.h"
 #include "drake/solvers/mathematical_program_result.h"
@@ -34,6 +35,7 @@ struct GraphOfConvexSetsOptions {
     a->Visit(DRAKE_NVP(max_rounding_trials));
     a->Visit(DRAKE_NVP(flow_tolerance));
     a->Visit(DRAKE_NVP(rounding_seed));
+    a->Visit(DRAKE_NVP(preprocessing_parallel_batch_size));
     // N.B. We skip the DRAKE_NVP(solver), DRAKE_NVP(restriction_solver), and
     // DRAKE_NVP(preprocessing_solver), because it cannot be serialized.
     // TODO(#20967) Serialize the DRAKE_NVP(solver_options).
@@ -124,6 +126,13 @@ struct GraphOfConvexSetsOptions {
   optimization, but not from the many smaller preprocessing optimizations. */
   std::optional<solvers::SolverOptions> preprocessing_solver_options{
       std::nullopt};
+
+  /** Degree of parallelism to use when performing the preprocessing. */
+  Parallelism preprocessing_parallelism{Parallelism::Max()};
+
+  /** Set the maximum number of preprocessing programs that are constructed in
+   * memory at once. */
+  int preprocessing_parallel_batch_size{1000};
 };
 
 struct GcsGraphvizOptions {
@@ -855,6 +864,16 @@ class GraphOfConvexSets {
  private: /* Facilitates testing. */
   friend class PreprocessShortestPathTest;
 
+  // Modify prog so that it contains the variables and constraints of the
+  // preprocessing program for a given edge.
+  copyable_unique_ptr<solvers::MathematicalProgram>
+  ConstructPreprocessingProgram(
+      EdgeId edge_id,
+      const std::map<VertexId, std::vector<int>>& incoming_edges,
+
+      const std::map<VertexId, std::vector<int>>& outgoing_edges,
+      VertexId source_id, VertexId target_id) const;
+
   std::set<EdgeId> PreprocessShortestPath(
       VertexId source_id, VertexId target_id,
       const GraphOfConvexSetsOptions& options) const;
diff --git a/geometry/test/geometry_roles_test.cc b/geometry/test/geometry_roles_test.cc
new file mode 100644
index 000000000000..11435b4d73a7
--- /dev/null
+++ b/geometry/test/geometry_roles_test.cc
@@ -0,0 +1,44 @@
+#include "drake/geometry/geometry_roles.h"
+
+#include <string>
+
+#include <gtest/gtest.h>
+
+namespace drake {
+namespace geometry {
+namespace {
+
+// An instance of XProperties can be constructed from YProperties (the result is
+// that it simply copies all of the properties). Remember, that the derived
+// FooProperties classes add no functionality to GeometryProperties -- they are
+// merely a type distinction.
+GTEST_TEST(GeometryRoleTest, CopyFromOther) {
+  PerceptionProperties source;
+  source.AddProperty("test", "int", 10);
+  source.AddProperty("test", "string", "value");
+
+  const GeometryProperties& generic = source;
+
+  ProximityProperties proximity(generic);
+  EXPECT_EQ(proximity.GetProperty<int>("test", "int"),
+            source.GetProperty<int>("test", "int"));
+  EXPECT_EQ(proximity.GetProperty<std::string>("test", "string"),
+            source.GetProperty<std::string>("test", "string"));
+
+  IllustrationProperties illustration(generic);
+  EXPECT_EQ(illustration.GetProperty<int>("test", "int"),
+            source.GetProperty<int>("test", "int"));
+  EXPECT_EQ(illustration.GetProperty<std::string>("test", "string"),
+            source.GetProperty<std::string>("test", "string"));
+
+  // Proximity -> Perception.
+  PerceptionProperties perception(generic);
+  EXPECT_EQ(perception.GetProperty<int>("test", "int"),
+            source.GetProperty<int>("test", "int"));
+  EXPECT_EQ(perception.GetProperty<std::string>("test", "string"),
+            source.GetProperty<std::string>("test", "string"));
+}
+
+}  // namespace
+}  // namespace geometry
+}  // namespace drake
diff --git a/multibody/parsing/detail_sdf_geometry.cc b/multibody/parsing/detail_sdf_geometry.cc
index f2d11f6c94c6..36f806a9c598 100644
--- a/multibody/parsing/detail_sdf_geometry.cc
+++ b/multibody/parsing/detail_sdf_geometry.cc
@@ -35,6 +35,7 @@ using std::string;
 using drake::internal::DiagnosticPolicy;
 using geometry::GeometryInstance;
 using geometry::IllustrationProperties;
+using geometry::PerceptionProperties;
 using geometry::ProximityProperties;
 using math::RigidTransformd;
 
@@ -67,9 +68,8 @@ std::optional<T> GetChildElementValue(const SDFormatDiagnostic& diagnostic,
 
 }  // namespace
 
-std::optional<std::unique_ptr<geometry::Shape>> MakeShapeFromSdfGeometry(
-    const SDFormatDiagnostic& diagnostic,
-    const sdf::Geometry& sdf_geometry,
+std::unique_ptr<geometry::Shape> MakeShapeFromSdfGeometry(
+    const SDFormatDiagnostic& diagnostic, const sdf::Geometry& sdf_geometry,
     ResolveFilename resolve_filename) {
   // TODO(amcastro-tri): unit tests for different error paths are needed.
   const std::set<std::string> supported_geometry_elements{
@@ -104,10 +104,10 @@ std::optional<std::unique_ptr<geometry::Shape>> MakeShapeFromSdfGeometry(
             diagnostic, capsule_element, {"radius", "length"});
         std::optional<const double> radius =
             GetChildElementValue<double>(diagnostic, capsule_element, "radius");
-        if (!radius.has_value()) return std::nullopt;
+        if (!radius.has_value()) return nullptr;
         std::optional<const double> length =
             GetChildElementValue<double>(diagnostic, capsule_element, "length");
-        if (!length.has_value()) return std::nullopt;
+        if (!length.has_value()) return nullptr;
         return make_unique<geometry::Capsule>(*radius, *length);
       } else if (sdf_geometry.Element()->HasElement("drake:ellipsoid")) {
         const sdf::ElementPtr ellipsoid_element =
@@ -116,17 +116,17 @@ std::optional<std::unique_ptr<geometry::Shape>> MakeShapeFromSdfGeometry(
             diagnostic, ellipsoid_element, {"a", "b", "c"});
         std::optional<const double> a =
             GetChildElementValue<double>(diagnostic, ellipsoid_element, "a");
-        if (!a.has_value()) return std::nullopt;
+        if (!a.has_value()) return nullptr;
         std::optional<const double> b =
             GetChildElementValue<double>(diagnostic, ellipsoid_element, "b");
-        if (!b.has_value()) return std::nullopt;
+        if (!b.has_value()) return nullptr;
         std::optional<const double> c =
             GetChildElementValue<double>(diagnostic, ellipsoid_element, "c");
-        if (!c.has_value()) return std::nullopt;
+        if (!c.has_value()) return nullptr;
         return make_unique<geometry::Ellipsoid>(*a, *b, *c);
       }
 
-      return std::unique_ptr<geometry::Shape>(nullptr);
+      return nullptr;
     }
     case sdf::GeometryType::BOX: {
       const sdf::Box& shape = *sdf_geometry.BoxShape();
@@ -160,14 +160,17 @@ std::optional<std::unique_ptr<geometry::Shape>> MakeShapeFromSdfGeometry(
       DRAKE_DEMAND(mesh_element != nullptr);
       std::optional<std::string> mesh_uri =
         GetChildElementValue<std::string>(diagnostic, mesh_element, "uri");
-      if (!mesh_uri.has_value()) return std::nullopt;
+      // We don't register an error; this is a required element and the sdformat
+      // parsing should handle the case of this missing.
+      DRAKE_DEMAND(mesh_uri.has_value());
+      if (!mesh_uri.has_value()) return nullptr;
       const std::string file_name = resolve_filename(diagnostic, *mesh_uri);
       double scale = 1.0;
       if (mesh_element->HasElement("scale")) {
         std::optional<gz::math::Vector3d> scale_vector =
             GetChildElementValue<gz::math::Vector3d>(
                 diagnostic, mesh_element, "scale");
-        if (!scale_vector.has_value()) return std::nullopt;
+        if (!scale_vector.has_value()) return nullptr;
         // geometry::Mesh only supports isotropic scaling and therefore we
         // enforce it.
         if (!(scale_vector->X() == scale_vector->Y() &&
@@ -176,7 +179,7 @@ std::optional<std::unique_ptr<geometry::Shape>> MakeShapeFromSdfGeometry(
               "Drake meshes only support isotropic scaling. Therefore all "
               "three scaling factors must be exactly equal.";
           diagnostic.Error(mesh_element, std::move(message));
-          return std::nullopt;
+          return nullptr;
         }
         scale = scale_vector->X();
       }
@@ -212,11 +215,9 @@ std::optional<std::unique_ptr<geometry::Shape>> MakeShapeFromSdfGeometry(
 
 static constexpr char kAcceptingTag[] = "drake:accepting_renderer";
 
-std::optional<std::unique_ptr<GeometryInstance>>
-    MakeGeometryInstanceFromSdfVisual(
-        const SDFormatDiagnostic& diagnostic,
-        const sdf::Visual& sdf_visual, ResolveFilename resolve_filename,
-        const math::RigidTransformd& X_LG) {
+std::unique_ptr<GeometryInstance> MakeGeometryInstanceFromSdfVisual(
+    const SDFormatDiagnostic& diagnostic, const sdf::Visual& sdf_visual,
+    ResolveFilename resolve_filename, const math::RigidTransformd& X_LG) {
   const std::set<std::string> supported_visual_elements{
     "geometry",
     "material",
@@ -232,7 +233,7 @@ std::optional<std::unique_ptr<GeometryInstance>>
     // drake:capsule, before we can decide to return a null geometry.
     if (!sdf_geometry.Element()->HasElement("drake:capsule") &&
         !sdf_geometry.Element()->HasElement("drake:ellipsoid")) {
-      return std::unique_ptr<GeometryInstance>(nullptr);
+      return nullptr;
     }
   }
 
@@ -283,19 +284,25 @@ std::optional<std::unique_ptr<GeometryInstance>>
     }
   }
 
-  auto shape = MakeShapeFromSdfGeometry(
+  std::unique_ptr<geometry::Shape> shape = MakeShapeFromSdfGeometry(
       diagnostic, sdf_geometry, resolve_filename);
-  if (!shape.has_value()) return std::nullopt;
-  if (*shape == nullptr) {
-    return nullptr;
-  }
+  if (shape == nullptr) return nullptr;
+
   auto instance =
       make_unique<GeometryInstance>(X_LC, std::move(*shape), sdf_visual.Name());
   std::optional<IllustrationProperties> illustration_properties =
       MakeVisualPropertiesFromSdfVisual(
           diagnostic, sdf_visual, resolve_filename);
-  if (!illustration_properties.has_value()) return std::nullopt;
-  instance->set_illustration_properties(*illustration_properties);
+  if (!illustration_properties.has_value()) return nullptr;
+  instance->set_perception_properties(
+      PerceptionProperties(*illustration_properties));
+  if (illustration_properties->HasProperty("renderer", "accepting")) {
+    // We stashed the perception property in the illustration properties. It has
+    // been copied into the perception properties, so we can remove it from here
+    // now.
+    illustration_properties->RemoveProperty("renderer", "accepting");
+  }
+  instance->set_illustration_properties(*std::move(illustration_properties));
   return instance;
 }
 
@@ -371,11 +378,10 @@ std::optional<IllustrationProperties> MakeVisualPropertiesFromSdfVisual(
     add_property("emissive", &properties);
   }
 
-  // TODO(SeanCurtis-TRI): Including this property in illustration properties is
-  //  a bit misleading; it isn't used by illustration, but we're not currently
-  //  parsing illustration and perception properties separately. So, we stash
-  //  them in the illustration properties relying on it to be ignored by
-  //  illustration consumers but copied over to the perception properties.
+  // We're putting this perception property into the illustration properties.
+  // We'll create the PerceptionProperties from these illustration properties
+  // and simply remove this property from the illustration properties as clean
+  // up.
   if (visual_element->HasElement(kAcceptingTag)) {
     set<string> accepting_names;
     sdf::ElementPtr accepting = visual_element->GetElement(kAcceptingTag);
diff --git a/multibody/parsing/detail_sdf_geometry.h b/multibody/parsing/detail_sdf_geometry.h
index 68855789740d..39e2aa81b9ef 100644
--- a/multibody/parsing/detail_sdf_geometry.h
+++ b/multibody/parsing/detail_sdf_geometry.h
@@ -28,23 +28,26 @@ using ResolveFilename = std::function<std::string (
 /* Given an sdf::Geometry object representing a <geometry> element from an SDF
  file, this method makes a new drake::geometry::Shape object from this
  specification.
- If no recognizable geometry is specified, nullptr is returned. If the geometry
- is recognized, but malformed, emits an error. When the error policy is set to
- not throw it returns std::nullopt. */
-std::optional<std::unique_ptr<geometry::Shape>> MakeShapeFromSdfGeometry(
-    const SDFormatDiagnostic& diagnostic,
-    const sdf::Geometry& sdf_geometry,
+ If no recognizable geometry is specified or the geometry is recognized but
+ malformed, nullptr is returned. In the case of a malformed specification, an
+ error is also emitted on `diagnostic`. */
+std::unique_ptr<geometry::Shape> MakeShapeFromSdfGeometry(
+    const SDFormatDiagnostic& diagnostic, const sdf::Geometry& sdf_geometry,
     ResolveFilename resolve_filename);
 
 /* Given an sdf::Visual object representing a <visual> element from an SDF
  file, this method makes a new drake::geometry::GeometryInstance object from
- this specification at a pose `X_LG` relatve to its parent link.
- This method returns nullptr when the given SDF specification corresponds
- to an uninterpreted geometry type:
- - `sdf::GeometryType::EMPTY` (`<empty/>` SDF tag.)
- - `sdf::GeometryType::HEIGHTMAP` (`<heightmap/>` SDF tag.)
- If the geometry is malformed, emits an error. When the error policy is not
- set to throw it returns an std::nullopt.
+ this specification at a pose `X_LG` relative to its parent link.
+
+ This method returns null when:
+   1. the given SDF specification corresponds to an uninterpreted geometry type:
+      - `sdf::GeometryType::EMPTY` (`<empty/>` SDF tag.)
+      - `sdf::GeometryType::HEIGHTMAP` (`<heightmap/>` SDF tag.)
+   2. the <visual> has had both of its Drake roles disabled.
+   3. the <visual> specification was in some way malformed.
+
+ In the case of a malformed specification, an error is also emitted to
+ `diagnostic`.
 
  <!-- TODO(SeanCurtis-TRI): Ultimately, a module for what we parse should be
   written outside of this _internal_ namespace. This should go there and
@@ -74,11 +77,10 @@ std::optional<std::unique_ptr<geometry::Shape>> MakeShapeFromSdfGeometry(
 
  This feature is one way to provide multiple visual representations of a body.
  */
-std::optional<std::unique_ptr<geometry::GeometryInstance>>
-    MakeGeometryInstanceFromSdfVisual(
-        const SDFormatDiagnostic& diagnostic,
-        const sdf::Visual& sdf_visual, ResolveFilename resolve_filename,
-        const math::RigidTransformd& X_LG);
+std::unique_ptr<geometry::GeometryInstance> MakeGeometryInstanceFromSdfVisual(
+    const SDFormatDiagnostic& diagnostic, const sdf::Visual& sdf_visual,
+    ResolveFilename resolve_filename, const math::RigidTransformd& X_LG);
+
 
 /* Extracts the material properties from the given sdf::Visual object.
  The sdf::Visual object represents a corresponding <visual> tag from an SDF
diff --git a/multibody/parsing/detail_sdf_parser.cc b/multibody/parsing/detail_sdf_parser.cc
index 9af9df0eaffa..b25b24eeaabd 100644
--- a/multibody/parsing/detail_sdf_parser.cc
+++ b/multibody/parsing/detail_sdf_parser.cc
@@ -1099,24 +1099,20 @@ std::optional<std::vector<LinkInfo>> AddLinksFromSpecification(
 
         const RigidTransformd X_LG = ResolveRigidTransform(
             diagnostic, sdf_visual.SemanticPose());
-        std::optional<unique_ptr<GeometryInstance>> geometry_instance =
+        unique_ptr<GeometryInstance> geometry_instance =
             MakeGeometryInstanceFromSdfVisual(
                 diagnostic, sdf_visual, resolve_filename, X_LG);
-        if (!geometry_instance.has_value()) return std::nullopt;
-        // We check for nullptr in case someone decided to specify an SDF
-        // <empty/> geometry.
-        if (*geometry_instance) {
-          // The parsing should *always* produce an IllustrationProperties
-          // instance, even if it is empty.
-          DRAKE_DEMAND(
-              (*geometry_instance)->illustration_properties() != nullptr);
-
-          plant->RegisterVisualGeometry(
-              body, (*geometry_instance)->pose(),
-              (*geometry_instance)->shape(),
-              (*geometry_instance)->name(),
-              *(*geometry_instance)->illustration_properties());
-        }
+        // No instance may simply mean there was a visual we should skip and we
+        // move on to the next. If there is a _real_ problem, we assume an error
+        // was reported to diagnostic (and it responds appropriately).
+        if (geometry_instance == nullptr) continue;
+
+        // The instance should be pre-configured to have both illustration and
+        // perception properties.
+        DRAKE_DEMAND(geometry_instance->illustration_properties() != nullptr &&
+                     geometry_instance->perception_properties() != nullptr);
+
+        plant->RegisterVisualGeometry(body, std::move(geometry_instance));
       }
 
       for (uint64_t collision_index = 0;
diff --git a/multibody/parsing/test/detail_sdf_geometry_test.cc b/multibody/parsing/test/detail_sdf_geometry_test.cc
index c50df62fe6f0..428868b3be11 100644
--- a/multibody/parsing/test/detail_sdf_geometry_test.cc
+++ b/multibody/parsing/test/detail_sdf_geometry_test.cc
@@ -195,16 +195,8 @@ std::string NoopResolveFilename(const SDFormatDiagnostic&,
 
 class SceneGraphParserDetail : public test::DiagnosticPolicyTestBase {
  public:
-  SceneGraphParserDetail() {
-    // Don't let warnings leak into spdlog; tests should always specifically
-    // handle any warnings that appear.
-    diagnostic_policy_.SetActionForWarnings(
-        &DiagnosticPolicy::ErrorDefaultAction);
-    RecordErrors();
-  }
-
   // Wraps a function under test with helpful defaults.
-  std::optional<std::unique_ptr<geometry::Shape>> MakeShapeFromSdfGeometry(
+  std::unique_ptr<geometry::Shape> MakeShapeFromSdfGeometry(
       const sdf::Geometry& sdf_geometry,
       const ResolveFilename& resolve_filename = &NoopResolveFilename) {
     return internal::MakeShapeFromSdfGeometry(
@@ -231,10 +223,8 @@ class SceneGraphParserDetail : public test::DiagnosticPolicyTestBase {
 TEST_F(SceneGraphParserDetail, MakeEmptyFromSdfGeometry) {
   unique_ptr<sdf::Geometry> sdf_geometry =
       MakeSdfGeometryFromString("<empty/>");
-  std::optional<unique_ptr<Shape>> shape =
-      MakeShapeFromSdfGeometry(*sdf_geometry);
-  EXPECT_TRUE(shape.has_value());
-  EXPECT_EQ(*shape, nullptr);
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  EXPECT_EQ(shape, nullptr);
 }
 
 // Verify MakeShapeFromSdfGeometry can make a box from an sdf::Geometry.
@@ -243,10 +233,8 @@ TEST_F(SceneGraphParserDetail, MakeBoxFromSdfGeometry) {
       "<box>"
       "  <size>1.0 2.0 3.0</size>"
       "</box>");
-  std::optional<unique_ptr<Shape>> shape =
-      MakeShapeFromSdfGeometry(*sdf_geometry);
-  EXPECT_TRUE(shape.has_value());
-  const Box* box = dynamic_cast<const Box*>(shape->get());
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  const Box* box = dynamic_cast<const Box*>(shape.get());
   ASSERT_NE(box, nullptr);
   EXPECT_EQ(box->size(), Vector3d(1.0, 2.0, 3.0));
 }
@@ -261,10 +249,8 @@ TEST_F(SceneGraphParserDetail, MakeDrakeCapsuleFromSdfGeometry) {
       "  <radius>0.5</radius>"
       "  <length>1.2</length>"
       "</drake:capsule>");
-  std::optional<unique_ptr<Shape>> shape =
-      MakeShapeFromSdfGeometry(*sdf_geometry);
-  EXPECT_TRUE(shape.has_value());
-  const Capsule* capsule = dynamic_cast<const Capsule*>(shape->get());
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  const Capsule* capsule = dynamic_cast<const Capsule*>(shape.get());
   ASSERT_NE(capsule, nullptr);
   EXPECT_EQ(capsule->radius(), 0.5);
   EXPECT_EQ(capsule->length(), 1.2);
@@ -278,9 +264,9 @@ TEST_F(SceneGraphParserDetail, CheckInvalidDrakeCapsules) {
       "<drake:capsule>"
       "  <length>1.2</length>"
       "</drake:capsule>");
-  std::optional<unique_ptr<Shape>> shape_no_radius =
+  unique_ptr<Shape> shape_no_radius =
       MakeShapeFromSdfGeometry(*no_radius_geometry);
-  EXPECT_FALSE(shape_no_radius.has_value());
+  EXPECT_EQ(shape_no_radius, nullptr);
   EXPECT_THAT(FormatFirstError(), ::testing::MatchesRegex(
       ".*Element <radius> is required within element <drake:capsule>."));
   ClearDiagnostics();
@@ -289,9 +275,9 @@ TEST_F(SceneGraphParserDetail, CheckInvalidDrakeCapsules) {
       "<drake:capsule>"
       "  <radius>0.5</radius>"
       "</drake:capsule>");
-  std::optional<unique_ptr<Shape>> shape_no_length =
+  unique_ptr<Shape> shape_no_length =
       MakeShapeFromSdfGeometry(*no_length_geometry);
-  EXPECT_FALSE(shape_no_length.has_value());
+  EXPECT_EQ(shape_no_length, nullptr);
   EXPECT_THAT(FormatFirstError(), ::testing::MatchesRegex(
       ".*Element <length> is required within element <drake:capsule>."));
   ClearDiagnostics();
@@ -304,10 +290,8 @@ TEST_F(SceneGraphParserDetail, MakeCapsuleFromSdfGeometry) {
       "  <radius>0.5</radius>"
       "  <length>1.2</length>"
       "</capsule>");
-  std::optional<unique_ptr<Shape>> shape =
-      MakeShapeFromSdfGeometry(*sdf_geometry);
-  EXPECT_TRUE(shape.has_value());
-  const Capsule* capsule = dynamic_cast<const Capsule*>(shape->get());
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  const Capsule* capsule = dynamic_cast<const Capsule*>(shape.get());
   ASSERT_NE(capsule, nullptr);
   EXPECT_EQ(capsule->radius(), 0.5);
   EXPECT_EQ(capsule->length(), 1.2);
@@ -320,10 +304,8 @@ TEST_F(SceneGraphParserDetail, MakeCylinderFromSdfGeometry) {
       "  <radius>0.5</radius>"
       "  <length>1.2</length>"
       "</cylinder>");
-  std::optional<unique_ptr<Shape>> shape =
-      MakeShapeFromSdfGeometry(*sdf_geometry);
-  EXPECT_TRUE(shape.has_value());
-  const Cylinder* cylinder = dynamic_cast<const Cylinder*>(shape->get());
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  const Cylinder* cylinder = dynamic_cast<const Cylinder*>(shape.get());
   ASSERT_NE(cylinder, nullptr);
   EXPECT_EQ(cylinder->radius(), 0.5);
   EXPECT_EQ(cylinder->length(), 1.2);
@@ -340,10 +322,8 @@ TEST_F(SceneGraphParserDetail, MakeDrakeEllipsoidFromSdfGeometry) {
       "  <b>1.2</b>"
       "  <c>0.9</c>"
       "</drake:ellipsoid>");
-  std::optional<unique_ptr<Shape>> shape =
-      MakeShapeFromSdfGeometry(*sdf_geometry);
-  EXPECT_TRUE(shape.has_value());
-  const Ellipsoid* ellipsoid = dynamic_cast<const Ellipsoid*>(shape->get());
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  const Ellipsoid* ellipsoid = dynamic_cast<const Ellipsoid*>(shape.get());
   ASSERT_NE(ellipsoid, nullptr);
   EXPECT_EQ(ellipsoid->a(), 0.5);
   EXPECT_EQ(ellipsoid->b(), 1.2);
@@ -359,7 +339,8 @@ TEST_F(SceneGraphParserDetail, CheckInvalidEllipsoids) {
       "  <b>1.2</b>"
       "  <c>0.9</c>"
       "</drake:ellipsoid>");
-  MakeShapeFromSdfGeometry(*no_a_geometry);
+  unique_ptr<Shape> shape_no_a = MakeShapeFromSdfGeometry(*no_a_geometry);
+  EXPECT_EQ(shape_no_a, nullptr);
   EXPECT_THAT(FormatFirstError(), ::testing::MatchesRegex(
       ".*Element <a> is required within element <drake:ellipsoid>."));
   ClearDiagnostics();
@@ -369,7 +350,8 @@ TEST_F(SceneGraphParserDetail, CheckInvalidEllipsoids) {
       "  <a>0.5</a>"
       "  <c>0.9</c>"
       "</drake:ellipsoid>");
-  MakeShapeFromSdfGeometry(*no_b_geometry);
+  unique_ptr<Shape> shape_no_b = MakeShapeFromSdfGeometry(*no_b_geometry);
+  EXPECT_EQ(shape_no_b, nullptr);
   EXPECT_THAT(FormatFirstError(), ::testing::MatchesRegex(
       ".*Element <b> is required within element <drake:ellipsoid>."));
   ClearDiagnostics();
@@ -379,7 +361,8 @@ TEST_F(SceneGraphParserDetail, CheckInvalidEllipsoids) {
       "  <a>0.5</a>"
       "  <b>1.2</b>"
       "</drake:ellipsoid>");
-  MakeShapeFromSdfGeometry(*no_c_geometry);
+  unique_ptr<Shape> shape_no_c = MakeShapeFromSdfGeometry(*no_c_geometry);
+  EXPECT_EQ(shape_no_c, nullptr);
   EXPECT_THAT(FormatFirstError(), ::testing::MatchesRegex(
       ".*Element <c> is required within element <drake:ellipsoid>."));
   ClearDiagnostics();
@@ -392,9 +375,8 @@ TEST_F(SceneGraphParserDetail, MakeEllipsoidFromSdfGeometry) {
       "<ellipsoid>"
       "  <radii>0.5 1.2 0.9</radii>"
       "</ellipsoid>");
-  std::optional<unique_ptr<Shape>> shape =
-      MakeShapeFromSdfGeometry(*sdf_geometry);
-  const Ellipsoid* ellipsoid = dynamic_cast<const Ellipsoid*>(shape->get());
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  const Ellipsoid* ellipsoid = dynamic_cast<const Ellipsoid*>(shape.get());
   ASSERT_NE(ellipsoid, nullptr);
   EXPECT_EQ(ellipsoid->a(), 0.5);
   EXPECT_EQ(ellipsoid->b(), 1.2);
@@ -407,9 +389,8 @@ TEST_F(SceneGraphParserDetail, MakeSphereFromSdfGeometry) {
       "<sphere>"
       "  <radius>0.5</radius>"
       "</sphere>");
-  std::optional<unique_ptr<Shape>> shape =
-      MakeShapeFromSdfGeometry(*sdf_geometry);
-  const Sphere* sphere = dynamic_cast<const Sphere*>(shape->get());
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  const Sphere* sphere = dynamic_cast<const Sphere*>(shape.get());
   ASSERT_NE(sphere, nullptr);
   EXPECT_EQ(sphere->radius(), 0.5);
 }
@@ -423,9 +404,8 @@ TEST_F(SceneGraphParserDetail, MakeHalfSpaceFromSdfGeometry) {
       "</plane>");
   // MakeShapeFromSdfGeometry() ignores <normal> and <size> to create the
   // HalfSpace. Therefore we only verify it created the right object.
-  std::optional<unique_ptr<Shape>> shape =
-      MakeShapeFromSdfGeometry(*sdf_geometry);
-  EXPECT_TRUE(dynamic_cast<const HalfSpace*>(shape->get()) != nullptr);
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  EXPECT_TRUE(dynamic_cast<const HalfSpace*>(shape.get()) != nullptr);
 }
 
 // Verify MakeShapeFromSdfGeometry can make a mesh from an sdf::Geometry.
@@ -439,9 +419,8 @@ TEST_F(SceneGraphParserDetail, MakeMeshFromSdfGeometry) {
       "  <uri>" + absolute_file_path + "</uri>"
       "  <scale> 3 3 3 </scale>"
       "</mesh>");
-  std::optional<unique_ptr<Shape>> shape =
-      MakeShapeFromSdfGeometry(*sdf_geometry);
-  const Mesh* mesh = dynamic_cast<const Mesh*>(shape->get());
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  const Mesh* mesh = dynamic_cast<const Mesh*>(shape.get());
   ASSERT_NE(mesh, nullptr);
   ASSERT_TRUE(mesh->source().is_path());
   EXPECT_EQ(mesh->source().path(), absolute_file_path);
@@ -459,7 +438,8 @@ TEST_F(SceneGraphParserDetail, MakeMeshFromSdfGeometryIsotropicError) {
       "  <uri>" + absolute_file_path + "</uri>"
       "  <scale> 3 1 2 </scale>"
       "</mesh>");
-  MakeShapeFromSdfGeometry(*sdf_geometry);
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  EXPECT_EQ(shape, nullptr);
   EXPECT_THAT(FormatFirstError(), ::testing::MatchesRegex(
       ".*Drake meshes only support isotropic scaling. Therefore"
       " all three scaling factors must be exactly equal."));
@@ -475,9 +455,8 @@ TEST_F(SceneGraphParserDetail, MakeConvexFromSdfGeometry) {
       "  <uri>" + absolute_file_path + "</uri>"
       "  <scale> 3 3 3 </scale>"
       "</mesh>");
-  std::optional<unique_ptr<Shape>> shape =
-      MakeShapeFromSdfGeometry(*sdf_geometry);
-  const Convex* convex = dynamic_cast<const Convex*>(shape->get());
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  const Convex* convex = dynamic_cast<const Convex*>(shape.get());
   ASSERT_NE(convex, nullptr);
   EXPECT_TRUE(convex->source().is_path());
   EXPECT_EQ(convex->source().path(), absolute_file_path);
@@ -490,9 +469,8 @@ TEST_F(SceneGraphParserDetail, MakeHeightmapFromSdfGeometry) {
       "<heightmap>"
       "  <uri>/path/to/some/heightmap.png</uri>"
       "</heightmap>");
-  std::optional<unique_ptr<Shape>> shape =
-      MakeShapeFromSdfGeometry(*sdf_geometry);
-  EXPECT_EQ(*shape, nullptr);
+  unique_ptr<Shape> shape = MakeShapeFromSdfGeometry(*sdf_geometry);
+  EXPECT_EQ(shape, nullptr);
 }
 
 // Verify that MakeShapeFromSdfGeometry does nothing with a polyline.
@@ -509,8 +487,7 @@ TEST_F(SceneGraphParserDetail, MakePolylineFromSdfGeometry) {
       "</polyline>");
   std::optional<unique_ptr<Shape>> shape =
       MakeShapeFromSdfGeometry(*sdf_geometry);
-  EXPECT_TRUE(shape.has_value());
-  EXPECT_EQ(*shape, nullptr);
+  EXPECT_EQ(shape, nullptr);
 }
 
 // Verify MakeGeometryInstanceFromSdfVisual can make a GeometryInstance from an
@@ -529,12 +506,15 @@ TEST_F(SceneGraphParserDetail, MakeGeometryInstanceFromSdfVisual) {
       "  </geometry>"
       "</visual>");
 
-  std::optional<unique_ptr<GeometryInstance>> geometry_instance =
+  unique_ptr<GeometryInstance> geometry_instance =
       MakeGeometryInstanceFromSdfVisual(
           sdf_diagnostic_, *sdf_visual, NoopResolveFilename,
           ToRigidTransform(sdf_visual->RawPose()));
 
-  const RigidTransformd X_LC((*geometry_instance)->pose());
+  EXPECT_NE(geometry_instance->perception_properties(), nullptr);
+  EXPECT_NE(geometry_instance->illustration_properties(), nullptr);
+
+  const RigidTransformd X_LC(geometry_instance->pose());
 
   // These are the expected values as specified by the string above.
   const RollPitchYaw<double> expected_rpy(3.14, 6.28, 1.57);
@@ -548,6 +528,36 @@ TEST_F(SceneGraphParserDetail, MakeGeometryInstanceFromSdfVisual) {
                               kTolerance, MatrixCompareType::relative));
 }
 
+// Verify MakeGeometryInstanceFromSdfVisual() creates an instance such that only
+// the perception properties have the ("renderer", "accepting") property.
+TEST_F(SceneGraphParserDetail,
+       MakeGeometryInstanceFromSdfVisualAcceptingRenderer) {
+  unique_ptr<sdf::Visual> sdf_visual = MakeSdfVisualFromString(
+      "<visual name = 'some_link_visual'>"
+      "  <pose>1.0 2.0 3.0 3.14 6.28 1.57</pose>"
+      "  <geometry><sphere><radius>1.0</radius></sphere></geometry>"
+      "  <drake:accepting_renderer>renderer1</drake:accepting_renderer>"
+      "</visual>");
+
+  unique_ptr<GeometryInstance> geometry_instance =
+      MakeGeometryInstanceFromSdfVisual(
+          sdf_diagnostic_, *sdf_visual, NoopResolveFilename,
+          ToRigidTransform(sdf_visual->RawPose()));
+
+  ASSERT_NE(geometry_instance->perception_properties(), nullptr);
+  ASSERT_NE(geometry_instance->illustration_properties(), nullptr);
+
+  EXPECT_FALSE(geometry_instance->illustration_properties()->HasProperty(
+      "renderer", "accepting"));
+  EXPECT_TRUE(geometry_instance->perception_properties()->HasProperty(
+      "renderer", "accepting"));
+  const auto& names =
+      geometry_instance->perception_properties()
+          ->GetProperty<std::set<std::string>>("renderer", "accepting");
+  EXPECT_EQ(names.size(), 1);
+  EXPECT_TRUE(names.contains("renderer1"));
+}
+
 // Confirms the failure conditions for SDFormat. SceneGraph requirements on
 // geometry names are supposed to mirror the SDFormat behavior. If these tests
 // no longer fail, the requirements in SceneGraph should become more relaxed.
diff --git a/multibody/plant/multibody_plant.cc b/multibody/plant/multibody_plant.cc
index 1c1ba5384566..3d345c15caa1 100644
--- a/multibody/plant/multibody_plant.cc
+++ b/multibody/plant/multibody_plant.cc
@@ -938,45 +938,57 @@ geometry::GeometryId MultibodyPlant<T>::RegisterVisualGeometry(
     const RigidBody<T>& body, const math::RigidTransform<double>& X_BG,
     const geometry::Shape& shape, const std::string& name,
     const geometry::IllustrationProperties& properties) {
-  // TODO(SeanCurtis-TRI): Consider simply adding an interface that takes a
-  // unique pointer to an already instantiated GeometryInstance. This will
-  // require shuffling around a fair amount of code and should ultimately be
-  // supplanted by providing a cleaner interface between parsing MBP and SG
-  // elements.
   DRAKE_MBP_THROW_IF_FINALIZED();
   DRAKE_THROW_UNLESS(geometry_source_is_registered());
 
-  // TODO(amcastro-tri): Consider doing this after finalize so that we can
-  // register geometry that has a fixed path to world to the world body (i.e.,
-  // as anchored geometry).
-  GeometryId id = RegisterGeometry(
-      body, X_BG, shape, GetScopedName(*this, body.model_instance(), name));
-  scene_graph_->AssignRole(*source_id_, id, properties);
-
-  // TODO(SeanCurtis-TRI): Eliminate the automatic assignment of perception
-  //  and illustration in favor of a protocol that allows definition.
-  geometry::PerceptionProperties perception_props;
-  perception_props.AddProperty("label", "id", RenderLabel(body.index()));
-  if (properties.HasProperty("phong", "diffuse")) {
-    perception_props.AddProperty(
-        "phong", "diffuse",
-        properties.GetProperty<geometry::Rgba>("phong", "diffuse"));
-  }
-  if (properties.HasProperty("phong", "diffuse_map")) {
-    perception_props.AddProperty(
-        "phong", "diffuse_map",
-        properties.GetProperty<std::string>("phong", "diffuse_map"));
-  }
-  if (properties.HasProperty("renderer", "accepting")) {
-    perception_props.AddProperty(
-        "renderer", "accepting",
-        properties.GetProperty<std::set<std::string>>("renderer", "accepting"));
-  }
-  scene_graph_->AssignRole(*source_id_, id, perception_props);
+  // Note: the geometry name will be scoped in the subsequent call to
+  // RegisterVisualGeometry().
+  auto instance =
+      std::make_unique<geometry::GeometryInstance>(X_BG, shape, name);
+  instance->set_illustration_properties(properties);
+  instance->set_perception_properties(
+      geometry::PerceptionProperties(properties));
+
+  const std::optional<geometry::GeometryId> id =
+      RegisterVisualGeometry(body, std::move(instance));
+  // We assigned properties, so this must be defined.
+  DRAKE_DEMAND(id.has_value());
+
+  return *id;
+}
+
+template <typename T>
+geometry::GeometryId MultibodyPlant<T>::RegisterVisualGeometry(
+    const RigidBody<T>& body,
+    std::unique_ptr<geometry::GeometryInstance> geometry) {
+  DRAKE_THROW_UNLESS(geometry != nullptr);
+  DRAKE_MBP_THROW_IF_FINALIZED();
+  DRAKE_THROW_UNLESS(geometry_source_is_registered());
+
+  if (geometry->perception_properties() == nullptr &&
+      geometry->illustration_properties() == nullptr) {
+    geometry->set_illustration_properties(geometry::IllustrationProperties());
+    geometry->set_perception_properties(geometry::PerceptionProperties());
+  }
+
+  // Map ("label", "id") to body index as necessary.
+  geometry::PerceptionProperties* percep =
+      geometry->mutable_perception_properties();
+  if (percep != nullptr) {
+    if (!percep->HasProperty("label", "id")) {
+      percep->AddProperty("label", "id", RenderLabel(body.index()));
+    }
+  }
+
+  geometry->set_name(
+      GetScopedName(*this, body.model_instance(), geometry->name()));
+
+  const geometry::GeometryId id = RegisterGeometry(body, std::move(geometry));
 
   DRAKE_ASSERT(ssize(visual_geometries_) == num_bodies());
   visual_geometries_[body.index()].push_back(id);
   ++num_visual_geometries_;
+
   return id;
 }
 
@@ -1000,7 +1012,9 @@ geometry::GeometryId MultibodyPlant<T>::RegisterCollisionGeometry(
   // register geometry that has a fixed path to world to the world body (i.e.,
   // as anchored geometry).
   GeometryId id = RegisterGeometry(
-      body, X_BG, shape, GetScopedName(*this, body.model_instance(), name));
+      body,
+      std::make_unique<geometry::GeometryInstance>(
+          X_BG, shape, GetScopedName(*this, body.model_instance(), name)));
 
   scene_graph_->AssignRole(*source_id_, id, std::move(properties));
   DRAKE_ASSERT(ssize(collision_geometries_) == num_bodies());
@@ -1103,18 +1117,16 @@ std::unordered_set<BodyIndex> MultibodyPlant<T>::GetFloatingBaseBodies() const {
 
 template <typename T>
 geometry::GeometryId MultibodyPlant<T>::RegisterGeometry(
-    const RigidBody<T>& body, const math::RigidTransform<double>& X_BG,
-    const geometry::Shape& shape, const std::string& name) {
+    const RigidBody<T>& body,
+    std::unique_ptr<geometry::GeometryInstance> instance) {
   DRAKE_ASSERT(!is_finalized());
   DRAKE_ASSERT(geometry_source_is_registered());
   DRAKE_ASSERT(body_has_registered_frame(body));
 
   // Register geometry in the body frame.
-  std::unique_ptr<geometry::GeometryInstance> geometry_instance =
-      std::make_unique<GeometryInstance>(X_BG, shape.Clone(), name);
   GeometryId geometry_id = scene_graph_->RegisterGeometry(
       source_id_.value(), body_index_to_frame_id_[body.index()],
-      std::move(geometry_instance));
+      std::move(instance));
   geometry_id_to_body_index_[geometry_id] = body.index();
   return geometry_id;
 }
diff --git a/multibody/plant/multibody_plant.h b/multibody/plant/multibody_plant.h
index cde4349363f8..4b067d93f537 100644
--- a/multibody/plant/multibody_plant.h
+++ b/multibody/plant/multibody_plant.h
@@ -1986,7 +1986,8 @@ class MultibodyPlant : public internal::MultibodyTreeSystem<T> {
   /// "roles". The `RegisterCollisionGeometry()` methods register geometry with
   /// SceneGraph and assign it the proximity role. The
   /// `RegisterVisualGeometry()` methods do the same, but assign the
-  /// illustration role.
+  /// illustration and/or perception role, depending on how the API is
+  /// exercised (see below).
   ///
   /// All geometry registration methods return a @ref geometry::GeometryId
   /// GeometryId. This is how SceneGraph refers to the geometries. The
@@ -2021,6 +2022,8 @@ class MultibodyPlant : public internal::MultibodyTreeSystem<T> {
   /// See documentation of geometry::SceneGraphInspector on where to get an
   /// inspector.
   ///
+  /// <h4> %MultibodyPlant names vs. SceneGraph names
+  ///
   /// In %MultibodyPlant, frame names only have to be unique in a single
   /// model instance. However, SceneGraph knows nothing of model instances. So,
   /// to generate unique names for the corresponding frames in SceneGraph,
@@ -2029,6 +2032,23 @@ class MultibodyPlant : public internal::MultibodyTreeSystem<T> {
   /// `[model instance name]::[body name]`. Searching for a frame with just the
   /// name `body name` will fail. (See RigidBody::name() and
   /// GetModelInstanceName() for those values.)
+  ///
+  /// Geometry names get scoped in the same way. The name passed to a
+  /// RegisterXXGeometry becomes the scoped name `[model instance name]::[name]`
+  /// in SceneGraph.
+  ///
+  /// <h4>Registering visual roles</h4>
+  ///
+  /// Drake has two visual roles: illustration and perception. Unless otherwise
+  /// indicated, the RegisterVisualGeometry() APIs register the given geometry
+  /// with both roles. One API allows specific control over which roles are
+  /// assigned.
+  /// @note This "assign-all-roles" behavior may change in the future and code
+  /// that directly relies on it will break.
+  ///
+  /// Furthermore, unless the ("label", "id") property has already
+  /// been defined, the PerceptionProperties will be assigned that property
+  /// with a geometry::RenderLabel whose value is equal to the body's index.
   /// @{
 
   /// Registers `this` plant to serve as a source for an instance of
@@ -2053,13 +2073,11 @@ class MultibodyPlant : public internal::MultibodyTreeSystem<T> {
       geometry::SceneGraph<T>* scene_graph);
 
   /// Registers geometry in a SceneGraph with a given geometry::Shape to be
-  /// used for visualization of a given `body`.
+  /// used for visualization of a given `body`. The perception properties are a
+  /// copy of the given `properties`. If the resulting perception properties
+  /// do not include ("label", "id"), then it is added as documented above.
   ///
-  /// @note Currently, the visual geometry will _also_ be assigned a perception
-  /// role. Its render label's value will be equal to the body's index and its
-  /// perception color will be the same as its illustration color (defaulting to
-  /// gray if no color is provided). This behavior will change in the near
-  /// future and code that directly relies on this behavior will break.
+  /// See @ref mbp_geometry "the overview" for more details.
   ///
   /// @param[in] body
   ///   The body for which geometry is being registered.
@@ -2074,26 +2092,53 @@ class MultibodyPlant : public internal::MultibodyTreeSystem<T> {
   /// @param[in] properties
   ///   The illustration properties for this geometry.
   /// @throws std::exception if called post-finalize.
-  /// @throws std::exception if `scene_graph` does not correspond to the same
-  /// instance with which RegisterAsSourceForSceneGraph() was called.
   /// @returns the id for the registered geometry.
   geometry::GeometryId RegisterVisualGeometry(
       const RigidBody<T>& body, const math::RigidTransform<double>& X_BG,
       const geometry::Shape& shape, const std::string& name,
       const geometry::IllustrationProperties& properties);
 
-  /// Overload for visual geometry registration; it converts the `diffuse_color`
-  /// (RGBA with values in the range [0, 1]) into a
-  /// geometry::DrakeVisualizer-compatible set of
-  /// geometry::IllustrationProperties.
+  /// Registers the given `geometry_instance` in a SceneGraph to be used for
+  /// visualization of a given `body`.
+  ///
+  /// The roles that `geometry_instance` gets assigned (illustration/perception)
+  /// in SceneGraph depend solely on the properties that have _already_ been
+  /// assigned to `geometry_instance`. If _any_ visual roles have been assigned,
+  /// those will be the only roles used. If _no_ visual roles have been
+  /// assigned, then both roles will be assigned using the default set of
+  /// property values.
+  ///
+  /// If the registered geometry has the perception role, it will have the
+  /// ("label", "id") property. Possibly assigned as documented above.
+  ///
+  /// See @ref mbp_geometry "the overview" for more details.
+  ///
+  /// @param[in] body
+  ///   The body for which geometry is being registered.
+  /// @param[in] geometry_instance
+  ///   The geometry to associate with the visual appearance of `body`.
+  /// @throws std::exception if `geometry_instance` is null.
+  /// @throws std::exception if called post-finalize.
+  /// @returns the id for the registered geometry.
+  geometry::GeometryId RegisterVisualGeometry(
+      const RigidBody<T>& body,
+      std::unique_ptr<geometry::GeometryInstance> geometry_instance);
+
+  /// Overload for visual geometry registration. The following properties are
+  /// set:
+  ///   - ("phong", "diffuse") = `diffuse_color` in both sets of properties.
+  ///   - ("label", "id") in perception properties as documented above.
+  ///
+  /// See @ref mbp_geometry "the overview" for more details.
   geometry::GeometryId RegisterVisualGeometry(
       const RigidBody<T>& body, const math::RigidTransform<double>& X_BG,
       const geometry::Shape& shape, const std::string& name,
       const Vector4<double>& diffuse_color);
 
-  /// Overload for visual geometry registration; it relies on the downstream
-  /// geometry::IllustrationProperties _consumer_ to provide default parameter
-  /// values (see @ref geometry_roles for details).
+  /// Overload for visual geometry registration. The ("label", "id")  property
+  /// is set in the perception properties (as documented above).
+  ///
+  /// See @ref mbp_geometry "the overview" for more details.
   geometry::GeometryId RegisterVisualGeometry(
       const RigidBody<T>& body, const math::RigidTransform<double>& X_BG,
       const geometry::Shape& shape, const std::string& name);
@@ -5736,8 +5781,8 @@ class MultibodyPlant : public internal::MultibodyTreeSystem<T> {
   // 3. `scene_graph` points to the same SceneGraph instance previously
   //    passed to RegisterAsSourceForSceneGraph().
   geometry::GeometryId RegisterGeometry(
-      const RigidBody<T>& body, const math::RigidTransform<double>& X_BG,
-      const geometry::Shape& shape, const std::string& name);
+      const RigidBody<T>& body,
+      std::unique_ptr<geometry::GeometryInstance> instance);
 
   // Registers a geometry frame for every body. If the body already has a
   // geometry frame, it is unchanged. This registration is part of finalization.
diff --git a/multibody/plant/test/multibody_plant_test.cc b/multibody/plant/test/multibody_plant_test.cc
index f6fe85539778..e768d2fffa83 100644
--- a/multibody/plant/test/multibody_plant_test.cc
+++ b/multibody/plant/test/multibody_plant_test.cc
@@ -61,12 +61,15 @@ using Eigen::VectorXd;
 using geometry::FrameId;
 using geometry::FramePoseVector;
 using geometry::GeometryId;
+using geometry::GeometryInstance;
 using geometry::IllustrationProperties;
 using geometry::PenetrationAsPointPair;
+using geometry::PerceptionProperties;
 using geometry::QueryObject;
 using geometry::SceneGraph;
 using geometry::SceneGraphInspector;
 using geometry::internal::DummyRenderEngine;
+using geometry::render::RenderLabel;
 using math::RigidTransform;
 using math::RigidTransformd;
 using math::RollPitchYawd;
@@ -1975,9 +1978,11 @@ GTEST_TEST(MultibodyPlantTest, CollisionGeometryRegistration) {
                   geometry::internal::kFriction) == ground_friction);
 }
 
-// Verifies the process of visual geometry registration with a SceneGraph.
-// We build a model with two spheres and a ground plane. The ground plane is
-// located at y = 0 with normal in the y-axis direction.
+// Verifies the process of visual geometry registration with a SceneGraph. We
+// have multiple APIs, so we register multiple geometries, one with each
+// distinct API invocation. We build a model with multiple spheres and a ground
+// plane. The ground plane is located at y = 0 with normal in the y-axis
+// direction.
 GTEST_TEST(MultibodyPlantTest, VisualGeometryRegistration) {
   // Parameters of the setup.
   const double radius = 0.5;
@@ -1999,42 +2004,97 @@ GTEST_TEST(MultibodyPlantTest, VisualGeometryRegistration) {
   plant.RegisterAsSourceForSceneGraph(&scene_graph);
   EXPECT_EQ(render_engine.num_registered(), 0);
 
-  // A half-space for the ground geometry -- uses default visual material
-  GeometryId ground_id = plant.RegisterVisualGeometry(
+  const std::string model("test_model");
+  const ModelInstanceIndex model_instance = plant.AddModelInstance(model);
+
+  // A half-space for the ground geometry. The ground shape defines no visual
+  // properties at all. It should get both roles and have the ("label", "id")
+  // perception property.
+  const GeometryId ground_id = plant.RegisterVisualGeometry(
       plant.world_body(),
       // A half-space passing through the origin in the x-z plane.
       geometry::HalfSpace::MakePose(Vector3d::UnitY(), Vector3d::Zero()),
       geometry::HalfSpace(), "ground");
   EXPECT_EQ(render_engine.num_registered(), 1);
 
-  // Add two spherical bodies.
-  // To avoid unnecessary warnings/errors, use a non-zero spatial inertia.
+  // Add the spherical bodies.
+  // We just need a non-zero spatial inertia.
+  const auto M_BBo = SpatialInertia<double>::MakeUnitary();
+  const geometry::Sphere sphere(radius);
+  const RigidTransformd X_BG = RigidTransformd::Identity();
+
+  // Sphere1 defines a diffuse color. It should get both roles. It should have
+  // the ("phong", "diffuse") property in both roles and the ("label", "id")
+  // perception property.
   const RigidBody<double>& sphere1 =
-      plant.AddRigidBody("Sphere1", SpatialInertia<double>::MakeUnitary());
-  Vector4<double> sphere1_diffuse{0.9, 0.1, 0.1, 0.5};
-  GeometryId sphere1_id = plant.RegisterVisualGeometry(
-      sphere1, RigidTransformd::Identity(), geometry::Sphere(radius), "visual",
-      sphere1_diffuse);
+      plant.AddRigidBody("Sphere1", model_instance, M_BBo);
+  const Vector4<double> sphere1_diffuse{0.9, 0.1, 0.1, 0.5};
+  // Turns the diffuse color into illustration and perception properties.
+  const GeometryId sphere1_id = plant.RegisterVisualGeometry(
+      sphere1, X_BG, sphere, "visual1", sphere1_diffuse);
   EXPECT_EQ(render_engine.num_registered(), 2);
+
+  // Sphere2 defines illustration properties. It should get both roles with the
+  // perception properties including all illustration properties and with the
+  // ("label", "id") perception property.
   const RigidBody<double>& sphere2 =
-      plant.AddRigidBody("Sphere2", SpatialInertia<double>::MakeUnitary());
+      plant.AddRigidBody("Sphere2", model_instance, M_BBo);
   IllustrationProperties sphere2_props;
   const Vector4<double> sphere2_diffuse{0.1, 0.9, 0.1, 0.5};
   sphere2_props.AddProperty("phong", "diffuse", sphere2_diffuse);
   sphere2_props.AddProperty("phong", "diffuse_map", "empty.png");
+  // This property prevents MbP from attempting to copy properties by hand. It
+  // must rely on GeometryProperties copying abilities instead.
+  sphere2_props.AddProperty("test_only", "dummy", true);
   sphere2_props.AddProperty("renderer", "accepting",
                             std::set<std::string>{"not_dummy"});
-  GeometryId sphere2_id = plant.RegisterVisualGeometry(
-      sphere2, RigidTransformd::Identity(), geometry::Sphere(radius), "visual",
-      sphere2_props);
-  // Because sphere 2 white listed a *different* renderer, it didn't get added
-  // to render_engine.
+  // Uses illustration properties for both illustration and perception
+  // properties.
+  const GeometryId sphere2_id = plant.RegisterVisualGeometry(
+      sphere2, X_BG, sphere, "visual2", sphere2_props);
+  // Sphere2's accepting renderer is *not* `render_engine`; it will not be
+  // added to it.
   EXPECT_EQ(render_engine.num_registered(), 2);
 
+  // Sphere3 defines *only* perception properties for a geometry instance. It
+  // should only get the perception role, but should have the ("label", "id")
+  // property added.
+  const RigidBody<double>& sphere3 =
+      plant.AddRigidBody("Sphere3", model_instance, M_BBo);
+  auto sphere3_instance =
+      std::make_unique<GeometryInstance>(X_BG, sphere, "visual3");
+  PerceptionProperties perception_props;
+  sphere3_instance->set_perception_properties(perception_props);
+  const GeometryId sphere3_id =
+      plant.RegisterVisualGeometry(sphere3, std::move(sphere3_instance));
+  EXPECT_EQ(render_engine.num_registered(), 3);
+
+  // Sphere4 defines perception properties with a ("label", "id") property. It
+  // will not change when added.
+  const RigidBody<double>& sphere4 =
+      plant.AddRigidBody("Sphere4", model_instance, M_BBo);
+  auto sphere4_instance =
+      std::make_unique<GeometryInstance>(X_BG, sphere, "visual4");
+  perception_props.AddProperty("label", "id", RenderLabel(1234));
+  sphere4_instance->set_perception_properties(perception_props);
+  const GeometryId sphere4_id =
+      plant.RegisterVisualGeometry(sphere4, std::move(sphere4_instance));
+  EXPECT_EQ(render_engine.num_registered(), 4);
+
+  // Sphere5 provides a geometry instance with no properties assigned. It will
+  // be registered with "defaulted" properties for both visual roles.
+  const RigidBody<double>& sphere5 =
+      plant.AddRigidBody("Sphere5", model_instance, M_BBo);
+  auto sphere5_instance =
+      std::make_unique<GeometryInstance>(X_BG, sphere, "visual5");
+  const GeometryId sphere5_id =
+      plant.RegisterVisualGeometry(sphere3, std::move(sphere5_instance));
+  EXPECT_EQ(render_engine.num_registered(), 5);
+
   // We are done defining the model.
   plant.Finalize();
 
-  EXPECT_EQ(plant.num_visual_geometries(), 3);
+  EXPECT_EQ(plant.num_visual_geometries(), 6);
   EXPECT_EQ(plant.num_collision_geometries(), 0);
   EXPECT_TRUE(plant.geometry_source_is_registered());
   EXPECT_TRUE(plant.get_source_id());
@@ -2048,25 +2108,64 @@ GTEST_TEST(MultibodyPlantTest, VisualGeometryRegistration) {
   scene_graph.get_query_output_port().Calc(*context, state_value.get());
 
   const SceneGraphInspector<double>& inspector = query_object.inspector();
+
+  // This implicitly assumes that there *is* a ("phong", "diffuse") material. An
+  // exception will be thrown otherwise.
+  auto get_diffuse_color = [&inspector](GeometryId id) -> Vector4<double> {
+    const IllustrationProperties* material =
+        inspector.GetIllustrationProperties(id);
+    return material->GetProperty<Vector4<double>>("phong", "diffuse");
+  };
+
+  // Get the render label property from the geometry's perception properties.
+  auto get_render_label = [&inspector](GeometryId id) {
+    const PerceptionProperties* material =
+        inspector.GetPerceptionProperties(id);
+    return material->GetProperty<RenderLabel>("label", "id");
+  };
+
+  // Confirms that every illustration property is also in the perception
+  // properties.
+  auto illustration_in_perception = [&inspector](GeometryId id) {
+    const IllustrationProperties* illus =
+        inspector.GetIllustrationProperties(id);
+    if (illus == nullptr) return true;
+
+    const PerceptionProperties* percep = inspector.GetPerceptionProperties(id);
+    if (percep == nullptr) return false;
+
+    for (const auto& group_name : illus->GetGroupNames()) {
+      if (!percep->HasGroup(group_name)) return false;
+      for (const auto& [name, val] : illus->GetPropertiesInGroup(group_name)) {
+        // We're not going to worry about values. We'll assume if all of the
+        // properties were copied, the values were well. We just need evidence
+        // that copying took place.
+        if (!percep->HasProperty(group_name, name)) return false;
+      }
+    }
+    return true;
+  };
+
   {
     const IllustrationProperties* material =
         inspector.GetIllustrationProperties(ground_id);
     ASSERT_NE(material, nullptr);
     // Undefined property value indicates use of default value.
     EXPECT_FALSE(material->HasProperty("phong", "diffuse"));
+    EXPECT_EQ(get_render_label(ground_id),
+              RenderLabel(plant.world_body().index()));
+    EXPECT_TRUE(illustration_in_perception(ground_id));
+    // Ground belongs to default model instance - no name scoping.
+    EXPECT_EQ(inspector.GetName(ground_id), "ground");
   }
 
-  // This implicitly assumes that there *is* a "phong"|"diffuse" material. An
-  // exception will be thrown otherwise.
-  auto get_diffuse_color = [&inspector](GeometryId id) -> Vector4<double> {
-    const IllustrationProperties* material =
-        inspector.GetIllustrationProperties(id);
-    return material->GetProperty<Vector4<double>>("phong", "diffuse");
-  };
   {
     const Vector4<double>& test_diffuse = get_diffuse_color(sphere1_id);
     EXPECT_TRUE(CompareMatrices(test_diffuse, sphere1_diffuse, 0.0,
                                 MatrixCompareType::absolute));
+    EXPECT_EQ(get_render_label(sphere1_id), RenderLabel(sphere1.index()));
+    EXPECT_TRUE(illustration_in_perception(sphere1_id));
+    EXPECT_EQ(inspector.GetName(sphere1_id), "test_model::visual1");
   }
 
   {
@@ -2078,6 +2177,32 @@ GTEST_TEST(MultibodyPlantTest, VisualGeometryRegistration) {
     ASSERT_TRUE(material->HasProperty("phong", "diffuse_map"));
     EXPECT_EQ(material->GetProperty<std::string>("phong", "diffuse_map"),
               "empty.png");
+    EXPECT_EQ(get_render_label(sphere2_id), RenderLabel(sphere2.index()));
+    EXPECT_TRUE(illustration_in_perception(sphere2_id));
+    EXPECT_EQ(inspector.GetName(sphere2_id), "test_model::visual2");
+  }
+
+  {
+    EXPECT_EQ(inspector.GetIllustrationProperties(sphere3_id), nullptr);
+    EXPECT_NE(inspector.GetPerceptionProperties(sphere3_id), nullptr);
+    EXPECT_EQ(get_render_label(sphere3_id), RenderLabel(sphere3.index()));
+    EXPECT_EQ(inspector.GetName(sphere3_id), "test_model::visual3");
+  }
+
+  {
+    EXPECT_EQ(inspector.GetIllustrationProperties(sphere4_id), nullptr);
+    EXPECT_NE(inspector.GetPerceptionProperties(sphere4_id), nullptr);
+    EXPECT_NE(get_render_label(sphere4_id), RenderLabel(sphere4.index()));
+    EXPECT_EQ(get_render_label(sphere4_id), RenderLabel(1234));
+    EXPECT_EQ(inspector.GetName(sphere4_id), "test_model::visual4");
+  }
+
+  {
+    EXPECT_NE(inspector.GetIllustrationProperties(sphere5_id), nullptr);
+    EXPECT_NE(inspector.GetPerceptionProperties(sphere5_id), nullptr);
+    EXPECT_NE(get_render_label(sphere5_id), RenderLabel(sphere5.index()));
+    EXPECT_EQ(inspector.GetName(sphere5_id), "test_model::visual5");
+    EXPECT_TRUE(illustration_in_perception(sphere5_id));
   }
 }
 
diff --git a/solvers/aggregate_costs_constraints.cc b/solvers/aggregate_costs_constraints.cc
index 3250455dc39c..2f6907aeb58d 100644
--- a/solvers/aggregate_costs_constraints.cc
+++ b/solvers/aggregate_costs_constraints.cc
@@ -695,6 +695,7 @@ void ParsePositiveSemidefiniteConstraints(
   DRAKE_ASSERT(psd_cone_length->empty());
   const double sqrt2 = std::sqrt(2);
   for (const auto& psd_constraint : prog.positive_semidefinite_constraints()) {
+    psd_constraint.evaluator()->WarnOnSmallMatrixSize();
     // PositiveSemidefiniteConstraint encodes the matrix X being psd.
     // We convert it to SCS/Clarabel form
     // A * x + s = 0
@@ -738,6 +739,7 @@ void ParsePositiveSemidefiniteConstraints(
   }
   for (const auto& lmi_constraint :
        prog.linear_matrix_inequality_constraints()) {
+    lmi_constraint.evaluator()->WarnOnSmallMatrixSize();
     // LinearMatrixInequalityConstraint encodes
     // F₀ + x₁*F₁ + x₂*F₂ + ... + xₙFₙ is p.s.d
     // We convert this to SCS/Clarabel form as
diff --git a/solvers/constraint.cc b/solvers/constraint.cc
index aed74945862b..8e5876f97008 100644
--- a/solvers/constraint.cc
+++ b/solvers/constraint.cc
@@ -251,6 +251,9 @@ LorentzConeConstraint::LorentzConeConstraint(
   set_is_thread_safe(true);
   DRAKE_THROW_UNLESS(A_.rows() >= 2);
   DRAKE_THROW_UNLESS(A_.rows() == b_.rows());
+
+  // Set the gradient sparsity pattern.
+  UpdateGradientSparsityPattern();
 }
 
 LorentzConeConstraint::~LorentzConeConstraint() = default;
@@ -274,6 +277,9 @@ void LorentzConeConstraint::UpdateCoefficients(
   // bounds only depend on EvalType. When EvalType=kNonconvex, the lower/upper
   // bound is [0, 0]/[inf, inf] respectively; otherwise, the lower/upper bound
   // is 0/inf respectively.
+
+  // Update the gradient sparsity pattern.
+  UpdateGradientSparsityPattern();
 }
 
 namespace {
@@ -354,6 +360,65 @@ std::string LorentzConeConstraint::DoToLatex(
                      symbolic::ToLatex(z(0), precision));
 }
 
+void LorentzConeConstraint::UpdateGradientSparsityPattern() {
+  std::vector<std::pair<int, int>> gradient_sparsity_pattern;
+  switch (eval_type_) {
+    case EvalType::kConvex:
+    case EvalType::kConvexSmooth: {
+      // For both kConvex and kConvexSmooth, we evaluate
+      // y=z(0) - sqrt(z(1)²+z(2)²+...+z(n-1)²) where z = A*x+b
+      // So dy/dx(i) is non-zero if A.col(i) is non-zero.
+      for (int i = 0; i < A_.outerSize(); ++i) {
+        for (Eigen::SparseMatrix<double>::InnerIterator it(A_, i); it; ++it) {
+          if (it.value() != 0) {
+            gradient_sparsity_pattern.emplace_back(0, i);
+            break;
+          }
+        }
+      }
+      break;
+    }
+    case EvalType::kNonconvex: {
+      // We evaluate
+      // y(0) = z(0)
+      // y(1) = z(0)² -(z(1)²+...+z(n-1)²)
+      // z = A*x+b.
+      // so dy(0)/dx(i) is non-zero if A(0, i) is non-zero.
+      // dy(1)/dx(i) is non-zero if A.col(i) is non-zero.
+      for (int i = 0; i < A_.outerSize(); ++i) {
+        bool is_column_zero = true;
+        for (Eigen::SparseMatrix<double>::InnerIterator it(A_, i); it; ++it) {
+          if (it.value() != 0) {
+            is_column_zero = false;
+            if (it.row() == 0) {
+              gradient_sparsity_pattern.emplace_back(0, i);
+            }
+          }
+        }
+        if (!is_column_zero) {
+          gradient_sparsity_pattern.emplace_back(1, i);
+        }
+      }
+    }
+  }
+  this->SetGradientSparsityPattern(gradient_sparsity_pattern);
+}
+
+RotatedLorentzConeConstraint::RotatedLorentzConeConstraint(
+    const Eigen::Ref<const Eigen::MatrixXd>& A,
+    const Eigen::Ref<const Eigen::VectorXd>& b)
+    : Constraint(
+          3, A.cols(), Eigen::Vector3d::Constant(0.0),
+          Eigen::Vector3d::Constant(std::numeric_limits<double>::infinity())),
+      A_(A.sparseView()),
+      A_dense_(A),
+      b_(b) {
+  DRAKE_THROW_UNLESS(A_.rows() >= 3);
+  DRAKE_THROW_UNLESS(A_.rows() == b_.rows());
+  set_is_thread_safe(true);
+  UpdateGradientSparsityPattern();
+}
+
 RotatedLorentzConeConstraint::~RotatedLorentzConeConstraint() = default;
 
 void RotatedLorentzConeConstraint::UpdateCoefficients(
@@ -372,6 +437,8 @@ void RotatedLorentzConeConstraint::UpdateCoefficients(
   DRAKE_THROW_UNLESS(A_.rows() == b_.rows());
   // Note that we don't need to update the lower and upper bounds as the
   // constraints lower/upper bounds are fixed (independent of A and b).
+
+  UpdateGradientSparsityPattern();
 }
 
 template <typename DerivedX, typename ScalarY>
@@ -416,6 +483,36 @@ std::string RotatedLorentzConeConstraint::DoToLatex(
       symbolic::ToLatex(z(0) * z(1), precision));
 }
 
+void RotatedLorentzConeConstraint::UpdateGradientSparsityPattern() {
+  // Set the sparsity pattern.
+  // We evaluate
+  // y(0) = z(0)
+  // y(1) = z(1)
+  // y(2) = z(0)*z(1)-z(2)²-...-z(n-1)²
+  // where z = A*x+b.
+  // dy(0)/dx(i) is non-zero if A(0, i) is non-zero
+  // dy(1)/dx(i) is non-zero if A(1, i) is non-zero
+  // dy(2)/dx(i) is non-zero if A.col(i) is non-zero
+  std::vector<std::pair<int, int>> gradient_sparsity_pattern;
+  for (int i = 0; i < A_.outerSize(); ++i) {
+    bool is_column_zero = true;
+    for (Eigen::SparseMatrix<double>::InnerIterator it(A_, i); it; ++it) {
+      if (it.value() != 0) {
+        is_column_zero = false;
+        if (it.row() == 0) {
+          gradient_sparsity_pattern.emplace_back(0, i);
+        } else if (it.row() == 1) {
+          gradient_sparsity_pattern.emplace_back(1, i);
+        }
+      }
+    }
+    if (!is_column_zero) {
+      gradient_sparsity_pattern.emplace_back(2, i);
+    }
+  }
+  this->SetGradientSparsityPattern(gradient_sparsity_pattern);
+}
+
 PolynomialConstraint::~PolynomialConstraint() = default;
 
 LinearConstraint::LinearConstraint(const Eigen::Ref<const Eigen::MatrixXd>& A,
@@ -671,18 +768,6 @@ PositiveSemidefiniteConstraint::PositiveSemidefiniteConstraint(int rows)
                  Eigen::VectorXd::Constant(
                      rows, std::numeric_limits<double>::infinity())),
       matrix_rows_(rows) {
-  // TODO(hongkai.dai): remove the warning when we change the solver backend.
-  if (matrix_rows_ == 1) {
-    drake::log()->warn(
-        "PositiveSemidefiniteConstraint: rows==1, please consider "
-        "reformulating this as a linear inequality constraint for better "
-        "speed/numerics.");
-  } else if (matrix_rows_ == 2) {
-    drake::log()->warn(
-        "PositiveSemidefiniteConstraint: rows==2, please consider to "
-        "reformulating this as a rotated Lorentz cone constraint for better "
-        "speed/numerics.");
-  }
   set_is_thread_safe(true);
 }
 
@@ -726,6 +811,20 @@ std::string PositiveSemidefiniteConstraint::DoToLatex(
   return fmt::format("{} \\succeq 0", symbolic::ToLatex(S.eval(), precision));
 }
 
+void PositiveSemidefiniteConstraint::WarnOnSmallMatrixSize() const {
+  if (matrix_rows_ == 1) {
+    drake::log()->warn(
+        "PositiveSemidefiniteConstraint: rows==1, please consider "
+        "reformulating this as a linear inequality constraint for better "
+        "speed/numerics.");
+  } else if (matrix_rows_ == 2) {
+    drake::log()->warn(
+        "PositiveSemidefiniteConstraint: rows==2, please consider "
+        "reformulating this as a rotated Lorentz cone constraint for better "
+        "speed/numerics.");
+  }
+}
+
 LinearMatrixInequalityConstraint::~LinearMatrixInequalityConstraint() = default;
 
 void LinearMatrixInequalityConstraint::DoEval(
@@ -761,20 +860,6 @@ LinearMatrixInequalityConstraint::LinearMatrixInequalityConstraint(
       F_{std::move(F)},
       matrix_rows_(F_.empty() ? 0 : F_.front().rows()) {
   DRAKE_THROW_UNLESS(!F_.empty());
-  // TODO(hongkai.dai): remove the warning when we change the solver backend.
-  if (matrix_rows_ == 1) {
-    drake::log()->warn(
-        "LinearMatrixInequalityConstraint: the matrix has size 1. Please "
-        "consider"
-        "reformulating this as a linear inequality constraint for better "
-        "speed/numerics.");
-  } else if (matrix_rows_ == 2) {
-    drake::log()->warn(
-        "LinearMatrixInequalityConstraint: the matrix has size 2. Please "
-        "consider "
-        "reformulating this as a rotated Lorentz cone constraint for better "
-        "speed/numerics.");
-  }
 
   set_bounds(Eigen::VectorXd::Zero(matrix_rows_),
              Eigen::VectorXd::Constant(
@@ -795,6 +880,22 @@ std::string LinearMatrixInequalityConstraint::DoToLatex(
   return fmt::format("{} \\succeq 0", symbolic::ToLatex(S, precision));
 }
 
+void LinearMatrixInequalityConstraint::WarnOnSmallMatrixSize() const {
+  // TODO(hongkai.dai): remove the warning when we change the solver backend.
+  if (matrix_rows_ == 1) {
+    drake::log()->warn(
+        "LinearMatrixInequalityConstraint: the matrix has size 1. Please "
+        "consider"
+        "reformulating this as a linear inequality constraint for better "
+        "speed/numerics.");
+  } else if (matrix_rows_ == 2) {
+    drake::log()->warn(
+        "LinearMatrixInequalityConstraint: the matrix has size 2. Please "
+        "consider reformulating this as a rotated Lorentz cone constraint for "
+        "better speed/numerics.");
+  }
+}
+
 ExpressionConstraint::ExpressionConstraint(
     const Eigen::Ref<const VectorX<symbolic::Expression>>& v,
     const Eigen::Ref<const Eigen::VectorXd>& lb,
diff --git a/solvers/constraint.h b/solvers/constraint.h
index a2822ae4b39c..e8f063949e12 100644
--- a/solvers/constraint.h
+++ b/solvers/constraint.h
@@ -413,6 +413,9 @@ class LorentzConeConstraint : public Constraint {
 
   std::string DoToLatex(const VectorX<symbolic::Variable>&, int) const override;
 
+  // Updates the gradient sparsity pattern given A_.
+  void UpdateGradientSparsityPattern();
+
   Eigen::SparseMatrix<double> A_;
   // We need to store a dense matrix of A_, so that we can compute the gradient
   // using AutoDiffXd, and return the gradient as a dense matrix.
@@ -449,17 +452,7 @@ class RotatedLorentzConeConstraint : public Constraint {
    @throws std::exception if A.rows() < 3.
    */
   RotatedLorentzConeConstraint(const Eigen::Ref<const Eigen::MatrixXd>& A,
-                               const Eigen::Ref<const Eigen::VectorXd>& b)
-      : Constraint(
-            3, A.cols(), Eigen::Vector3d::Constant(0.0),
-            Eigen::Vector3d::Constant(std::numeric_limits<double>::infinity())),
-        A_(A.sparseView()),
-        A_dense_(A),
-        b_(b) {
-    DRAKE_THROW_UNLESS(A_.rows() >= 3);
-    DRAKE_THROW_UNLESS(A_.rows() == b_.rows());
-    set_is_thread_safe(true);
-  }
+                               const Eigen::Ref<const Eigen::VectorXd>& b);
 
   /** Getter for A. */
   const Eigen::SparseMatrix<double>& A() const { return A_; }
@@ -501,6 +494,9 @@ class RotatedLorentzConeConstraint : public Constraint {
 
   std::string DoToLatex(const VectorX<symbolic::Variable>&, int) const override;
 
+  // Updates the gradient sparsity pattern given A_.
+  void UpdateGradientSparsityPattern();
+
   Eigen::SparseMatrix<double> A_;
   // We need to store a dense matrix of A_, so that we can compute the gradient
   // using AutoDiffXd, and return the gradient as a dense matrix.
@@ -1001,6 +997,12 @@ class PositiveSemidefiniteConstraint : public Constraint {
 
   int matrix_rows() const { return matrix_rows_; }
 
+  /**
+   * Throw a warning if the matrix size is either 1x1 or 2x2.
+   */
+  // TODO(hongkai.dai): remove the warning when we change the solver backend.
+  void WarnOnSmallMatrixSize() const;
+
  protected:
   /**
    * Evaluate the eigen values of the symmetric matrix.
@@ -1071,6 +1073,12 @@ class LinearMatrixInequalityConstraint : public Constraint {
   /// Fi are all matrix_rows() x matrix_rows() matrices.
   int matrix_rows() const { return matrix_rows_; }
 
+  /**
+   * Warn if the matrix size is 1x1 or 2x2.
+   */
+  // TODO(hongkai.dai): remove the warning when we change the solver backend.
+  void WarnOnSmallMatrixSize() const;
+
  protected:
   /**
    * Evaluate the eigen values of the linear matrix.
diff --git a/solvers/gurobi_solver.cc b/solvers/gurobi_solver.cc
index 710bd519bc3d..5cd1249608a2 100644
--- a/solvers/gurobi_solver.cc
+++ b/solvers/gurobi_solver.cc
@@ -952,7 +952,7 @@ void GurobiSolver::DoSolve2(const MathematicalProgram& prog,
   const std::optional<std::string> grb_write =
       options->template Pop<std::string>("GRBwrite");
 
-  // Copy the remaining options into model_env.
+  // Convert the common options into their Gurobi flavor.
   options->Respell([](const auto& common, auto* respelled) {
     respelled->emplace("LogToConsole", common.print_to_console ? 1 : 0);
     if (!common.print_file_name.empty()) {
@@ -986,6 +986,11 @@ void GurobiSolver::DoSolve2(const MathematicalProgram& prog,
     DRAKE_DEMAND(num_threads.has_value());
     respelled->emplace("Threads", *num_threads);
   });
+
+  // Copy the remaining options into model_env. Set the logging level first, so
+  // that changes to any of the other options are uniformly logged (or not).
+  SetOptionOrThrow(model_env, "LogToConsole",
+                   options->Pop<int>("LogToConsole").value_or(0));
   options->CopyToCallbacks(
       [&model_env](const std::string& key, double value) {
         SetOptionOrThrow(model_env, key, value);
diff --git a/solvers/mosek_solver_internal.cc b/solvers/mosek_solver_internal.cc
index 958a712ff4e0..3c6aac853434 100644
--- a/solvers/mosek_solver_internal.cc
+++ b/solvers/mosek_solver_internal.cc
@@ -839,6 +839,7 @@ MSKrescodee MosekSolverProgram::AddPositiveSemidefiniteConstraints(
   bar_var_dimension.reserve(prog.positive_semidefinite_constraints().size());
   int psd_count = 0;
   for (const auto& binding : prog.positive_semidefinite_constraints()) {
+    binding.evaluator()->WarnOnSmallMatrixSize();
     bar_var_dimension.push_back(binding.evaluator()->matrix_rows());
     psd_barvar_indices->emplace(binding, numbarvar + psd_count);
     psd_count++;
@@ -872,6 +873,7 @@ MSKrescodee MosekSolverProgram::AddLinearMatrixInequalityConstraint(
   // where A is a sparse matrix.
   std::vector<Eigen::Triplet<double>> A_triplets;
   for (const auto& binding : prog.linear_matrix_inequality_constraints()) {
+    binding.evaluator()->WarnOnSmallMatrixSize();
     // Allocate memory for A_triplets. We allocate the maximal memory by
     // assuming that A is dense.
     // TODO(hongkai.dai): change LinearMatrixInequalityConstraint::F() to return
diff --git a/solvers/test/constraint_test.cc b/solvers/test/constraint_test.cc
index b224774de99c..04b0602252aa 100644
--- a/solvers/test/constraint_test.cc
+++ b/solvers/test/constraint_test.cc
@@ -47,6 +47,35 @@ Environment BuildEnvironment(const VectorX<Variable>& vars,
   return env;
 }
 
+template <typename C>
+void CheckGradientSparsityPattern(
+    const C& constraint, const Eigen::Ref<const Eigen::VectorXd>& x_val) {
+  const std::optional<std::vector<std::pair<int, int>>>&
+      gradient_sparsity_pattern = constraint.gradient_sparsity_pattern();
+  if (gradient_sparsity_pattern.has_value()) {
+    // nonzero_gradient(i, j) = 1 if (i, j) is in gradient_sparsity_pattern.
+    Eigen::MatrixX<int> nonzero_gradient = Eigen::MatrixX<int>::Zero(
+        constraint.num_constraints(), constraint.num_vars());
+    for (const auto& [row, col] : gradient_sparsity_pattern.value()) {
+      // There should be no duplicated entries in gradient_sparsity_pattern,
+      // hence nonzero_gradient(row, col) should not have been set already.
+      ASSERT_EQ(nonzero_gradient(row, col), 0);
+      nonzero_gradient(row, col) = 1;
+    }
+    const auto x_ad = math::InitializeAutoDiff(x_val);
+    VectorX<AutoDiffXd> y_ad(constraint.num_constraints());
+    constraint.Eval(x_ad, &y_ad);
+    const Eigen::MatrixXd y_grad = math::ExtractGradient(y_ad);
+    Eigen::MatrixX<int> nonzero_gradient_expected(y_grad.rows(), y_grad.cols());
+    for (int i = 0; i < y_grad.rows(); ++i) {
+      for (int j = 0; j < y_grad.cols(); ++j) {
+        nonzero_gradient_expected(i, j) = (y_grad(i, j) != 0);
+      }
+    }
+    EXPECT_TRUE(CompareMatrices(nonzero_gradient, nonzero_gradient_expected));
+  }
+}
+
 GTEST_TEST(TestConstraint, BoundSizeCheck) {
   DRAKE_EXPECT_THROWS_MESSAGE(
       LinearConstraint(Eigen::Matrix3d::Identity(), Eigen::Vector2d(1., 2),
@@ -557,6 +586,40 @@ GTEST_TEST(testConstraint, testLorentzConeConstraint) {
   TestLorentzConeEvalNonconvex(A4, b4, x4, false);
 }
 
+GTEST_TEST(TestConstraint, LorentzConeGradientSparsityPattern) {
+  for (const auto eval_type : {LorentzConeConstraint::EvalType::kConvex,
+                               LorentzConeConstraint::EvalType::kConvexSmooth,
+                               LorentzConeConstraint::EvalType::kNonconvex}) {
+    const Eigen::Vector3d b(10, 20, 30);
+    LorentzConeConstraint constraint1(Eigen::Matrix3d::Identity(), b,
+                                      eval_type);
+    CheckGradientSparsityPattern(constraint1, Eigen::Vector3d(1, 2, 3));
+
+    Eigen::Matrix3d new_A = Eigen::Matrix3d::Identity();
+    new_A.row(0).setZero();
+    constraint1.UpdateCoefficients(new_A, b);
+    CheckGradientSparsityPattern(constraint1, Eigen::Vector3d(1, 2, 3));
+
+    Eigen::Matrix3d A = Eigen::Matrix3d::Ones();
+    // Set each row of A to be zero.
+    for (int i = 0; i < 3; ++i) {
+      A.setOnes();
+      A.row(i).setZero();
+      LorentzConeConstraint constraint_i(A, b, eval_type);
+      CheckGradientSparsityPattern(constraint_i, Eigen::Vector3d(1, 2, 3));
+    }
+
+    // Set each column of A to be zero.
+    for (int i = 0; i < 3; ++i) {
+      A.setOnes();
+      A.col(i).setZero();
+      LorentzConeConstraint constraint_i(A, b, eval_type);
+      ASSERT_TRUE(constraint_i.gradient_sparsity_pattern().has_value());
+      CheckGradientSparsityPattern(constraint_i, Eigen::Vector3d(1, 2, 3));
+    }
+  }
+}
+
 GTEST_TEST(TestConstraint, LorentzConeConstraintIsThreadSafe) {
   Eigen::Matrix<double, 4, 2> A;
   // clang-format off
@@ -654,6 +717,36 @@ GTEST_TEST(testConstraint, testRotatedLorentzConeConstraint) {
   TestRotatedLorentzConeEval(A4, b4, x4, false);
 }
 
+GTEST_TEST(testConstraint,
+           RotatedLorentzConeConstraintGradientSparsityPattern) {
+  RotatedLorentzConeConstraint constraint(Eigen::Matrix4d::Identity(),
+                                          Eigen::Vector4d(1, 2, 3, 4));
+  CheckGradientSparsityPattern(constraint, Eigen::Vector4d(4, 5, 6, 7));
+
+  Eigen::Matrix4d new_A = Eigen::Matrix4d::Identity();
+  new_A.row(0).setZero();
+  constraint.UpdateCoefficients(new_A, Eigen::Vector4d(1, 2, 3, 4));
+  CheckGradientSparsityPattern(constraint, Eigen::Vector4d(4, 5, 6, 7));
+
+  Eigen::Matrix4d A;
+  // Set each row of A to be zero.
+  for (int i = 0; i < 4; ++i) {
+    A.setOnes();
+    A.row(i).setZero();
+    RotatedLorentzConeConstraint constraint_i(A, Eigen::Vector4d(1, 2, 3, 4));
+    CheckGradientSparsityPattern(constraint_i, Eigen::Vector4d(4, 5, 6, 7));
+  }
+
+  // Set each column of A to be zero.
+  for (int i = 0; i < 4; ++i) {
+    A.setOnes();
+    A.col(i).setZero();
+    RotatedLorentzConeConstraint constraint_i(A, Eigen::Vector4d(1, 2, 3, 4));
+    ASSERT_TRUE(constraint_i.gradient_sparsity_pattern().has_value());
+    CheckGradientSparsityPattern(constraint_i, Eigen::Vector4d(4, 5, 6, 7));
+  }
+}
+
 GTEST_TEST(testConstraint, RotatedLorentzConeConstraintUpdateCoefficients) {
   Eigen::Matrix<double, 3, 2> A;
   A << 1, 2, -2, -1, 2, 3;
diff --git a/tools/dynamic_analysis/valgrind.supp b/tools/dynamic_analysis/valgrind.supp
index cf45b09243c6..c57aaa16173d 100644
--- a/tools/dynamic_analysis/valgrind.supp
+++ b/tools/dynamic_analysis/valgrind.supp
@@ -63,6 +63,22 @@
    ...
    obj:*/libmosek64.so.10.0
 }
+{
+   MOSEK possible leak #3
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:memalign
+   ...
+   fun:MSK_optimize
+}
+{
+   MOSEK possible leak #4
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:calloc
+   ...
+   fun:allocate_stack
+}
 
 # Started happening when Gurobi got updated to 7.0.2. PR 6332.
 {