diff --git a/Editor/Tools/UpdateComponentTool.cs b/Editor/Tools/UpdateComponentTool.cs
index 390dce0..e86e29c 100644
--- a/Editor/Tools/UpdateComponentTool.cs
+++ b/Editor/Tools/UpdateComponentTool.cs
@@ -238,13 +238,54 @@ private Type FindComponentType(string componentName)
             
             return null;
         }
+
+        /// <summary>
+        /// Recursively search for a field through the type hierarchy
+        /// </summary>
+        /// <param name="type">The type to start searching from</param>
+        /// <param name="fieldName">The name of the field to find</param>
+        /// <returns>The FieldInfo if found, null otherwise</returns>
+        private FieldInfo GetFieldRecursive(Type type, string fieldName)
+        {
+            while (type != null && type != typeof(object))
+            {
+                FieldInfo field = type.GetField(fieldName, 
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
+                if (field != null) 
+                    return field;
+                type = type.BaseType;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Recursively search for a property through the type hierarchy
+        /// </summary>
+        /// <param name="type">The type to start searching from</param>
+        /// <param name="propertyName">The name of the property to find</param>
+        /// <returns>The PropertyInfo if found, null otherwise</returns>
+        private PropertyInfo GetPropertyRecursive(Type type, string propertyName)
+        {
+            while (type != null && type != typeof(object))
+            {
+                PropertyInfo prop = type.GetProperty(propertyName, 
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
+                if (prop != null) 
+                    return prop;
+                type = type.BaseType;
+            }
+            return null;
+        }
         
         /// <summary>
         /// Update component data based on the provided JObject
+        /// Uses SerializedObject API as primary method (handles base class fields and nested paths),
+        /// with reflection as fallback for non-serialized properties.
         /// </summary>
         /// <param name="component">The component to update</param>
         /// <param name="componentData">The data to apply to the component</param>
-        /// <returns>True if the component was updated successfully</returns>
+        /// <param name="errorMessage">Error message if any fields failed to update</param>
+        /// <returns>True if all fields were updated successfully</returns>
         private bool UpdateComponentData(Component component, JObject componentData, out string errorMessage)
         {
             errorMessage = "";
@@ -261,21 +302,36 @@ private bool UpdateComponentData(Component component, JObject componentData, out
             // Record object for undo
             Undo.RecordObject(component, $"Update {componentType.Name} fields");
             
+            // Create SerializedObject for the primary approach
+            SerializedObject serializedObject = new SerializedObject(component);
+            
             // Process each field or property in the component data
             foreach (var property in componentData.Properties())
             {
                 string fieldName = property.Name;
                 JToken fieldValue = property.Value;
                 
-                // Skip null values
-                if (string.IsNullOrEmpty(fieldName) || fieldValue.Type == JTokenType.Null)
+                // Skip null field names
+                if (string.IsNullOrEmpty(fieldName))
+                {
+                    continue;
+                }
+                
+                // Primary approach: Try SerializedObject API first
+                // This handles base class fields and nested paths automatically
+                SerializedProperty serializedProperty = serializedObject.FindProperty(fieldName);
+                
+                if (serializedProperty != null)
                 {
+                    SetSerializedPropertyValue(serializedProperty, fieldValue);
                     continue;
                 }
                 
-                // Try to update field
-                FieldInfo fieldInfo = componentType.GetField(fieldName, 
-                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+                // Fallback: Use reflection with recursive base class search
+                // This handles non-serialized properties that SerializedObject can't access
+                
+                // Try to find field (including in base classes)
+                FieldInfo fieldInfo = GetFieldRecursive(componentType, fieldName);
                     
                 if (fieldInfo != null)
                 {
@@ -284,11 +340,10 @@ private bool UpdateComponentData(Component component, JObject componentData, out
                     continue;
                 }
                 
-                // Try to update property if not found as a field
-                PropertyInfo propertyInfo = componentType.GetProperty(fieldName, 
-                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+                // Try to find property (including in base classes)
+                PropertyInfo propertyInfo = GetPropertyRecursive(componentType, fieldName);
                 
-                if (propertyInfo != null)
+                if (propertyInfo != null && propertyInfo.CanWrite)
                 {
                     object value = ConvertJTokenToValue(fieldValue, propertyInfo.PropertyType);
                     propertyInfo.SetValue(component, value);
@@ -296,12 +351,352 @@ private bool UpdateComponentData(Component component, JObject componentData, out
                 }
                 
                 fullSuccess = false;
-                errorMessage = $"Field or Property  with name '{fieldName}' not found on component '{componentType.Name}'";
+                errorMessage = $"Field or Property with name '{fieldName}' not found on component '{componentType.Name}'";
+                McpLogger.LogWarning($"[MCP Unity] {errorMessage}");
             }
+            
+            // Apply all SerializedObject changes
+            serializedObject.ApplyModifiedProperties();
 
             return fullSuccess;
         }
 
+        /// <summary>
+        /// Update component data using Unity's SerializedObject API
+        /// This properly handles all serialized fields including private ones in base classes
+        /// </summary>
+        /// <param name="component">The component to update</param>
+        /// <param name="componentData">The data to apply to the component</param>
+        /// <param name="errorMessage">Error message if any fields failed to update</param>
+        /// <returns>True if all fields were updated successfully</returns>
+        private bool UpdateComponentDataSerialized(Component component, JObject componentData, out string errorMessage)
+        {
+            errorMessage = "";
+            SerializedObject serializedObject = new SerializedObject(component);
+            bool allFieldsFound = true;
+            
+            foreach (var property in componentData.Properties())
+            {
+                string fieldPath = property.Name;
+                JToken fieldValue = property.Value;
+                
+                // Skip null values
+                if (string.IsNullOrEmpty(fieldPath) || fieldValue.Type == JTokenType.Null)
+                {
+                    continue;
+                }
+                
+                // SerializedObject.FindProperty uses Unity's serialization path
+                SerializedProperty serializedProperty = serializedObject.FindProperty(fieldPath);
+                
+                if (serializedProperty == null)
+                {
+                    McpLogger.LogWarning($"[MCP Unity] SerializedProperty '{fieldPath}' not found on {component.GetType().Name}");
+                    errorMessage = $"Property '{fieldPath}' not found";
+                    allFieldsFound = false;
+                    continue;
+                }
+                
+                SetSerializedPropertyValue(serializedProperty, fieldValue);
+            }
+            
+            serializedObject.ApplyModifiedProperties();
+            return allFieldsFound;
+        }
+
+        /// <summary>
+        /// Set a SerializedProperty value from a JToken
+        /// </summary>
+        /// <param name="prop">The SerializedProperty to set</param>
+        /// <param name="value">The JToken value to apply</param>
+        private void SetSerializedPropertyValue(SerializedProperty prop, JToken value)
+        {
+            switch (prop.propertyType)
+            {
+                case SerializedPropertyType.Integer:
+                    prop.intValue = value.ToObject<int>();
+                    break;
+                    
+                case SerializedPropertyType.Boolean:
+                    prop.boolValue = value.ToObject<bool>();
+                    break;
+                    
+                case SerializedPropertyType.Float:
+                    prop.floatValue = value.ToObject<float>();
+                    break;
+                    
+                case SerializedPropertyType.String:
+                    prop.stringValue = value.ToObject<string>();
+                    break;
+                    
+                case SerializedPropertyType.Color:
+                    if (value.Type == JTokenType.Object)
+                    {
+                        JObject color = (JObject)value;
+                        prop.colorValue = new Color(
+                            color["r"]?.ToObject<float>() ?? 0f,
+                            color["g"]?.ToObject<float>() ?? 0f,
+                            color["b"]?.ToObject<float>() ?? 0f,
+                            color["a"]?.ToObject<float>() ?? 1f
+                        );
+                    }
+                    break;
+                    
+                case SerializedPropertyType.Vector2:
+                    if (value.Type == JTokenType.Object)
+                    {
+                        JObject v2 = (JObject)value;
+                        prop.vector2Value = new Vector2(
+                            v2["x"]?.ToObject<float>() ?? 0f,
+                            v2["y"]?.ToObject<float>() ?? 0f
+                        );
+                    }
+                    break;
+                    
+                case SerializedPropertyType.Vector3:
+                    if (value.Type == JTokenType.Object)
+                    {
+                        JObject v3 = (JObject)value;
+                        prop.vector3Value = new Vector3(
+                            v3["x"]?.ToObject<float>() ?? 0f,
+                            v3["y"]?.ToObject<float>() ?? 0f,
+                            v3["z"]?.ToObject<float>() ?? 0f
+                        );
+                    }
+                    break;
+                    
+                case SerializedPropertyType.Vector4:
+                    if (value.Type == JTokenType.Object)
+                    {
+                        JObject v4 = (JObject)value;
+                        prop.vector4Value = new Vector4(
+                            v4["x"]?.ToObject<float>() ?? 0f,
+                            v4["y"]?.ToObject<float>() ?? 0f,
+                            v4["z"]?.ToObject<float>() ?? 0f,
+                            v4["w"]?.ToObject<float>() ?? 0f
+                        );
+                    }
+                    break;
+                    
+                case SerializedPropertyType.Quaternion:
+                    if (value.Type == JTokenType.Object)
+                    {
+                        JObject q = (JObject)value;
+                        prop.quaternionValue = new Quaternion(
+                            q["x"]?.ToObject<float>() ?? 0f,
+                            q["y"]?.ToObject<float>() ?? 0f,
+                            q["z"]?.ToObject<float>() ?? 0f,
+                            q["w"]?.ToObject<float>() ?? 1f
+                        );
+                    }
+                    break;
+                    
+                case SerializedPropertyType.Rect:
+                    if (value.Type == JTokenType.Object)
+                    {
+                        JObject rect = (JObject)value;
+                        prop.rectValue = new Rect(
+                            rect["x"]?.ToObject<float>() ?? 0f,
+                            rect["y"]?.ToObject<float>() ?? 0f,
+                            rect["width"]?.ToObject<float>() ?? 0f,
+                            rect["height"]?.ToObject<float>() ?? 0f
+                        );
+                    }
+                    break;
+                    
+                case SerializedPropertyType.Bounds:
+                    if (value.Type == JTokenType.Object)
+                    {
+                        JObject bounds = (JObject)value;
+                        JObject center = bounds["center"] as JObject;
+                        JObject size = bounds["size"] as JObject;
+                        prop.boundsValue = new Bounds(
+                            center != null ? new Vector3(
+                                center["x"]?.ToObject<float>() ?? 0f,
+                                center["y"]?.ToObject<float>() ?? 0f,
+                                center["z"]?.ToObject<float>() ?? 0f
+                            ) : Vector3.zero,
+                            size != null ? new Vector3(
+                                size["x"]?.ToObject<float>() ?? 0f,
+                                size["y"]?.ToObject<float>() ?? 0f,
+                                size["z"]?.ToObject<float>() ?? 0f
+                            ) : Vector3.one
+                        );
+                    }
+                    break;
+                    
+                case SerializedPropertyType.Enum:
+                    if (value.Type == JTokenType.String)
+                    {
+                        // Find enum value by name
+                        string[] enumNames = prop.enumNames;
+                        string enumValue = value.ToObject<string>();
+                        int index = Array.IndexOf(enumNames, enumValue);
+                        if (index >= 0)
+                        {
+                            prop.enumValueIndex = index;
+                        }
+                        else
+                        {
+                            // Try case-insensitive match
+                            for (int i = 0; i < enumNames.Length; i++)
+                            {
+                                if (string.Equals(enumNames[i], enumValue, StringComparison.OrdinalIgnoreCase))
+                                {
+                                    prop.enumValueIndex = i;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else if (value.Type == JTokenType.Integer)
+                    {
+                        prop.enumValueIndex = value.ToObject<int>();
+                    }
+                    break;
+                    
+                case SerializedPropertyType.ObjectReference:
+                    // Handle asset references
+                    if (value.Type == JTokenType.String)
+                    {
+                        string assetPath = value.ToObject<string>();
+                        if (!string.IsNullOrEmpty(assetPath))
+                        {
+                            UnityEngine.Object asset = null;
+                            
+                            // Try to load as asset path
+                            if (assetPath.StartsWith("Assets/") || assetPath.StartsWith("Packages/"))
+                            {
+                                asset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(assetPath);
+                            }
+                            
+                            // If not found, try to find by name
+                            if (asset == null)
+                            {
+                                string[] guids = AssetDatabase.FindAssets(assetPath);
+                                if (guids.Length > 0)
+                                {
+                                    string path = AssetDatabase.GUIDToAssetPath(guids[0]);
+                                    asset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(path);
+                                }
+                            }
+                            
+                            prop.objectReferenceValue = asset;
+                        }
+                        else
+                        {
+                            prop.objectReferenceValue = null;
+                        }
+                    }
+                    else if (value.Type == JTokenType.Object)
+                    {
+                        JObject obj = (JObject)value;
+                        string guid = obj["guid"]?.ToObject<string>();
+                        string path = obj["path"]?.ToObject<string>();
+                        
+                        if (!string.IsNullOrEmpty(guid))
+                        {
+                            path = AssetDatabase.GUIDToAssetPath(guid);
+                        }
+                        
+                        if (!string.IsNullOrEmpty(path))
+                        {
+                            prop.objectReferenceValue = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(path);
+                        }
+                    }
+                    else if (value.Type == JTokenType.Null)
+                    {
+                        prop.objectReferenceValue = null;
+                    }
+                    break;
+                    
+                case SerializedPropertyType.LayerMask:
+                    prop.intValue = value.ToObject<int>();
+                    break;
+                    
+                case SerializedPropertyType.Vector2Int:
+                    if (value.Type == JTokenType.Object)
+                    {
+                        JObject v2i = (JObject)value;
+                        prop.vector2IntValue = new Vector2Int(
+                            v2i["x"]?.ToObject<int>() ?? 0,
+                            v2i["y"]?.ToObject<int>() ?? 0
+                        );
+                    }
+                    break;
+                    
+                case SerializedPropertyType.Vector3Int:
+                    if (value.Type == JTokenType.Object)
+                    {
+                        JObject v3i = (JObject)value;
+                        prop.vector3IntValue = new Vector3Int(
+                            v3i["x"]?.ToObject<int>() ?? 0,
+                            v3i["y"]?.ToObject<int>() ?? 0,
+                            v3i["z"]?.ToObject<int>() ?? 0
+                        );
+                    }
+                    break;
+                    
+                case SerializedPropertyType.RectInt:
+                    if (value.Type == JTokenType.Object)
+                    {
+                        JObject rectInt = (JObject)value;
+                        prop.rectIntValue = new RectInt(
+                            rectInt["x"]?.ToObject<int>() ?? 0,
+                            rectInt["y"]?.ToObject<int>() ?? 0,
+                            rectInt["width"]?.ToObject<int>() ?? 0,
+                            rectInt["height"]?.ToObject<int>() ?? 0
+                        );
+                    }
+                    break;
+                    
+                case SerializedPropertyType.BoundsInt:
+                    if (value.Type == JTokenType.Object)
+                    {
+                        JObject boundsInt = (JObject)value;
+                        JObject position = boundsInt["position"] as JObject;
+                        JObject size = boundsInt["size"] as JObject;
+                        prop.boundsIntValue = new BoundsInt(
+                            position != null ? new Vector3Int(
+                                position["x"]?.ToObject<int>() ?? 0,
+                                position["y"]?.ToObject<int>() ?? 0,
+                                position["z"]?.ToObject<int>() ?? 0
+                            ) : Vector3Int.zero,
+                            size != null ? new Vector3Int(
+                                size["x"]?.ToObject<int>() ?? 0,
+                                size["y"]?.ToObject<int>() ?? 0,
+                                size["z"]?.ToObject<int>() ?? 0
+                            ) : Vector3Int.one
+                        );
+                    }
+                    break;
+                    
+                case SerializedPropertyType.Generic:
+                    // For complex types, try to iterate children
+                    if (value.Type == JTokenType.Object)
+                    {
+                        JObject obj = (JObject)value;
+                        foreach (var child in obj.Properties())
+                        {
+                            SerializedProperty childProp = prop.FindPropertyRelative(child.Name);
+                            if (childProp != null)
+                            {
+                                SetSerializedPropertyValue(childProp, child.Value);
+                            }
+                        }
+                    }
+                    break;
+                    
+                case SerializedPropertyType.ArraySize:
+                    prop.intValue = value.ToObject<int>();
+                    break;
+                    
+                default:
+                    McpLogger.LogWarning($"[MCP Unity] Unsupported property type: {prop.propertyType} for {prop.name}");
+                    break;
+            }
+        }
+
         /// <summary>
         /// Convert a JToken to a value of the specified type
         /// </summary>
@@ -387,10 +782,77 @@ private object ConvertJTokenToValue(JToken token, Type targetType)
                 );
             }
             
-            // Handle UnityEngine.Object types;
-            if (targetType == typeof(UnityEngine.Object))
+            // Handle UnityEngine.Object types (assets) by path or GUID
+            if (typeof(UnityEngine.Object).IsAssignableFrom(targetType))
             {
-                return token.ToObject<UnityEngine.Object>();
+                if (token.Type == JTokenType.String)
+                {
+                    string assetPath = token.ToObject<string>();
+                    
+                    if (string.IsNullOrEmpty(assetPath))
+                    {
+                        return null;
+                    }
+                    
+                    // Try to load as asset path
+                    if (assetPath.StartsWith("Assets/") || assetPath.StartsWith("Packages/"))
+                    {
+                        UnityEngine.Object asset = AssetDatabase.LoadAssetAtPath(assetPath, targetType);
+                        if (asset != null)
+                        {
+                            return asset;
+                        }
+                        McpLogger.LogWarning($"[MCP Unity] Could not load asset at path: {assetPath}");
+                    }
+                    
+                    // Try to find by name in project
+                    string[] guids = AssetDatabase.FindAssets($"{assetPath} t:{targetType.Name}");
+                    if (guids.Length > 0)
+                    {
+                        string path = AssetDatabase.GUIDToAssetPath(guids[0]);
+                        return AssetDatabase.LoadAssetAtPath(path, targetType);
+                    }
+                    
+                    // Final fallback - search without type filter
+                    guids = AssetDatabase.FindAssets(assetPath);
+                    if (guids.Length > 0)
+                    {
+                        string path = AssetDatabase.GUIDToAssetPath(guids[0]);
+                        UnityEngine.Object asset = AssetDatabase.LoadAssetAtPath(path, targetType);
+                        if (asset != null)
+                        {
+                            return asset;
+                        }
+                    }
+                    
+                    McpLogger.LogWarning($"[MCP Unity] Could not find asset: {assetPath}");
+                    return null;
+                }
+                else if (token.Type == JTokenType.Object)
+                {
+                    // Handle object with guid or path property
+                    JObject obj = (JObject)token;
+                    string guid = obj["guid"]?.ToObject<string>();
+                    string path = obj["path"]?.ToObject<string>();
+                    
+                    if (!string.IsNullOrEmpty(guid))
+                    {
+                        string assetPath = AssetDatabase.GUIDToAssetPath(guid);
+                        if (!string.IsNullOrEmpty(assetPath))
+                        {
+                            return AssetDatabase.LoadAssetAtPath(assetPath, targetType);
+                        }
+                        McpLogger.LogWarning($"[MCP Unity] Could not find asset with GUID: {guid}");
+                    }
+                    else if (!string.IsNullOrEmpty(path))
+                    {
+                        return AssetDatabase.LoadAssetAtPath(path, targetType);
+                    }
+                }
+                else if (token.Type == JTokenType.Null)
+                {
+                    return null;
+                }
             }
             
             // Handle enum types