@@ -21,6 +21,7 @@ import (
 	"github.com/github/github-mcp-server/pkg/translations"
 	"github.com/github/github-mcp-server/pkg/utils"
 	"github.com/go-chi/chi/v5"
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/modelcontextprotocol/go-sdk/jsonrpc"
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 	"github.com/stretchr/testify/assert"
@@ -60,6 +61,41 @@ func (f allScopesFetcher) FetchTokenScopes(_ context.Context, _ string) ([]strin
 
 var _ scopes.FetcherInterface = allScopesFetcher{}
 
+func TestDefaultInventoryFactoryReusesSchemaDefinitions(t *testing.T) {
+	t.Parallel()
+	for _, host := range []string{"https://github.com", "https://example.ghe.com", "https://github.example.com"} {
+		t.Run(host, func(t *testing.T) {
+			factory, err := NewDefaultInventoryFactory(&ServerConfig{Host: host}, translations.NullTranslationHelper, nil, allScopesFetcher{})
+			require.NoError(t, err)
+			request := httptest.NewRequest(http.MethodPost, "/", nil)
+			request = request.WithContext(ghcontext.WithToolsets(request.Context(), []string{"all"}))
+			first, err := factory(request)
+			require.NoError(t, err)
+			definitions := first.AllTools()
+			require.NotEmpty(t, definitions)
+			for range 10 {
+				next, err := factory(request)
+				require.NoError(t, err)
+				tools := next.AllTools()
+				require.Len(t, tools, len(definitions))
+				for i, tool := range tools {
+					assert.Equal(t, definitions[i].Tool.Name, tool.Tool.Name)
+					if _, ok := definitions[i].Tool.InputSchema.(*jsonschema.Schema); ok {
+						assert.Same(t, definitions[i].Tool.InputSchema, tool.Tool.InputSchema)
+					} else {
+						assert.Equal(t, definitions[i].Tool.InputSchema, tool.Tool.InputSchema)
+					}
+					if _, ok := definitions[i].Tool.OutputSchema.(*jsonschema.Schema); ok {
+						assert.Same(t, definitions[i].Tool.OutputSchema, tool.Tool.OutputSchema)
+					} else {
+						assert.Equal(t, definitions[i].Tool.OutputSchema, tool.Tool.OutputSchema)
+					}
+				}
+			}
+		})
+	}
+}
+
 func mockToolWithFeatureFlag(name, toolsetID string, readOnly bool, enableFlag, disableFlag inventory.FeatureFlag) inventory.ServerTool {
 	tool := mockTool(name, toolsetID, readOnly)
 	features := make([]inventory.FeatureFlag, 0, 2)
 
@@ -123,6 +123,57 @@ func TestEncodedSchemasConcurrentRegistration(t *testing.T) {
 	assert.Equal(t, original, after, "source schema must remain unchanged")
 }
 
+func TestEncodedSchemasRepeatedInventoryRegistration(t *testing.T) {
+	t.Parallel()
+	schema := &jsonschema.Schema{
+		Type:       "object",
+		Properties: map[string]*jsonschema.Schema{"owner": {Type: "string"}},
+	}
+	definition := ServerTool{
+		Tool: mcp.Tool{Name: "repeated", InputSchema: schema, OutputSchema: schema},
+		HandlerFunc: func(any) mcp.ToolHandler {
+			return func(context.Context, *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+				return &mcp.CallToolResult{}, nil
+			}
+		},
+	}
+	original, err := json.Marshal(schema)
+	require.NoError(t, err)
+	var first []byte
+	for range 20 {
+		inv, err := NewBuilder().SetTools([]ServerTool{definition}).WithToolsets([]string{"all"}).Build()
+		require.NoError(t, err)
+		server := mcp.NewServer(&mcp.Implementation{Name: "repeated"}, nil)
+		inv.ForMCPRequest(MCPMethodToolsList, "").RegisterTools(context.Background(), server, nil)
+		st, ct := mcp.NewInMemoryTransports()
+		ss, err := server.Connect(context.Background(), st, nil)
+		require.NoError(t, err)
+		cs, err := mcp.NewClient(&mcp.Implementation{Name: "test"}, nil).Connect(context.Background(), ct, nil)
+		require.NoError(t, err)
+		list, err := cs.ListTools(context.Background(), nil)
+		_ = cs.Close()
+		_ = ss.Close()
+		require.NoError(t, err)
+		data, err := json.Marshal(list)
+		require.NoError(t, err)
+		if first == nil {
+			first = data
+		}
+		assert.Equal(t, first, data)
+	}
+	var entries int
+	encodedSchemas.Range(func(key, _ any) bool {
+		if key.(encodedSchemaKey).schema == schema {
+			entries++
+		}
+		return true
+	})
+	assert.Equal(t, 2, entries, "new inventories and annotation clones must reuse the two source-schema keys")
+	after, err := json.Marshal(schema)
+	require.NoError(t, err)
+	assert.Equal(t, original, after)
+}
+
 func TestEncodedSchemasPreserveReplacementsAndErrors(t *testing.T) {
 	t.Parallel()
 	source := &jsonschema.Schema{Type: "object"}
 
@@ -240,6 +240,9 @@ func shouldStripMCPAppsMetadata(ctx context.Context) bool {
 // the client did not advertise the io.modelcontextprotocol/ui extension. The
 // strip happens here (rather than at Build() time) so the per-request
 // context, which carries the client capability, is in scope.
+//
+// Schema definitions must remain immutable and be reused across registrations.
+// Their encodings are retained process-wide, keyed by source schema identity.
 func (r *Inventory) RegisterTools(ctx context.Context, s *mcp.Server, deps any, middleware ...ToolHandlerMiddleware) {
 	tools := r.ToolsForRegistration(ctx)
 	addToolAvailabilityMiddleware(s, tools)