Add Future section to ConfigLoader documentation

- Document current Agent(), Graph(), and Swarm() constructor modifications
- Detail config parameter integration approach before removal
- Highlight API fluidity advantages and developer experience benefits
- Preserve implementation approach for potential future use
- Focus on public interface rather than internal implementation details

Author: vawsgit

docs/experimental/config-loader/overview.md

@@ -181,3 +181,126 @@ Loads and serializes Strands Graph instances via dictionary configurations. Supp
 - `load_graph(config, cache_key=None)` - Load graph from dictionary configuration
 - `serialize_graph(graph)` - Serialize graph to dictionary configuration
 - `clear_cache()` - Clear internal graph cache
+
+---
+
+## Future: Constructor Integration
+
+**Note**: This section documents a future enhancement that would integrate configuration loading directly into the main constructors for improved API fluidity and developer experience.
+
+### Enhanced Constructor Interface
+
+The future implementation would extend the main constructors (`Agent()`, `Graph()`, and `Swarm()`) with a `config` parameter, enabling seamless configuration-driven initialization alongside traditional programmatic instantiation.
+
+#### Agent Constructor Enhancement
+
+```python
+from strands import Agent
+
+# File-based configuration
+agent = Agent(config="agent_config.yaml")
+agent = Agent(config="agent_config.json")
+
+# Dictionary-based configuration
+agent = Agent(config={
+    "model": "us.amazon.nova-pro-v1:0",
+    "system_prompt": "You are a helpful assistant.",
+    "tools": [{"name": "calculator"}]
+})
+
+# Hybrid approach - config with parameter overrides
+agent = Agent(
+    config="base_config.yaml",
+    model="us.amazon.nova-lite-v1:0",  # Override config model
+    system_prompt="Custom prompt"      # Override config prompt
+)
+```
+
+#### Swarm Constructor Enhancement
+
+```python
+from strands.multiagent import Swarm
+
+# File-based configuration
+swarm = Swarm(config="swarm_config.yaml")
+
+# Dictionary-based configuration
+swarm = Swarm(config={
+    "max_handoffs": 15,
+    "agents": [
+        {
+            "name": "researcher",
+            "model": "us.amazon.nova-pro-v1:0",
+            "system_prompt": "You are a research specialist."
+        }
+    ]
+})
+
+# Parameter override capability
+swarm = Swarm(
+    config="base_swarm.yaml",
+    max_handoffs=25,  # Override config value
+    execution_timeout=1200.0
+)
+```
+
+#### Graph Constructor Enhancement
+
+```python
+from strands.multiagent import Graph
+
+# File-based configuration via GraphBuilder
+graph = Graph.from_config("graph_config.yaml").build()
+
+# Dictionary-based configuration
+graph = Graph.from_config({
+    "nodes": [
+        {
+            "id": "analyzer",
+            "agent": {
+                "model": "us.amazon.nova-pro-v1:0",
+                "system_prompt": "Analyze the input data."
+            }
+        }
+    ],
+    "edges": [
+        {"from": "analyzer", "to": "reporter"}
+    ],
+    "entry_points": ["analyzer"]
+}).build()
+```
+
+### API Fluidity Advantages
+
+#### Unified Interface
+- **Consistent Experience**: Single constructor interface supports both programmatic and configuration-driven approaches
+- **Seamless Migration**: Easy transition from code-based to config-based initialization without changing the fundamental API
+- **Reduced Learning Curve**: Developers familiar with the main constructors can immediately use configuration features
+
+#### Flexible Configuration Management
+- **Parameter Override**: Config provides defaults while explicit parameters override specific values
+- **Environment Adaptation**: Same codebase can use different configurations for development, staging, and production
+- **Dynamic Configuration**: Runtime configuration selection based on conditions or user input
+
+#### Enhanced Developer Experience
+- **Reduced Boilerplate**: Configuration files eliminate repetitive parameter specification
+- **Better Maintainability**: Centralized configuration management separate from application logic
+- **Version Control Friendly**: Configuration changes tracked separately from code changes
+- **IDE Support**: Full IntelliSense and type checking for both config and parameter approaches
+
+#### Backward Compatibility
+- **Zero Breaking Changes**: Existing code continues to work unchanged
+- **Gradual Adoption**: Teams can migrate to configuration-driven approach incrementally
+- **Interoperability**: Mix and match approaches within the same application
+
+### Implementation Benefits
+
+The enhanced constructor approach provides superior API fluidity by:
+
+1. **Eliminating Context Switching**: Developers stay within familiar constructor patterns rather than learning separate loader classes
+2. **Reducing Import Complexity**: No need to import and manage separate config loader classes
+3. **Maintaining Type Safety**: Full type hints and validation for both configuration and parameter approaches
+4. **Enabling Hybrid Workflows**: Seamless combination of configuration defaults with runtime parameter overrides
+5. **Preserving Existing Patterns**: All current usage patterns remain valid while adding new capabilities
+
+This approach represents the natural evolution of the Strands Agents API, providing maximum flexibility while maintaining the simplicity and elegance that developers expect from the framework.