@@ -44,21 +44,43 @@ Get your API token at [pipeboard.co/settings](https://pipeboard.co/settings).
 pipeboard login
 ```
 
+## Quick Start
+
+After authenticating, fetch the available tools:
+
+```bash
+pipeboard refresh
+```
+
+This downloads tool definitions from Pipeboard's MCP servers and caches them locally at `~/.pipeboard/tools-cache.json`. Run this once after install, or again when new tools are available.
+
 ## Usage
 
-Commands are auto-generated from Pipeboard's MCP tool definitions. Run `pipeboard --help` to see available commands.
+Commands are auto-generated from Pipeboard's MCP tool definitions. Each ad platform is a top-level command with subcommands for every available operation.
 
 ```bash
 # List Google Ads campaigns
-pipeboard google-ads list-campaigns --customer-id 1234567890
+pipeboard google-ads get-campaigns --customer-id 1234567890
+
+# Execute a raw GAQL query
+pipeboard google-ads execute-gaql-query --customer-id 1234567890 --query "SELECT campaign.id, campaign.name FROM campaign LIMIT 10"
+
+# Get Meta Ads campaign insights
+pipeboard meta-ads get-insights --object-id act_123 --date-preset last_30d
 
-# Get Meta Ads insights
-pipeboard meta-ads get-insights --account-id act_123 --date-range last_30d
+# Create a Meta Ads campaign
+pipeboard meta-ads create-campaign --account-id act_123 --name "Spring Sale" --objective OUTCOME_SALES
+
+# See all available commands for a platform
+pipeboard google-ads --help
+pipeboard meta-ads --help
 
 # Check version
 pipeboard version
 ```
 
+Flags are generated from each tool's JSON Schema — required flags are enforced and enum values are shown in help text.
+
 ## Development
 
 ```bash
 
@@ -0,0 +1,61 @@
+package cmd
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/pipeboard-co/pipeboard-cli/internal/client"
+)
+
+// ToolsCache stores tool definitions fetched from MCP servers.
+type ToolsCache struct {
+	Servers   map[string]ServerToolsCache `json:"servers"`
+	UpdatedAt time.Time                   `json:"updated_at"`
+}
+
+// ServerToolsCache holds the tools for a single MCP server.
+type ServerToolsCache struct {
+	Tools []client.ToolDefinition `json:"tools"`
+}
+
+func toolsCachePath() (string, error) {
+	dir, err := configDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(dir, "tools-cache.json"), nil
+}
+
+func loadToolsCache() (*ToolsCache, error) {
+	path, err := toolsCachePath()
+	if err != nil {
+		return nil, err
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+	var cache ToolsCache
+	if err := json.Unmarshal(data, &cache); err != nil {
+		return nil, err
+	}
+	return &cache, nil
+}
+
+func saveToolsCache(cache *ToolsCache) error {
+	path, err := toolsCachePath()
+	if err != nil {
+		return err
+	}
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0700); err != nil {
+		return err
+	}
+	data, err := json.MarshalIndent(cache, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(path, data, 0600)
+}
@@ -0,0 +1,234 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/pipeboard-co/pipeboard-cli/internal/client"
+	"github.com/spf13/cobra"
+)
+
+// registerDynamicCommands loads the tools cache and registers platform commands.
+func registerDynamicCommands() {
+	cache, err := loadToolsCache()
+	if err != nil {
+		return // No cache — user needs to run 'pipeboard refresh'
+	}
+
+	for _, server := range knownServers {
+		serverCache, ok := cache.Servers[server.Path]
+		if !ok || len(serverCache.Tools) == 0 {
+			continue
+		}
+
+		platformCmd := &cobra.Command{
+			Use:   server.CommandName,
+			Short: server.Description,
+		}
+
+		for _, tool := range serverCache.Tools {
+			cmd := buildToolCommand(server, tool)
+			platformCmd.AddCommand(cmd)
+		}
+
+		rootCmd.AddCommand(platformCmd)
+	}
+}
+
+// toolNameToCommandName converts an MCP tool name to a CLI command name.
+// It strips the platform prefix and converts underscores to hyphens.
+//
+// Examples:
+//
+//	get_google_ads_campaigns  → get-campaigns
+//	execute_google_ads_gaql_query → execute-gaql-query
+//	get_campaigns             → get-campaigns
+func toolNameToCommandName(toolName, prefix string) string {
+	name := toolName
+	if prefix != "" {
+		name = strings.Replace(name, prefix, "", 1)
+	}
+	return strings.ReplaceAll(name, "_", "-")
+}
+
+// InputSchema is a simplified JSON Schema for MCP tool inputs.
+type InputSchema struct {
+	Type       string                    `json:"type"`
+	Properties map[string]PropertySchema `json:"properties"`
+	Required   []string                  `json:"required"`
+}
+
+// PropertySchema describes a single property in the input schema.
+type PropertySchema struct {
+	Type        interface{} `json:"type"` // string or []string (e.g. ["string", "null"])
+	Description string      `json:"description"`
+	Enum        []string    `json:"enum"`
+}
+
+// resolveType returns the primary type as a string, handling union types like ["string", "null"].
+func (p PropertySchema) resolveType() string {
+	switch t := p.Type.(type) {
+	case string:
+		return t
+	case []interface{}:
+		for _, v := range t {
+			if s, ok := v.(string); ok && s != "null" {
+				return s
+			}
+		}
+	}
+	return "string"
+}
+
+func buildToolCommand(server ServerConfig, tool client.ToolDefinition) *cobra.Command {
+	cmdName := toolNameToCommandName(tool.Name, server.ToolPrefix)
+
+	var schema InputSchema
+	if len(tool.InputSchema) > 0 {
+		_ = json.Unmarshal(tool.InputSchema, &schema)
+	}
+
+	requiredSet := make(map[string]bool)
+	for _, r := range schema.Required {
+		requiredSet[r] = true
+	}
+
+	// Flag storage — one map per type we support
+	stringFlags := make(map[string]*string)
+	boolFlags := make(map[string]*bool)
+
+	cmd := &cobra.Command{
+		Use:   cmdName,
+		Short: truncate(tool.Description, 80),
+		Long:  tool.Description,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runDynamicTool(server, tool.Name, schema, stringFlags, boolFlags)
+		},
+	}
+
+	for propName, prop := range schema.Properties {
+		flagName := strings.ReplaceAll(propName, "_", "-")
+		desc := prop.Description
+		if len(prop.Enum) > 0 {
+			desc += " (options: " + strings.Join(prop.Enum, ", ") + ")"
+		}
+
+		switch prop.resolveType() {
+		case "boolean":
+			boolFlags[propName] = cmd.Flags().Bool(flagName, false, desc)
+		default:
+			// string, number, integer, array, object — all accepted as strings
+			stringFlags[propName] = cmd.Flags().String(flagName, "", desc)
+		}
+
+		if requiredSet[propName] {
+			cmd.MarkFlagRequired(flagName)
+		}
+	}
+
+	return cmd
+}
+
+func runDynamicTool(server ServerConfig, toolName string, schema InputSchema, stringFlags map[string]*string, boolFlags map[string]*bool) error {
+	token, err := getToken()
+	if err != nil {
+		return err
+	}
+
+	c := client.New(apiURL, token)
+
+	fmt.Fprintf(os.Stderr, "Connecting to %s/%s...\n", apiURL, server.Path)
+	if err := c.Initialize(server.Path); err != nil {
+		return fmt.Errorf("handshake failed: %w", err)
+	}
+
+	// Build arguments from flag values, coercing types based on schema
+	toolArgs := make(map[string]interface{})
+
+	for propName, val := range stringFlags {
+		if val == nil || *val == "" {
+			continue
+		}
+		prop := schema.Properties[propName]
+		switch prop.resolveType() {
+		case "integer":
+			if n, err := strconv.Atoi(*val); err == nil {
+				toolArgs[propName] = n
+			} else {
+				toolArgs[propName] = *val
+			}
+		case "number":
+			if n, err := strconv.ParseFloat(*val, 64); err == nil {
+				toolArgs[propName] = n
+			} else {
+				toolArgs[propName] = *val
+			}
+		case "object", "array":
+			var parsed interface{}
+			if err := json.Unmarshal([]byte(*val), &parsed); err == nil {
+				toolArgs[propName] = parsed
+			} else {
+				toolArgs[propName] = *val
+			}
+		default:
+			toolArgs[propName] = *val
+		}
+	}
+
+	for propName, val := range boolFlags {
+		if val != nil && *val {
+			toolArgs[propName] = true
+		}
+	}
+
+	fmt.Fprintf(os.Stderr, "Calling %s...\n", toolName)
+	result, err := c.CallTool(server.Path, toolName, toolArgs)
+	if err != nil {
+		return fmt.Errorf("tool call failed: %w", err)
+	}
+
+	return printToolResult(result)
+}
+
+// printToolResult extracts text content from the MCP tools/call response and prints it.
+func printToolResult(raw json.RawMessage) error {
+	var toolResult struct {
+		Content []struct {
+			Type string `json:"type"`
+			Text string `json:"text"`
+		} `json:"content"`
+		IsError bool `json:"isError"`
+	}
+
+	if err := json.Unmarshal(raw, &toolResult); err == nil && len(toolResult.Content) > 0 {
+		for _, item := range toolResult.Content {
+			if item.Type != "text" {
+				continue
+			}
+			// Try to pretty-print as JSON; fall back to plain text
+			var parsed interface{}
+			if err := json.Unmarshal([]byte(item.Text), &parsed); err == nil {
+				enc := json.NewEncoder(os.Stdout)
+				enc.SetIndent("", "  ")
+				enc.Encode(parsed)
+			} else {
+				fmt.Println(item.Text)
+			}
+		}
+		if toolResult.IsError {
+			return fmt.Errorf("tool returned an error")
+		}
+		return nil
+	}
+
+	// Fallback: print raw result
+	var parsed interface{}
+	if err := json.Unmarshal(raw, &parsed); err == nil {
+		return printJSON(parsed)
+	}
+	fmt.Println(string(raw))
+	return nil
+}