diff --git a/cli/azd/extensions/azure.ai.agents/internal/cmd/dev.go b/cli/azd/extensions/azure.ai.agents/internal/cmd/dev.go
new file mode 100644
index 00000000000..8d4f2458221
--- /dev/null
+++ b/cli/azd/extensions/azure.ai.agents/internal/cmd/dev.go
@@ -0,0 +1,370 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/azure/azure-dev/cli/azd/pkg/azdext"
+	"github.com/spf13/cobra"
+)
+
+type devFlags struct {
+	src          string
+	port         int
+	name         string
+	startCommand string
+}
+
+func newRunCommand() *cobra.Command {
+	flags := &devFlags{}
+
+	cmd := &cobra.Command{
+		Use:   "run",
+		Short: "Run your agent locally for development.",
+		Long: `Run your agent locally for development.
+
+Detects the project type (Python, .NET, Node.js), installs dependencies,
+and starts the agent server in the foreground. Press Ctrl+C to stop.
+
+The startup command is read from the startupCommand property of the
+agent service in azure.yaml. If not set, it is auto-detected from the
+project type. Use --start-command to override both.
+
+Use a separate terminal to invoke the running agent:
+  azd ai agent invoke "Hello!"`,
+		Example: `  # Start the agent in the current directory
+  azd ai agent run
+
+  # Start from a specific source directory
+  azd ai agent run --src ./my-agent
+
+  # Start a specific agent by name
+  azd ai agent run --name my-agent
+
+  # Start on a custom port
+  azd ai agent run --port 9090
+
+  # Start with an explicit command
+  azd ai agent run --start-command "python app.py"`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := azdext.WithAccessToken(cmd.Context())
+			setupDebugLogging(cmd.Flags())
+			return runDev(ctx, flags)
+		},
+	}
+
+	cmd.Flags().StringVarP(&flags.src, "src", "s", ".", "Project source directory")
+	cmd.Flags().IntVarP(&flags.port, "port", "p", DefaultPort, "Port to listen on")
+	cmd.Flags().StringVarP(&flags.name, "name", "n", "", "Agent service name (from azure.yaml)")
+	cmd.Flags().StringVarP(&flags.startCommand, "start-command", "c", "",
+		"Explicit startup command (overrides azure.yaml and auto-detection)")
+
+	return cmd
+}
+
+func runDev(ctx context.Context, flags *devFlags) error {
+	projectDir, err := filepath.Abs(flags.src)
+	if err != nil {
+		return fmt.Errorf("invalid source directory: %w", err)
+	}
+
+	if _, err := os.Stat(projectDir); os.IsNotExist(err) {
+		return fmt.Errorf("source directory does not exist: %s", projectDir)
+	}
+
+	// Resolve start command: --start-command flag > azure.yaml startupCommand > detect
+	startCmd := flags.startCommand
+	if startCmd == "" {
+		startCmd = resolveStartupCommandFromService(ctx, flags.name)
+	}
+
+	if startCmd == "" {
+		pt := detectProjectType(projectDir)
+		if pt.StartCmd != "" {
+			startCmd = pt.StartCmd
+			fmt.Printf("Detected %s project. Start command: %s\n", pt.Language, startCmd)
+		} else {
+			return fmt.Errorf(
+				"could not detect project type in %s\n\n"+
+					"Supported project types:\n"+
+					"  - Python (pyproject.toml or requirements.txt)\n"+
+					"  - .NET (*.csproj)\n"+
+					"  - Node.js (package.json)\n\n"+
+					"Use --start-command to specify explicitly, or set startupCommand in azure.yaml",
+				projectDir,
+			)
+		}
+	} else {
+		fmt.Printf("Using startup command from azure.yaml: %s\n", startCmd)
+	}
+
+	// Install dependencies
+	if err := installDependencies(projectDir); err != nil {
+		return fmt.Errorf("failed to install dependencies: %w", err)
+	}
+
+	// Build the command
+	cmdParts := parseCommand(startCmd)
+	if len(cmdParts) == 0 {
+		return fmt.Errorf("empty start command")
+	}
+
+	cmdParts = resolveVenvCommand(projectDir, cmdParts)
+
+	env := os.Environ()
+	env = append(env, fmt.Sprintf("PORT=%d", flags.port))
+
+	// Load azd environment variables (e.g., AZURE_AI_PROJECT_ENDPOINT)
+	// so the agent can reach Azure services during local development
+	if azdEnvVars, err := loadAzdEnvironment(ctx); err == nil {
+		for k, v := range azdEnvVars {
+			env = append(env, fmt.Sprintf("%s=%s", k, v))
+		}
+	}
+
+	url := fmt.Sprintf("http://localhost:%d", flags.port)
+	fmt.Println()
+	fmt.Println("In another terminal, try:")
+	fmt.Printf("  azd ai agent invoke \"Hello!\"\n\n")
+	fmt.Printf("Starting agent on %s (Ctrl+C to stop)\n\n", url)
+
+	// Create command with stdout/stderr piped to terminal
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	proc := exec.CommandContext(ctx, cmdParts[0], cmdParts[1:]...)
+	proc.Dir = projectDir
+	proc.Env = env
+	proc.Stdout = os.Stdout
+	proc.Stderr = os.Stderr
+	proc.Stdin = os.Stdin
+
+	if err := proc.Start(); err != nil {
+		return fmt.Errorf("failed to start agent: %w", err)
+	}
+
+	// Handle Ctrl+C: forward signal to child, then wait for it to exit
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, os.Interrupt)
+	go func() {
+		<-sigCh
+		fmt.Println("\nStopping agent...")
+		cancel()
+	}()
+
+	err = proc.Wait()
+
+	// Suppress the noisy "signal: interrupt" error on Ctrl+C
+	if ctx.Err() != nil {
+		fmt.Println("Agent stopped.")
+		return nil
+	}
+
+	if err != nil {
+		return fmt.Errorf("agent exited: %w", err)
+	}
+	return nil
+}
+
+// --- Dependency installation ---
+
+func installDependencies(projectDir string) error {
+	pt := detectProjectType(projectDir)
+
+	switch pt.Language {
+	case "python":
+		return installPythonDeps(projectDir)
+	case "node":
+		return installNodeDeps(projectDir)
+	case "dotnet":
+		return nil
+	}
+	return nil
+}
+
+func installPythonDeps(projectDir string) error {
+	if _, err := exec.LookPath("uv"); err != nil {
+		fmt.Println("Warning: uv is not installed. Install it from https://docs.astral.sh/uv/")
+		fmt.Println("Falling back to pip...")
+		return installPythonDepsPip(projectDir)
+	}
+
+	venvDir := filepath.Join(projectDir, ".venv")
+	if _, err := os.Stat(venvDir); os.IsNotExist(err) {
+		fmt.Println("Setting up Python environment...")
+		cmd := exec.Command("uv", "venv", venvDir, "--python", ">=3.12")
+		cmd.Dir = projectDir
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
+			return fmt.Errorf("failed to create venv: %w", err)
+		}
+	}
+
+	pythonPath := venvPython(venvDir)
+
+	if fileExists(filepath.Join(projectDir, "pyproject.toml")) {
+		fmt.Println("Installing dependencies (pyproject.toml)...")
+		cmd := exec.Command("uv", "pip", "install", "-e", ".", "--python", pythonPath, "--prerelease", "allow", "--quiet")
+		cmd.Dir = projectDir
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
+			return fmt.Errorf("uv pip install failed: %w", err)
+		}
+		fmt.Println("  ✓ Dependencies installed (pyproject.toml)")
+	}
+
+	if fileExists(filepath.Join(projectDir, "requirements.txt")) {
+		fmt.Println("Installing dependencies (requirements.txt)...")
+		cmd := exec.Command("uv", "pip", "install", "-r", "requirements.txt", "--python", pythonPath, "--prerelease", "allow", "--quiet")
+		cmd.Dir = projectDir
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
+			return fmt.Errorf("uv pip install failed: %w", err)
+		}
+		fmt.Println("  ✓ Dependencies installed (requirements.txt)")
+	}
+
+	return nil
+}
+
+func installPythonDepsPip(projectDir string) error {
+	if fileExists(filepath.Join(projectDir, "requirements.txt")) {
+		fmt.Println("Installing dependencies (requirements.txt)...")
+		cmd := exec.Command("pip", "install", "-r", "requirements.txt", "-q")
+		cmd.Dir = projectDir
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
+			return fmt.Errorf("pip install failed: %w", err)
+		}
+		fmt.Println("  ✓ Dependencies installed (requirements.txt)")
+	}
+	return nil
+}
+
+func installNodeDeps(projectDir string) error {
+	if fileExists(filepath.Join(projectDir, "package.json")) {
+		fmt.Println("Installing dependencies (package.json)...")
+		cmd := exec.Command("npm", "install", "--quiet")
+		cmd.Dir = projectDir
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
+			return fmt.Errorf("npm install failed: %w", err)
+		}
+		fmt.Println("  ✓ Dependencies installed (package.json)")
+	}
+	return nil
+}
+
+// --- Command parsing utilities ---
+
+func parseCommand(cmd string) []string {
+	var parts []string
+	var current strings.Builder
+	inQuote := false
+	quoteChar := byte(0)
+
+	for i := 0; i < len(cmd); i++ {
+		c := cmd[i]
+		if inQuote {
+			if c == quoteChar {
+				inQuote = false
+			} else {
+				current.WriteByte(c)
+			}
+		} else if c == '"' || c == '\'' {
+			inQuote = true
+			quoteChar = c
+		} else if c == ' ' {
+			if current.Len() > 0 {
+				parts = append(parts, current.String())
+				current.Reset()
+			}
+		} else {
+			current.WriteByte(c)
+		}
+	}
+	if current.Len() > 0 {
+		parts = append(parts, current.String())
+	}
+	return parts
+}
+
+func resolveVenvCommand(projectDir string, cmdParts []string) []string {
+	if len(cmdParts) == 0 {
+		return cmdParts
+	}
+
+	venvDir := filepath.Join(projectDir, ".venv")
+	if _, err := os.Stat(venvDir); os.IsNotExist(err) {
+		return cmdParts
+	}
+
+	pythonPath := venvPython(venvDir)
+
+	if cmdParts[0] == "python" || cmdParts[0] == "python3" {
+		cmdParts[0] = pythonPath
+	} else {
+		binDir := venvBinDir(venvDir)
+		binPath := filepath.Join(binDir, cmdParts[0])
+		if fileExists(binPath) {
+			cmdParts[0] = binPath
+		}
+	}
+
+	return cmdParts
+}
+
+func venvPython(venvDir string) string {
+	if runtime.GOOS == "windows" {
+		return filepath.Join(venvDir, "Scripts", "python.exe")
+	}
+	return filepath.Join(venvDir, "bin", "python")
+}
+
+func venvBinDir(venvDir string) string {
+	if runtime.GOOS == "windows" {
+		return filepath.Join(venvDir, "Scripts")
+	}
+	return filepath.Join(venvDir, "bin")
+}
+
+// loadAzdEnvironment reads all key-value pairs from the current azd environment.
+func loadAzdEnvironment(ctx context.Context) (map[string]string, error) {
+	azdClient, err := azdext.NewAzdClient()
+	if err != nil {
+		return nil, err
+	}
+	defer azdClient.Close()
+
+	envResponse, err := azdClient.Environment().GetCurrent(ctx, &azdext.EmptyRequest{})
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := azdClient.Environment().GetValues(ctx, &azdext.GetEnvironmentRequest{
+		Name: envResponse.Environment.Name,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	result := make(map[string]string, len(resp.KeyValues))
+	for _, kv := range resp.KeyValues {
+		result[kv.Key] = kv.Value
+	}
+	return result, nil
+}
diff --git a/cli/azd/extensions/azure.ai.agents/internal/cmd/helpers.go b/cli/azd/extensions/azure.ai.agents/internal/cmd/helpers.go
new file mode 100644
index 00000000000..4a2ad32a4b6
--- /dev/null
+++ b/cli/azd/extensions/azure.ai.agents/internal/cmd/helpers.go
@@ -0,0 +1,386 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package cmd
+
+import (
+	"context"
+	"crypto/rand"
+	"fmt"
+	"math/big"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"azureaiagent/internal/pkg/agents/agent_api"
+
+	"github.com/azure/azure-dev/cli/azd/pkg/azdext"
+)
+
+const (
+	// DefaultPort is the default port for local agent servers.
+	DefaultPort = 8088
+
+	// Environment variable keys for invoke state
+	EnvKeyAgentInvokeName           = "AZD_AI_AGENT_INVOKE_NAME"
+	EnvKeyAgentInvokeSessionID      = "AZD_AI_AGENT_INVOKE_SESSIONID"
+	EnvKeyAgentInvokeConversationID = "AZD_AI_AGENT_INVOKE_CONVERSATIONID"
+)
+
+// getInvokeEnvValue reads an invoke state env var from the current azd environment.
+func getInvokeEnvValue(ctx context.Context, key string) string {
+	azdClient, err := azdext.NewAzdClient()
+	if err != nil {
+		return ""
+	}
+	defer azdClient.Close()
+
+	envResp, err := azdClient.Environment().GetCurrent(ctx, &azdext.EmptyRequest{})
+	if err != nil {
+		return ""
+	}
+
+	val, err := azdClient.Environment().GetValue(ctx, &azdext.GetEnvRequest{
+		EnvName: envResp.Environment.Name,
+		Key:     key,
+	})
+	if err != nil || val.Value == "" {
+		return ""
+	}
+	return val.Value
+}
+
+// setInvokeEnvValue writes an invoke state env var to the current azd environment.
+func setInvokeEnvValue(ctx context.Context, key, value string) error {
+	azdClient, err := azdext.NewAzdClient()
+	if err != nil {
+		return err
+	}
+	defer azdClient.Close()
+
+	envResp, err := azdClient.Environment().GetCurrent(ctx, &azdext.EmptyRequest{})
+	if err != nil {
+		return err
+	}
+
+	_, err = azdClient.Environment().SetValue(ctx, &azdext.SetEnvRequest{
+		EnvName: envResp.Environment.Name,
+		Key:     key,
+		Value:   value,
+	})
+	return err
+}
+
+// resolveSessionID resolves or generates a session ID for invoke.
+// State is stored in the azd environment via AZD_AI_AGENT_INVOKE_SESSIONID.
+func resolveSessionID(ctx context.Context, agentName string, explicit string, forceNew bool) string {
+	if explicit != "" {
+		return explicit
+	}
+
+	currentName := getInvokeEnvValue(ctx, EnvKeyAgentInvokeName)
+	if !forceNew && currentName == agentName {
+		if sid := getInvokeEnvValue(ctx, EnvKeyAgentInvokeSessionID); sid != "" {
+			return sid
+		}
+	}
+
+	sid := generateSessionID()
+	_ = setInvokeEnvValue(ctx, EnvKeyAgentInvokeName, agentName)
+	_ = setInvokeEnvValue(ctx, EnvKeyAgentInvokeSessionID, sid)
+	return sid
+}
+
+// resolveConversationID resolves the conversation ID from the azd environment.
+// Returns empty string if no conversation exists or the agent changed.
+func resolveConversationID(ctx context.Context, agentName string, forceNew bool) string {
+	if forceNew {
+		return ""
+	}
+
+	currentName := getInvokeEnvValue(ctx, EnvKeyAgentInvokeName)
+	if currentName != agentName {
+		return ""
+	}
+
+	return getInvokeEnvValue(ctx, EnvKeyAgentInvokeConversationID)
+}
+
+// saveConversationID persists a conversation ID in the azd environment.
+func saveConversationID(ctx context.Context, agentName, convID string) {
+	_ = setInvokeEnvValue(ctx, EnvKeyAgentInvokeName, agentName)
+	_ = setInvokeEnvValue(ctx, EnvKeyAgentInvokeConversationID, convID)
+}
+
+// generateSessionID creates a random 25-character session ID (lowercase + digits).
+func generateSessionID() string {
+	const chars = "abcdefghijklmnopqrstuvwxyz0123456789"
+	b := make([]byte, 25)
+	for i := range b {
+		n, err := rand.Int(rand.Reader, big.NewInt(int64(len(chars))))
+		if err != nil {
+			panic(fmt.Sprintf("crypto/rand failed: %v", err))
+		}
+		b[i] = chars[n.Int64()]
+	}
+	return string(b)
+}
+
+// detectProjectType detects the project type and suggests a start command.
+type ProjectType struct {
+	Language string // "python", "dotnet", "node", "unknown"
+	StartCmd string // suggested start command
+}
+
+func detectProjectType(projectDir string) ProjectType {
+	// Detect Python entrypoint
+	pyEntry := detectPythonEntrypoint(projectDir)
+
+	// Python with pyproject.toml → uv-managed project
+	if fileExists(filepath.Join(projectDir, "pyproject.toml")) {
+		cmd := "uv run python main.py"
+		if pyEntry != "" {
+			cmd = "uv run python " + pyEntry
+		}
+		return ProjectType{Language: "python", StartCmd: cmd}
+	}
+
+	// Python with requirements.txt
+	if fileExists(filepath.Join(projectDir, "requirements.txt")) {
+		cmd := "python main.py"
+		if pyEntry != "" {
+			cmd = "python " + pyEntry
+		}
+		return ProjectType{Language: "python", StartCmd: cmd}
+	}
+
+	// .NET: find .csproj file and use its name
+	matches, _ := filepath.Glob(filepath.Join(projectDir, "*.csproj"))
+	if len(matches) > 0 {
+		csprojName := filepath.Base(matches[0])
+		return ProjectType{Language: "dotnet", StartCmd: "dotnet " + csprojName}
+	}
+
+	// Node.js: package.json
+	if fileExists(filepath.Join(projectDir, "package.json")) {
+		return ProjectType{Language: "node", StartCmd: "npm start"}
+	}
+
+	// Bare Python entrypoint as fallback
+	if pyEntry != "" {
+		return ProjectType{Language: "python", StartCmd: "python " + pyEntry}
+	}
+
+	return ProjectType{Language: "unknown", StartCmd: ""}
+}
+
+// detectPythonEntrypoint returns the name of the Python entrypoint file found in projectDir.
+func detectPythonEntrypoint(projectDir string) string {
+	for _, name := range []string{"main.py", "app.py"} {
+		if fileExists(filepath.Join(projectDir, name)) {
+			return name
+		}
+	}
+	return ""
+}
+
+// promptStartupCommand detects the project startup command and prompts the user to confirm or override.
+// If flagValue is set (from --startup-command), it is returned directly.
+// If noPrompt is true, the auto-detected value is returned without prompting.
+func promptStartupCommand(
+	ctx context.Context,
+	azdClient *azdext.AzdClient,
+	projectDir string,
+	flagValue string,
+	noPrompt bool,
+) (string, error) {
+	if flagValue != "" {
+		return flagValue, nil
+	}
+
+	detected := detectProjectType(projectDir)
+	defaultCmd := detected.StartCmd
+
+	if noPrompt {
+		return defaultCmd, nil
+	}
+
+	message := "Enter startup command for the agent"
+	if detected.Language != "unknown" && detected.Language != "" {
+		message = fmt.Sprintf("Enter startup command for the agent (detected %s project)", detected.Language)
+	}
+
+	resp, err := azdClient.Prompt().Prompt(ctx, &azdext.PromptRequest{
+		Options: &azdext.PromptOptions{
+			Message:        message,
+			DefaultValue:   defaultCmd,
+			IgnoreHintKeys: true,
+		},
+	})
+	if err != nil {
+		return "", fmt.Errorf("prompting for startup command: %w", err)
+	}
+
+	return resp.Value, nil
+}
+
+// resolveProjectDir resolves a relative targetDir to an absolute path using the azd project root.
+func resolveProjectDir(ctx context.Context, azdClient *azdext.AzdClient, targetDir string) (string, error) {
+	if filepath.IsAbs(targetDir) {
+		return targetDir, nil
+	}
+
+	projectResponse, err := azdClient.Project().Get(ctx, &azdext.EmptyRequest{})
+	if err != nil {
+		return "", fmt.Errorf("getting project path: %w", err)
+	}
+
+	return filepath.Join(projectResponse.Project.Path, targetDir), nil
+}
+
+// parseEndpoint extracts account and project names from a Foundry project endpoint URL.
+// e.g., "https://myaccount.services.ai.azure.com/api/projects/myproject" → ("myaccount", "myproject")
+func parseEndpoint(endpoint string) (account, project string, err error) {
+	endpoint = strings.TrimRight(endpoint, "/")
+	// Extract account from hostname
+	if !strings.Contains(endpoint, "://") {
+		return "", "", fmt.Errorf("invalid endpoint URL: %s", endpoint)
+	}
+	hostPath := strings.SplitN(endpoint, "://", 2)[1]
+	hostParts := strings.SplitN(hostPath, "/", 2)
+	hostname := hostParts[0]
+	account = strings.SplitN(hostname, ".", 2)[0]
+
+	// Extract project from path
+	pathParts := strings.Split(endpoint, "/")
+	if len(pathParts) > 0 {
+		project = pathParts[len(pathParts)-1]
+	}
+	if account == "" || project == "" {
+		return "", "", fmt.Errorf("could not parse account/project from endpoint: %s", endpoint)
+	}
+	return account, project, nil
+}
+
+func fileExists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+// AgentServiceInfo holds the resolved name for an agent service.
+type AgentServiceInfo struct {
+	ServiceName string // azure.yaml service key
+	AgentName   string // agent name (same as service name)
+}
+
+// resolveAgentServiceFromProject finds the first azure.ai.agent service in azure.yaml.
+// The name parameter filters to a specific service; empty means use the first one found.
+// The service name from azure.yaml is used directly as the agent name.
+func resolveAgentServiceFromProject(ctx context.Context, name string) (*AgentServiceInfo, error) {
+	azdClient, err := azdext.NewAzdClient()
+	if err != nil {
+		return nil, fmt.Errorf("failed to create azd client: %w", err)
+	}
+	defer azdClient.Close()
+
+	projectResponse, err := azdClient.Project().Get(ctx, &azdext.EmptyRequest{})
+	if err != nil || projectResponse.Project == nil {
+		return nil, fmt.Errorf("failed to get project config: %w", err)
+	}
+
+	// Find the matching azure.ai.agent service
+	var svc *azdext.ServiceConfig
+	for _, s := range projectResponse.Project.Services {
+		if s.Host != AiAgentHost {
+			continue
+		}
+		if name != "" && s.Name != name {
+			continue
+		}
+		svc = s
+		break
+	}
+
+	if svc == nil {
+		if name != "" {
+			return nil, fmt.Errorf("no azure.ai.agent service named '%s' found in azure.yaml", name)
+		}
+		return nil, fmt.Errorf("no azure.ai.agent service found in azure.yaml")
+	}
+
+	return &AgentServiceInfo{
+		ServiceName: svc.Name,
+		AgentName:   svc.Name,
+	}, nil
+}
+
+// resolveLatestVersion fetches the latest deployed version of an agent via the API.
+func resolveLatestVersion(ctx context.Context, accountName, projectName, agentName string) (string, error) {
+	endpoint, err := resolveAgentEndpoint(ctx, accountName, projectName)
+	if err != nil {
+		return "", err
+	}
+
+	credential, err := newAgentCredential()
+	if err != nil {
+		return "", err
+	}
+
+	client := agent_api.NewAgentClient(endpoint, credential)
+	agent, err := client.GetAgent(ctx, agentName, DefaultAgentAPIVersion)
+	if err != nil {
+		return "", fmt.Errorf("failed to get agent '%s': %w", agentName, err)
+	}
+
+	version := agent.Versions.Latest.Version
+	if version == "" {
+		return "", fmt.Errorf("agent '%s' has no deployed versions", agentName)
+	}
+
+	return version, nil
+}
+
+// resolveStartupCommandFromService reads startupCommand from an azure.ai.agent
+// service's AdditionalProperties. Returns empty string if unavailable.
+func resolveStartupCommandFromService(ctx context.Context, name string) string {
+	azdClient, err := azdext.NewAzdClient()
+	if err != nil {
+		return ""
+	}
+	defer azdClient.Close()
+
+	projectResponse, err := azdClient.Project().Get(ctx, &azdext.EmptyRequest{})
+	if err != nil || projectResponse.Project == nil {
+		return ""
+	}
+
+	for _, s := range projectResponse.Project.Services {
+		if s.Host != AiAgentHost {
+			continue
+		}
+		if name != "" && s.Name != name {
+			continue
+		}
+		if s.AdditionalProperties == nil {
+			return ""
+		}
+		fields := s.AdditionalProperties.GetFields()
+		if fields == nil {
+			return ""
+		}
+		v, ok := fields["startupCommand"]
+		if !ok || v == nil {
+			return ""
+		}
+		return v.GetStringValue()
+	}
+
+	return ""
+}
+
+// toServiceKey converts a service name into the env var key format (uppercase, underscores).
+func toServiceKey(serviceName string) string {
+	key := strings.ReplaceAll(serviceName, " ", "_")
+	key = strings.ReplaceAll(key, "-", "_")
+	return strings.ToUpper(key)
+}
diff --git a/cli/azd/extensions/azure.ai.agents/internal/cmd/init.go b/cli/azd/extensions/azure.ai.agents/internal/cmd/init.go
index f81019fa402..fe8ea5cb2c2 100644
--- a/cli/azd/extensions/azure.ai.agents/internal/cmd/init.go
+++ b/cli/azd/extensions/azure.ai.agents/internal/cmd/init.go
@@ -15,7 +15,6 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
-	"strconv"
 	"strings"
 	"time"
 
@@ -47,9 +46,12 @@ type initFlags struct {
 	*rootFlagsDefinition
 	projectResourceId string
 	manifestPointer   string
+	templateUrl       string
 	src               string
 	host              string
 	env               string
+	infra             bool
+	startupCommand    string
 }
 
 // AiProjectResourceConfig represents the configuration for an AI project resource
@@ -109,7 +111,7 @@ func newInitCommand(rootFlags *rootFlagsDefinition) *cobra.Command {
 	}
 
 	cmd := &cobra.Command{
-		Use:   "init [-m <manifest pointer>] [--src <source directory>]",
+		Use:   "init [-m <manifest pointer>] [-t <template url>] [--src <source directory>]",
 		Short: fmt.Sprintf("Initialize a new AI agent project. %s", color.YellowString("(Preview)")),
 		Args:  cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
@@ -117,6 +119,15 @@ func newInitCommand(rootFlags *rootFlagsDefinition) *cobra.Command {
 
 			setupDebugLogging(cmd.Flags())
 
+			// Validate mutual exclusivity of -t and -m
+			if flags.templateUrl != "" && flags.manifestPointer != "" {
+				return exterrors.Validation(
+					exterrors.CodeInvalidArgs,
+					"--template and --manifest cannot be used together",
+					"use either --template (-t) to initialize from a template repo, or --manifest (-m) to initialize from a manifest file",
+				)
+			}
+
 			azdClient, err := azdext.NewAzdClient()
 			if err != nil {
 				return exterrors.Internal(exterrors.CodeAzdClientFailed, fmt.Sprintf("failed to create azd client: %s", err))
@@ -139,8 +150,22 @@ func newInitCommand(rootFlags *rootFlagsDefinition) *cobra.Command {
 				Timeout: 30 * time.Second,
 			}
 
-			if flags.manifestPointer != "" {
-				azureContext, projectConfig, environment, err := ensureAzureContext(ctx, flags, azdClient)
+			if flags.templateUrl != "" {
+				action := &InitFromTemplateAction{
+					azdClient:  azdClient,
+					flags:      flags,
+					httpClient: httpClient,
+				}
+
+				if err := action.Run(ctx); err != nil {
+					if exterrors.IsCancellation(err) {
+						return exterrors.Cancelled("initialization was cancelled")
+					}
+					return err
+				}
+			} else if flags.manifestPointer != "" {
+				// Ensure project exists first (no subscription needed yet)
+				projectConfig, err := ensureProject(ctx, flags, azdClient)
 				if err != nil {
 					if exterrors.IsCancellation(err) {
 						return exterrors.Cancelled("initialization was cancelled")
@@ -148,16 +173,72 @@ func newInitCommand(rootFlags *rootFlagsDefinition) *cobra.Command {
 					return err
 				}
 
-				credential, err := azidentity.NewAzureDeveloperCLICredential(&azidentity.AzureDeveloperCLICredentialOptions{
-					TenantID:                   azureContext.Scope.TenantId,
-					AdditionallyAllowedTenants: []string{"*"},
-				})
+				// Get or create environment (without forcing subscription/location)
+				existingEnv := getExistingEnvironment(ctx, flags, azdClient)
+				if existingEnv == nil {
+					// Create environment without requiring subscription/location
+					fmt.Println("Lets create a new default azd environment for your project.")
+					envArgs := []string{"env", "new"}
+					if flags.env != "" {
+						envArgs = append(envArgs, flags.env)
+					}
+					workflow := &azdext.Workflow{
+						Name: "env new",
+						Steps: []*azdext.WorkflowStep{
+							{Command: &azdext.WorkflowCommand{Args: envArgs}},
+						},
+					}
+					_, err := azdClient.Workflow().Run(ctx, &azdext.RunWorkflowRequest{
+						Workflow: workflow,
+					})
+					if err != nil {
+						if exterrors.IsCancellation(err) {
+							return exterrors.Cancelled("initialization was cancelled")
+						}
+						return exterrors.Dependency(
+							exterrors.CodeEnvironmentCreationFailed,
+							fmt.Sprintf("failed to create new azd environment: %s", err),
+							"run 'azd env new' manually to create an environment",
+						)
+					}
+					existingEnv = getExistingEnvironment(ctx, flags, azdClient)
+					if existingEnv == nil {
+						return exterrors.Dependency(
+							exterrors.CodeEnvironmentNotFound,
+							"azd environment not found after creation",
+							"run 'azd env new' to create an environment and try again",
+						)
+					}
+				}
+
+				// Build initial azure context from existing env values (may be partially populated)
+				azureContext, err := buildAzureContextFromEnv(ctx, existingEnv.Name, azdClient)
 				if err != nil {
-					return exterrors.Auth(
-						exterrors.CodeCredentialCreationFailed,
-						fmt.Sprintf("failed to create Azure credential: %s", err),
-						"run 'azd auth login' to authenticate",
-					)
+					return err
+				}
+
+				// If --project-id is provided, extract subscription from it
+				if flags.projectResourceId != "" {
+					fp, fpErr := extractProjectDetails(flags.projectResourceId)
+					if fpErr == nil {
+						azureContext.Scope.SubscriptionId = fp.SubscriptionId
+					}
+				}
+
+				// Create credential if we have a tenant
+				var credential azcore.TokenCredential
+				if azureContext.Scope.TenantId != "" {
+					credential, err = azidentity.NewAzureDeveloperCLICredential(&azidentity.AzureDeveloperCLICredentialOptions{
+						TenantID:                   azureContext.Scope.TenantId,
+						AdditionallyAllowedTenants: []string{"*"},
+					})
+					if err != nil {
+						return exterrors.Auth(
+							exterrors.CodeCredentialCreationFailed,
+							fmt.Sprintf("failed to create Azure credential: %s", err),
+							"run 'azd auth login' to authenticate",
+						)
+					}
 				}
 
 				console := input.NewConsole(
@@ -174,16 +255,14 @@ func newInitCommand(rootFlags *rootFlagsDefinition) *cobra.Command {
 				)
 
 				action := &InitAction{
-					azdClient: azdClient,
-					// azureClient:         azure.NewAzureClient(credential),
+					azdClient:    azdClient,
 					azureContext: azureContext,
-					// composedResources:   getComposedResourcesResponse.Resources,
-					console:       console,
-					credential:    credential,
+					console:      console,
+					credential:   credential,
 					projectConfig: projectConfig,
-					environment:   environment,
-					flags:         flags,
-					httpClient:    httpClient,
+					environment:  existingEnv,
+					flags:        flags,
+					httpClient:   httpClient,
 				}
 
 				if err := action.Run(ctx); err != nil {
@@ -217,6 +296,9 @@ func newInitCommand(rootFlags *rootFlagsDefinition) *cobra.Command {
 	cmd.Flags().StringVarP(&flags.manifestPointer, "manifest", "m", "",
 		"Path or URI to an agent manifest to add to your azd project")
 
+	cmd.Flags().StringVarP(&flags.templateUrl, "template", "t", "",
+		"URL to a GitHub template repo containing an agent.yaml or agent.manifest.yaml manifest")
+
 	cmd.Flags().StringVarP(&flags.src, "src", "s", "",
 		"[Optional] Directory to download the agent definition to (defaults to 'src/<agent-id>')")
 
@@ -225,9 +307,116 @@ func newInitCommand(rootFlags *rootFlagsDefinition) *cobra.Command {
 
 	cmd.Flags().StringVarP(&flags.env, "environment", "e", "", "The name of the azd environment to use.")
 
+	cmd.Flags().StringVar(&flags.startupCommand, "startup-command", "",
+		"Startup command for the agent service (e.g., 'uv run python main.py', 'dotnet Agent.csproj')")
+
+	cmd.Flags().BoolVar(&flags.infra, "infra", false,
+		"Include infrastructure-as-code (infra/) from the template. "+
+			"If used in an existing azd project, adds only the infra directory.")
+
 	return cmd
 }
 
+// ensureSubscriptionAndCredential lazily prompts for subscription and creates a credential
+// if they haven't been set up yet. This allows the -m flow to defer Azure prompts until needed.
+func (a *InitAction) ensureSubscriptionAndCredential(ctx context.Context) error {
+	if a.azureContext.Scope.SubscriptionId == "" {
+		fmt.Println()
+		fmt.Println("We need to connect to your Azure subscription. This will be the subscription which contains your ")
+		fmt.Println("Foundry project and where your resources will be provisioned.")
+
+		subscriptionResponse, err := a.azdClient.Prompt().PromptSubscription(ctx, &azdext.PromptSubscriptionRequest{})
+		if err != nil {
+			if exterrors.IsCancellation(err) {
+				return exterrors.Cancelled("subscription selection was cancelled")
+			}
+			return fmt.Errorf("failed to prompt for subscription: %w", err)
+		}
+
+		a.azureContext.Scope.SubscriptionId = subscriptionResponse.Subscription.Id
+		a.azureContext.Scope.TenantId = subscriptionResponse.Subscription.TenantId
+
+		if _, err := a.azdClient.Environment().SetValue(ctx, &azdext.SetEnvRequest{
+			EnvName: a.environment.Name,
+			Key:     "AZURE_TENANT_ID",
+			Value:   a.azureContext.Scope.TenantId,
+		}); err != nil {
+			return fmt.Errorf("failed to set AZURE_TENANT_ID in environment: %w", err)
+		}
+
+		if _, err := a.azdClient.Environment().SetValue(ctx, &azdext.SetEnvRequest{
+			EnvName: a.environment.Name,
+			Key:     "AZURE_SUBSCRIPTION_ID",
+			Value:   a.azureContext.Scope.SubscriptionId,
+		}); err != nil {
+			return fmt.Errorf("failed to set AZURE_SUBSCRIPTION_ID in environment: %w", err)
+		}
+	}
+
+	if a.credential == nil {
+		tenantId := a.azureContext.Scope.TenantId
+		if tenantId == "" {
+			// Look up tenant from subscription
+			tenantResponse, err := a.azdClient.Account().LookupTenant(ctx, &azdext.LookupTenantRequest{
+				SubscriptionId: a.azureContext.Scope.SubscriptionId,
+			})
+			if err != nil {
+				return exterrors.Auth(
+					exterrors.CodeTenantLookupFailed,
+					fmt.Sprintf("failed to lookup tenant for subscription %s: %s", a.azureContext.Scope.SubscriptionId, err),
+					"verify your Azure login with 'azd auth login'",
+				)
+			}
+			tenantId = tenantResponse.TenantId
+			a.azureContext.Scope.TenantId = tenantId
+		}
+
+		credential, err := azidentity.NewAzureDeveloperCLICredential(&azidentity.AzureDeveloperCLICredentialOptions{
+			TenantID:                   tenantId,
+			AdditionallyAllowedTenants: []string{"*"},
+		})
+		if err != nil {
+			return exterrors.Auth(
+				exterrors.CodeCredentialCreationFailed,
+				fmt.Sprintf("failed to create Azure credential: %s", err),
+				"run 'azd auth login' to authenticate",
+			)
+		}
+		a.credential = credential
+	}
+
+	return nil
+}
+
+// ensureLocation lazily prompts for Azure location if not already set.
+func (a *InitAction) ensureLocation(ctx context.Context) error {
+	if a.azureContext.Scope.Location == "" {
+		fmt.Println()
+		fmt.Println("Next, we need to select a default Azure location that will be used as the target for your resources.")
+
+		locationResponse, err := a.azdClient.Prompt().PromptLocation(ctx, &azdext.PromptLocationRequest{
+			AzureContext: a.azureContext,
+		})
+		if err != nil {
+			if exterrors.IsCancellation(err) {
+				return exterrors.Cancelled("location selection was cancelled")
+			}
+			return fmt.Errorf("failed to prompt for location: %w", err)
+		}
+
+		a.azureContext.Scope.Location = locationResponse.Location.Name
+
+		if _, err := a.azdClient.Environment().SetValue(ctx, &azdext.SetEnvRequest{
+			EnvName: a.environment.Name,
+			Key:     "AZURE_LOCATION",
+			Value:   a.azureContext.Scope.Location,
+		}); err != nil {
+			return fmt.Errorf("failed to set AZURE_LOCATION in environment: %w", err)
+		}
+	}
+	return nil
+}
+
 func (a *InitAction) Run(ctx context.Context) error {
 	color.Green("Initializing AI agent project...")
 	fmt.Println()
@@ -248,8 +437,12 @@ func (a *InitAction) Run(ctx context.Context) error {
 
 	// If --manifest is given
 	if a.flags.manifestPointer != "" {
-		// If --project-id is given
+		// If --project-id is given, we need credentials to query the project
 		if a.flags.projectResourceId != "" {
+			if err := a.ensureSubscriptionAndCredential(ctx); err != nil {
+				return err
+			}
+
 			// projectResourceId is a string of the format
 			// /subscriptions/[AZURE_SUBSCRIPTION]/resourceGroups/[AZURE_RESOURCE_GROUP]/providers/Microsoft.CognitiveServices/accounts/[AI_ACCOUNT_NAME]/projects/[AI_PROJECT_NAME]
 			// extract each of those fields from the string, issue an error if it doesn't match the format
@@ -283,7 +476,7 @@ func (a *InitAction) Run(ctx context.Context) error {
 			return exterrors.Validation(
 				exterrors.CodeInvalidAgentManifest,
 				fmt.Sprintf("agent manifest pointer is invalid: '%s' is neither a valid URI nor an existing file path", a.flags.manifestPointer),
-				"provide a valid URL or an existing local agent.yaml/agent.yml path",
+				"provide a valid URL or an existing local agent.yaml/agent.manifest.yaml path",
 			)
 		}
 
@@ -536,26 +729,18 @@ func ensureEnvironment(ctx context.Context, flags *initFlags, azdClient *azdext.
 	return existingEnv, nil
 }
 
-func ensureAzureContext(
+// buildAzureContextFromEnv reads environment values and constructs an AzureContext.
+// The returned context may be partially populated if the environment hasn't been fully configured yet.
+func buildAzureContextFromEnv(
 	ctx context.Context,
-	flags *initFlags,
+	envName string,
 	azdClient *azdext.AzdClient,
-) (*azdext.AzureContext, *azdext.ProjectConfig, *azdext.Environment, error) {
-	project, err := ensureProject(ctx, flags, azdClient)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
-	env, err := ensureEnvironment(ctx, flags, azdClient)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
+) (*azdext.AzureContext, error) {
 	envValues, err := azdClient.Environment().GetValues(ctx, &azdext.GetEnvironmentRequest{
-		Name: env.Name,
+		Name: envName,
 	})
 	if err != nil {
-		return nil, nil, nil, exterrors.Dependency(
+		return nil, exterrors.Dependency(
 			exterrors.CodeEnvironmentValuesFailed,
 			fmt.Sprintf("failed to get environment values: %s", err),
 			"run 'azd env get-values' to verify environment state",
@@ -567,13 +752,34 @@ func ensureAzureContext(
 		envValueMap[value.Key] = value.Value
 	}
 
-	azureContext := &azdext.AzureContext{
+	return &azdext.AzureContext{
 		Scope: &azdext.AzureScope{
 			TenantId:       envValueMap["AZURE_TENANT_ID"],
 			SubscriptionId: envValueMap["AZURE_SUBSCRIPTION_ID"],
 			Location:       envValueMap["AZURE_LOCATION"],
 		},
 		Resources: []string{},
+	}, nil
+}
+
+func ensureAzureContext(
+	ctx context.Context,
+	flags *initFlags,
+	azdClient *azdext.AzdClient,
+) (*azdext.AzureContext, *azdext.ProjectConfig, *azdext.Environment, error) {
+	project, err := ensureProject(ctx, flags, azdClient)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	env, err := ensureEnvironment(ctx, flags, azdClient)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	azureContext, err := buildAzureContextFromEnv(ctx, env.Name, azdClient)
+	if err != nil {
+		return nil, nil, nil, err
 	}
 
 	if azureContext.Scope.SubscriptionId == "" {
@@ -1159,6 +1365,11 @@ func (a *InitAction) downloadAgentYaml(
 
 		content = []byte(contentStr)
 	} else if isRegistry, registryManifest := a.isRegistryUrl(manifestPointer); isRegistry {
+		// Registry URLs require credentials
+		if err := a.ensureSubscriptionAndCredential(ctx); err != nil {
+			return nil, "", err
+		}
+
 		// Handle registry URLs
 		manifestClient := registry_api.NewRegistryAgentManifestClient(registryManifest.registryName, a.credential)
 
@@ -1213,7 +1424,7 @@ func (a *InitAction) downloadAgentYaml(
 		return nil, "", exterrors.Validation(
 			exterrors.CodeInvalidManifestPointer,
 			fmt.Sprintf("manifest pointer '%s' is not a valid local file path, GitHub URL, or registry URL", manifestPointer),
-			"provide a valid URL or an existing local agent.yaml/agent.yml path",
+			"provide a valid URL or an existing local agent.yaml/agent.manifest.yaml path",
 		)
 	}
 
@@ -1246,6 +1457,14 @@ func (a *InitAction) downloadAgentYaml(
 		return nil, "", fmt.Errorf("failed to process manifest parameters: %w", err)
 	}
 
+	// Ensure subscription and credential are available before processing models
+	if err := a.ensureSubscriptionAndCredential(ctx); err != nil {
+		return nil, "", err
+	}
+	if err := a.ensureLocation(ctx); err != nil {
+		return nil, "", err
+	}
+
 	agentManifest, deploymentDetails, err := a.ProcessModels(ctx, agentManifest)
 	if err != nil {
 		return nil, "", fmt.Errorf("failed to process model resources: %w", err)
@@ -1429,6 +1648,25 @@ func (a *InitAction) addToProject(ctx context.Context, targetDir string, agentMa
 		serviceConfig.Docker = &azdext.DockerProjectOptions{
 			RemoteBuild: true,
 		}
+
+		// Prompt for startup command (only for hosted/container agents)
+		absDir, dirErr := resolveProjectDir(ctx, a.azdClient, targetDir)
+		if dirErr != nil {
+			return fmt.Errorf("resolving project directory: %w", dirErr)
+		}
+
+		startupCmd, cmdErr := promptStartupCommand(ctx, a.azdClient, absDir, a.flags.startupCommand, a.flags.NoPrompt)
+		if cmdErr != nil {
+			return fmt.Errorf("prompting for startup command: %w", cmdErr)
+		}
+		if startupCmd != "" {
+			serviceConfig.AdditionalProperties, err = structpb.NewStruct(map[string]interface{}{
+				"startupCommand": startupCmd,
+			})
+			if err != nil {
+				return fmt.Errorf("creating additional properties: %w", err)
+			}
+		}
 	}
 
 	req := &azdext.AddServiceRequest{Service: serviceConfig}
@@ -1446,9 +1684,30 @@ func (a *InitAction) addToProject(ctx context.Context, targetDir string, agentMa
 	return nil
 }
 
+// populateContainerSettings prompts the user to select a container resource preset.
 func (a *InitAction) populateContainerSettings(ctx context.Context) (*project.ContainerSettings, error) {
-	if a.flags.NoPrompt {
-		fmt.Printf("No prompt mode enabled, using default container settings\n")
+	return promptContainerPreset(ctx, a.azdClient)
+}
+
+// promptContainerPreset presents the user with container configuration presets
+// and returns the selected container settings.
+func promptContainerPreset(ctx context.Context, azdClient *azdext.AzdClient) (*project.ContainerSettings, error) {
+	choices := make([]*azdext.SelectChoice, len(project.ContainerPresets))
+	for i, p := range project.ContainerPresets {
+		choices[i] = &azdext.SelectChoice{
+			Label: p.Label,
+			Value: fmt.Sprintf("%d", i),
+		}
+	}
+
+	resp, err := azdClient.Prompt().Select(ctx, &azdext.SelectRequest{
+		Options: &azdext.SelectOptions{
+			Message: "Select a container configuration (can be changed later in azure.yaml):",
+			Choices: choices,
+		},
+	})
+	if err != nil {
+		// Fall back to defaults if prompting fails (e.g., --no-prompt)
 		return &project.ContainerSettings{
 			Resources: &project.ResourceSettings{
 				Memory: project.DefaultMemory,
@@ -1461,80 +1720,23 @@ func (a *InitAction) populateContainerSettings(ctx context.Context) (*project.Co
 		}, nil
 	}
 
-	// Default values
-	defaultMemory := project.DefaultMemory
-	defaultCpu := project.DefaultCpu
-	defaultMinReplicas := fmt.Sprintf("%d", project.DefaultMinReplicas)
-	defaultMaxReplicas := fmt.Sprintf("%d", project.DefaultMaxReplicas)
-
-	// Prompt for memory allocation
-	memoryResp, err := a.azdClient.Prompt().Prompt(ctx, &azdext.PromptRequest{
-		Options: &azdext.PromptOptions{
-			Message:      "Enter desired container memory allocation (e.g., '1Gi', '512Mi')",
-			DefaultValue: defaultMemory,
-		},
-	})
-	if err != nil {
-		return nil, fmt.Errorf("prompting for memory allocation: %w", err)
-	}
-
-	// Prompt for CPU allocation
-	cpuResp, err := a.azdClient.Prompt().Prompt(ctx, &azdext.PromptRequest{
-		Options: &azdext.PromptOptions{
-			Message:      "Enter desired container CPU allocation (e.g., '1', '500m')",
-			DefaultValue: defaultCpu,
-		},
-	})
-	if err != nil {
-		return nil, fmt.Errorf("prompting for CPU allocation: %w", err)
+	idx := 0
+	if resp.Value != nil {
+		idx = int(*resp.Value)
 	}
-
-	// Prompt for minimum replicas
-	minReplicasResp, err := a.azdClient.Prompt().Prompt(ctx, &azdext.PromptRequest{
-		Options: &azdext.PromptOptions{
-			Message:      "Enter desired container minimum number of replicas",
-			DefaultValue: defaultMinReplicas,
-		},
-	})
-	if err != nil {
-		return nil, fmt.Errorf("prompting for minimum replicas: %w", err)
-	}
-
-	// Prompt for maximum replicas
-	maxReplicasResp, err := a.azdClient.Prompt().Prompt(ctx, &azdext.PromptRequest{
-		Options: &azdext.PromptOptions{
-			Message:      "Enter desired container maximum number of replicas",
-			DefaultValue: defaultMaxReplicas,
-		},
-	})
-	if err != nil {
-		return nil, fmt.Errorf("prompting for maximum replicas: %w", err)
-	}
-
-	// Convert string values to appropriate types
-	minReplicas, err := strconv.Atoi(minReplicasResp.Value)
-	if err != nil {
-		return nil, fmt.Errorf("invalid minimum replicas value: %w", err)
-	}
-
-	maxReplicas, err := strconv.Atoi(maxReplicasResp.Value)
-	if err != nil {
-		return nil, fmt.Errorf("invalid maximum replicas value: %w", err)
-	}
-
-	// Validate that max replicas >= min replicas
-	if maxReplicas < minReplicas {
-		return nil, fmt.Errorf("maximum replicas (%d) must be greater than or equal to minimum replicas (%d)", maxReplicas, minReplicas)
+	if idx < 0 || idx >= len(project.ContainerPresets) {
+		idx = 0
 	}
+	preset := project.ContainerPresets[idx]
 
 	return &project.ContainerSettings{
 		Resources: &project.ResourceSettings{
-			Memory: memoryResp.Value,
-			Cpu:    cpuResp.Value,
+			Memory: preset.Memory,
+			Cpu:    preset.Cpu,
 		},
 		Scale: &project.ScaleSettings{
-			MinReplicas: minReplicas,
-			MaxReplicas: maxReplicas,
+			MinReplicas: preset.MinReplicas,
+			MaxReplicas: preset.MaxReplicas,
 		},
 	}, nil
 }
@@ -1670,7 +1872,7 @@ func downloadParentDirectory(
 	// Get parent directory by removing the filename from the file path
 	pathParts := strings.Split(urlInfo.FilePath, "/")
 	if len(pathParts) <= 1 {
-		fmt.Println("The file agent.yaml is at repository root, no parent directory to download")
+		fmt.Println("The agent manifest file is at repository root, no parent directory to download")
 		return nil
 	}
 
diff --git a/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_code.go b/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_code.go
index 9d2be0d018a..fee0aab5cc6 100644
--- a/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_code.go
+++ b/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_code.go
@@ -33,14 +33,15 @@ import (
 )
 
 type InitFromCodeAction struct {
-	azdClient         *azdext.AzdClient
-	flags             *initFlags
-	projectConfig     *azdext.ProjectConfig
-	azureContext      *azdext.AzureContext
-	environment       *azdext.Environment
-	credential        azcore.TokenCredential
-	deploymentDetails []project.Deployment
-	httpClient        *http.Client
+	azdClient            *azdext.AzdClient
+	flags                *initFlags
+	projectConfig        *azdext.ProjectConfig
+	azureContext         *azdext.AzureContext
+	environment          *azdext.Environment
+	credential           azcore.TokenCredential
+	deploymentDetails    []project.Deployment
+	httpClient           *http.Client
+	existingAgentDefName string // agent name from existing AgentDefinition, if found
 }
 
 // templateFileInfo represents a file from the GitHub template repository.
@@ -76,6 +77,20 @@ func (a *InitFromCodeAction) Run(ctx context.Context) error {
 		a.flags.src = relPath
 	}
 
+	// Determine srcDir early (needed for existing definition check)
+	srcDir := a.flags.src
+	if srcDir == "" {
+		srcDir = "."
+	}
+
+	// Check if an existing agent.yaml is an AgentDefinition (not a manifest).
+	// If so, we preserve it rather than overwriting.
+	existingDefName, existingDefPath := findExistingAgentDefinition(srcDir)
+	preserveExistingDef := existingDefPath != ""
+	if preserveExistingDef && existingDefName != "" {
+		a.existingAgentDefName = existingDefName
+	}
+
 	// No manifest pointer provided - process local agent code
 	// Create a definition based on user prompts
 	localDefinition, err := a.createDefinitionFromLocalAgent(ctx)
@@ -84,16 +99,12 @@ func (a *InitFromCodeAction) Run(ctx context.Context) error {
 	}
 
 	if localDefinition != nil {
-		// Default src to current directory when not specified
-		srcDir := a.flags.src
-		if srcDir == "" {
-			srcDir = "."
-		}
-
-		// Write the definition to a file in the src directory
-		_, err := a.writeDefinitionToSrcDir(localDefinition, srcDir)
-		if err != nil {
-			return fmt.Errorf("failed to write definition to src directory: %w", err)
+		if !preserveExistingDef {
+			// Write the definition to a file in the src directory
+			_, err := a.writeDefinitionToSrcDir(localDefinition, srcDir)
+			if err != nil {
+				return fmt.Errorf("failed to write definition to src directory: %w", err)
+			}
 		}
 
 		// Add the agent to the azd project (azure.yaml) services
@@ -101,14 +112,29 @@ func (a *InitFromCodeAction) Run(ctx context.Context) error {
 			return fmt.Errorf("failed to add agent to azure.yaml: %w", err)
 		}
 
-		if srcDir == "." {
-			fmt.Printf("  %s  %s\n", color.GreenString("+"), color.GreenString("agent.yaml"))
+		if preserveExistingDef {
+			fmt.Printf("\n  %s  Existing agent.yaml preserved (not overwritten)\n", color.GreenString("✓"))
+			fmt.Println("\n  Next steps:")
+			fmt.Println("  1. Update your agent.yaml environment variables to reference azd environment values:")
+			fmt.Println("     - AZURE_AI_PROJECT_ENDPOINT   → ${AZURE_AI_PROJECT_ENDPOINT}")
+			fmt.Println("     - AZURE_AI_MODEL_DEPLOYMENT   → ${AZURE_AI_MODEL_DEPLOYMENT_NAME}")
+			fmt.Println("  2. Update your code to use these environment variables if needed.")
+			fmt.Println("  3. Verify the Docker image and container settings in azure.yaml match your project.")
+			fmt.Printf("  4. Run %s to run your agent locally, or %s to deploy.\n",
+				color.HiBlueString("azd ai agent run"),
+				color.HiBlueString("azd ai agent deploy"))
 		} else {
-			fmt.Printf("  %s  %s\n", color.GreenString("+"), color.GreenString("%s/agent.yaml", srcDir))
-		}
+			if srcDir == "." {
+				fmt.Printf("  %s  %s\n", color.GreenString("+"), color.GreenString("agent.yaml"))
+			} else {
+				fmt.Printf("  %s  %s\n", color.GreenString("+"), color.GreenString("%s/agent.yaml", srcDir))
+			}
 
-		fmt.Println("\nYou can customize environment variables, cpu, memory, and replica settings in the agent.yaml.")
-		fmt.Printf("Next steps: Run %s to deploy your agent to Microsoft Foundry.\n", color.HiBlueString("azd up"))
+			fmt.Println("\nYou can customize environment variables, cpu, memory, and replica settings in the agent.yaml.")
+			fmt.Printf("Next steps:\n")
+			fmt.Printf("  Run %s to run your agent locally.\n", color.HiBlueString("azd ai agent run"))
+			fmt.Printf("  Run %s to deploy your agent to Microsoft Foundry.\n", color.HiBlueString("azd ai agent deploy"))
+		}
 	}
 
 	return nil
@@ -398,10 +424,10 @@ func (a *InitFromCodeAction) scaffoldTemplate(ctx context.Context, azdClient *az
 // createDefinitionFromLocalAgent creates a ContainerAgent for local agent code
 // This is used when no manifest pointer is provided and we need to scaffold a new agent
 func (a *InitFromCodeAction) createDefinitionFromLocalAgent(ctx context.Context) (*agent_yaml.ContainerAgent, error) {
-	// Default agent name to sanitized cwd
+	// Default agent name to existing definition name if available
 	defaultName := "my-agent"
-	if cwd, err := os.Getwd(); err == nil {
-		defaultName = sanitizeAgentName(filepath.Base(cwd))
+	if a.existingAgentDefName != "" {
+		defaultName = a.existingAgentDefName
 	}
 
 	// Prompt user for agent name
@@ -1203,6 +1229,39 @@ func (a *InitFromCodeAction) lookupAcrResourceId(ctx context.Context, subscripti
 	return "", fmt.Errorf("container registry '%s' not found in subscription", registryName)
 }
 
+// findExistingAgentDefinition checks if an existing agent.yaml or agent.yml in srcDir
+// is an AgentDefinition (has "kind" field, no "template" field) rather than an AgentManifest.
+// Returns the agent name and file path if found, or empty strings if not.
+func findExistingAgentDefinition(srcDir string) (name string, filePath string) {
+	for _, fileName := range []string{"agent.yaml", "agent.yml"} {
+		path := filepath.Join(srcDir, fileName)
+		content, err := os.ReadFile(path)
+		if err != nil {
+			continue
+		}
+
+		var generic map[string]interface{}
+		if err := yaml.Unmarshal(content, &generic); err != nil {
+			continue
+		}
+
+		// An AgentDefinition has a "kind" field but no "template" field
+		_, hasKind := generic["kind"]
+		_, hasTemplate := generic["template"]
+
+		if hasKind && !hasTemplate {
+			if nameVal, ok := generic["name"]; ok {
+				if nameStr, ok := nameVal.(string); ok {
+					return nameStr, path
+				}
+			}
+			return "", path
+		}
+	}
+
+	return "", ""
+}
+
 // writeDefinitionToSrcDir writes a ContainerAgent to a YAML file in the src directory and returns the path
 func (a *InitFromCodeAction) writeDefinitionToSrcDir(definition *agent_yaml.ContainerAgent, srcDir string) (string, error) {
 	// Ensure the src directory exists
@@ -1230,21 +1289,15 @@ func (a *InitFromCodeAction) writeDefinitionToSrcDir(definition *agent_yaml.Cont
 func (a *InitFromCodeAction) addToProject(ctx context.Context, targetDir string, agentName string) error {
 	var agentConfig = project.ServiceTargetAgentConfig{}
 
-	agentConfig.Container = &project.ContainerSettings{
-		Resources: &project.ResourceSettings{
-			Memory: project.DefaultMemory,
-			Cpu:    project.DefaultCpu,
-		},
-		Scale: &project.ScaleSettings{
-			MinReplicas: project.DefaultMinReplicas,
-			MaxReplicas: project.DefaultMaxReplicas,
-		},
+	containerSettings, err := promptContainerPreset(ctx, a.azdClient)
+	if err != nil {
+		return fmt.Errorf("failed to populate container settings: %w", err)
 	}
+	agentConfig.Container = containerSettings
 
 	agentConfig.Deployments = a.deploymentDetails
 
 	var agentConfigStruct *structpb.Struct
-	var err error
 	if agentConfigStruct, err = project.MarshalStruct(&agentConfig); err != nil {
 		return fmt.Errorf("failed to marshal agent config: %w", err)
 	}
@@ -1262,6 +1315,25 @@ func (a *InitFromCodeAction) addToProject(ctx context.Context, targetDir string,
 		RemoteBuild: true,
 	}
 
+	// Prompt for startup command
+	absDir, err := resolveProjectDir(ctx, a.azdClient, targetDir)
+	if err != nil {
+		return fmt.Errorf("resolving project directory: %w", err)
+	}
+
+	startupCmd, err := promptStartupCommand(ctx, a.azdClient, absDir, a.flags.startupCommand, a.flags.NoPrompt)
+	if err != nil {
+		return fmt.Errorf("prompting for startup command: %w", err)
+	}
+	if startupCmd != "" {
+		serviceConfig.AdditionalProperties, err = structpb.NewStruct(map[string]interface{}{
+			"startupCommand": startupCmd,
+		})
+		if err != nil {
+			return fmt.Errorf("creating additional properties: %w", err)
+		}
+	}
+
 	req := &azdext.AddServiceRequest{Service: serviceConfig}
 
 	if _, err := a.azdClient.Project().AddService(ctx, req); err != nil {
@@ -1269,11 +1341,9 @@ func (a *InitFromCodeAction) addToProject(ctx context.Context, targetDir string,
 	}
 
 	fmt.Printf("\nAdded your agent as a service entry named '%s' under the file azure.yaml.\n", agentName)
-	fmt.Printf("To provision and deploy the whole solution, use %s.\n", color.HiBlueString("azd up"))
-	fmt.Printf(
-		"If you already have your project provisioned with hosted agents requirements, "+
-			"you can directly use %s.\n",
-		color.HiBlueString("azd deploy %s", agentName))
+	fmt.Printf("Run %s to run your agent locally, or %s to deploy.\n",
+		color.HiBlueString("azd ai agent run"),
+		color.HiBlueString("azd ai agent deploy"))
 	return nil
 }
 
diff --git a/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_code_test.go b/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_code_test.go
index 4f63f8da4b7..61159798c69 100644
--- a/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_code_test.go
+++ b/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_code_test.go
@@ -498,6 +498,140 @@ func TestWriteDefinitionToSrcDir(t *testing.T) {
 	})
 }
 
+func TestFindExistingAgentDefinition(t *testing.T) {
+	t.Parallel()
+
+	t.Run("no agent.yaml returns empty", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+
+		name, path := findExistingAgentDefinition(dir)
+		if name != "" || path != "" {
+			t.Errorf("expected empty, got name=%q path=%q", name, path)
+		}
+	})
+
+	t.Run("AgentDefinition with kind and name returns both", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+
+		content := `kind: hosted
+name: my-existing-agent
+protocols:
+  - protocol: responses
+    version: v1
+`
+		if err := os.WriteFile(filepath.Join(dir, "agent.yaml"), []byte(content), 0644); err != nil {
+			t.Fatal(err)
+		}
+
+		name, path := findExistingAgentDefinition(dir)
+		if name != "my-existing-agent" {
+			t.Errorf("name = %q, want %q", name, "my-existing-agent")
+		}
+		if path == "" {
+			t.Error("expected non-empty path")
+		}
+	})
+
+	t.Run("AgentDefinition in agent.yml", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+
+		content := `kind: prompt
+name: yml-agent
+`
+		if err := os.WriteFile(filepath.Join(dir, "agent.yml"), []byte(content), 0644); err != nil {
+			t.Fatal(err)
+		}
+
+		name, path := findExistingAgentDefinition(dir)
+		if name != "yml-agent" {
+			t.Errorf("name = %q, want %q", name, "yml-agent")
+		}
+		if path == "" {
+			t.Error("expected non-empty path")
+		}
+	})
+
+	t.Run("AgentManifest with template returns empty", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+
+		content := `name: manifest-agent
+template:
+  kind: hosted
+  name: manifest-agent
+parameters: {}
+`
+		if err := os.WriteFile(filepath.Join(dir, "agent.yaml"), []byte(content), 0644); err != nil {
+			t.Fatal(err)
+		}
+
+		name, path := findExistingAgentDefinition(dir)
+		if name != "" || path != "" {
+			t.Errorf("expected empty for manifest, got name=%q path=%q", name, path)
+		}
+	})
+
+	t.Run("invalid YAML returns empty", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+
+		content := `not: valid: yaml: [[[`
+		if err := os.WriteFile(filepath.Join(dir, "agent.yaml"), []byte(content), 0644); err != nil {
+			t.Fatal(err)
+		}
+
+		name, path := findExistingAgentDefinition(dir)
+		if name != "" || path != "" {
+			t.Errorf("expected empty for invalid yaml, got name=%q path=%q", name, path)
+		}
+	})
+
+	t.Run("agent.yaml preferred over agent.yml", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+
+		yamlContent := `kind: hosted
+name: yaml-agent
+`
+		ymlContent := `kind: hosted
+name: yml-agent
+`
+		if err := os.WriteFile(filepath.Join(dir, "agent.yaml"), []byte(yamlContent), 0644); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(dir, "agent.yml"), []byte(ymlContent), 0644); err != nil {
+			t.Fatal(err)
+		}
+
+		name, _ := findExistingAgentDefinition(dir)
+		if name != "yaml-agent" {
+			t.Errorf("name = %q, want %q (agent.yaml should be preferred)", name, "yaml-agent")
+		}
+	})
+
+	t.Run("AgentDefinition with kind but no name returns empty name with path", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+
+		content := `kind: workflow
+`
+		if err := os.WriteFile(filepath.Join(dir, "agent.yaml"), []byte(content), 0644); err != nil {
+			t.Fatal(err)
+		}
+
+		name, path := findExistingAgentDefinition(dir)
+		if name != "" {
+			t.Errorf("name = %q, want empty", name)
+		}
+		if path == "" {
+			t.Error("expected non-empty path for AgentDefinition with kind")
+		}
+	})
+}
+
 func TestFoundryDeploymentInfo(t *testing.T) {
 	t.Parallel()
 
diff --git a/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_template.go b/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_template.go
new file mode 100644
index 00000000000..c6deeb35d42
--- /dev/null
+++ b/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_template.go
@@ -0,0 +1,1240 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	posixpath "path"
+	"path/filepath"
+	"slices"
+	"strings"
+
+	"azureaiagent/internal/exterrors"
+	"azureaiagent/internal/pkg/agents/agent_yaml"
+	"azureaiagent/internal/pkg/agents/registry_api"
+	"azureaiagent/internal/project"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
+	"github.com/azure/azure-dev/cli/azd/pkg/azdext"
+	"github.com/azure/azure-dev/cli/azd/pkg/ux"
+	"github.com/fatih/color"
+	"google.golang.org/protobuf/types/known/structpb"
+	"gopkg.in/yaml.v3"
+)
+
+type InitFromTemplateAction struct {
+	azdClient         *azdext.AzdClient
+	flags             *initFlags
+	projectConfig     *azdext.ProjectConfig
+	azureContext      *azdext.AzureContext
+	environment       *azdext.Environment
+	credential        azcore.TokenCredential
+	deploymentDetails []project.Deployment
+	httpClient        *http.Client
+}
+
+func (a *InitFromTemplateAction) Run(ctx context.Context) error {
+	color.Green("Initializing AI agent project from template...")
+	fmt.Println()
+
+	a.azureContext = &azdext.AzureContext{
+		Scope:     &azdext.AzureScope{},
+		Resources: []string{},
+	}
+
+	// 1. Resolve the template URL
+	repoUrl, branch := resolveTemplateUrl(a.flags.templateUrl)
+	repoSlug := extractRepoSlug(repoUrl)
+
+	// 2. Check if project already exists
+	projectResponse, projErr := a.azdClient.Project().Get(ctx, &azdext.EmptyRequest{})
+	if projErr != nil {
+		// No project exists — scaffold from the template repo directly into cwd.
+		// This uses the same scaffoldTemplate approach (GitHub API tree + collision handling)
+		// so that the template's azure.yaml, infra/, and agent sources are placed here.
+		if repoSlug == "" {
+			return exterrors.Validation(
+				exterrors.CodeInvalidArgs,
+				fmt.Sprintf("could not extract owner/repo from template URL: %s", repoUrl),
+				"provide a valid GitHub URL, owner/repo, or repo name",
+			)
+		}
+
+		if branch == "" {
+			branch = "main"
+		}
+
+		if err := a.scaffoldFromTemplate(ctx, repoSlug, branch); err != nil {
+			if exterrors.IsCancellation(err) {
+				return exterrors.Cancelled("project initialization was cancelled")
+			}
+			return exterrors.Dependency(
+				exterrors.CodeScaffoldTemplateFailed,
+				fmt.Sprintf("failed to scaffold template: %s", err),
+				"",
+			)
+		}
+
+		projectResponse, projErr = a.azdClient.Project().Get(ctx, &azdext.EmptyRequest{})
+		if projErr != nil {
+			return exterrors.Dependency(
+				exterrors.CodeProjectNotFound,
+				fmt.Sprintf("failed to get project after template initialization: %s", projErr),
+				"",
+			)
+		}
+
+		fmt.Println()
+	} else if a.flags.infra {
+		// Project already exists + --infra: copy only infra/ from the template
+		fmt.Println("Project already exists. Downloading template to add infrastructure files...")
+
+		templateDir, err := a.downloadTemplate(ctx, repoUrl, branch)
+		if err != nil {
+			return fmt.Errorf("downloading template: %w", err)
+		}
+		defer os.RemoveAll(templateDir)
+
+		infraSrc := filepath.Join(templateDir, "infra")
+		if _, statErr := os.Stat(infraSrc); os.IsNotExist(statErr) {
+			return exterrors.Validation(
+				exterrors.CodeInvalidArgs,
+				"the template repository does not contain an infra/ directory",
+				"choose a template that includes infrastructure-as-code, or remove the --infra flag",
+			)
+		}
+
+		if err := copyDirectory(infraSrc, "infra"); err != nil {
+			return fmt.Errorf("copying infra directory: %w", err)
+		}
+
+		color.Green("\nInfrastructure files added from template successfully!")
+		fmt.Println("The infra/ directory has been added to your project.")
+		fmt.Printf("Next steps: Run %s to provision and deploy.\n", color.HiBlueString("azd up"))
+		return nil
+	} else {
+		// Project already exists — clone template to temp dir and copy agent files
+		fmt.Println("Project already exists. Downloading template to add agent...")
+
+		templateDir, err := a.downloadTemplate(ctx, repoUrl, branch)
+		if err != nil {
+			return fmt.Errorf("downloading template: %w", err)
+		}
+		defer os.RemoveAll(templateDir)
+
+		// Find agent.yaml and copy its parent directory to the target
+		agentYamlPath, err := findAgentYaml(templateDir)
+		if err != nil {
+			return err
+		}
+
+		content, err := os.ReadFile(agentYamlPath)
+		if err != nil {
+			return fmt.Errorf("reading agent.yaml: %w", err)
+		}
+
+		agentManifest, err := agent_yaml.LoadAndValidateAgentManifest(content)
+		if err != nil {
+			return fmt.Errorf("validating agent.yaml: %w", err)
+		}
+
+		// Determine target directory
+		agentName := agentManifest.Name
+		if agentName == "" {
+			agentName = "my-agent"
+		}
+
+		targetDir := a.flags.src
+		if targetDir == "" {
+			targetDir = filepath.Join("src", agentName)
+		}
+
+		agentYamlDir := filepath.Dir(agentYamlPath)
+		if err := os.MkdirAll(targetDir, 0755); err != nil {
+			return fmt.Errorf("creating target directory: %w", err)
+		}
+		if err := copyDirectory(agentYamlDir, targetDir); err != nil {
+			return fmt.Errorf("copying template files: %w", err)
+		}
+	}
+
+	if projectResponse.Project == nil {
+		return exterrors.Dependency(
+			exterrors.CodeProjectNotFound,
+			"project not found",
+			"",
+		)
+	}
+	a.projectConfig = projectResponse.Project
+
+	// 3. Find agent.yaml in the project directory (either scaffolded or existing)
+	projectPath := a.projectConfig.Path
+	agentYamlPath, err := findAgentYaml(projectPath)
+	if err != nil {
+		return exterrors.Validation(
+			exterrors.CodeAgentYamlNotFound,
+			"no agent manifest found in the template repository",
+			"the template must contain an agent.yaml or agent.manifest.yaml file (searched root, src/*/, and all subdirectories). "+
+				"Add an agent manifest to your template, or use 'azd ai agent init' without -t to create one interactively",
+		)
+	}
+
+	// 4. Read and parse the agent.yaml
+	content, err := os.ReadFile(agentYamlPath)
+	if err != nil {
+		return fmt.Errorf("reading agent.yaml: %w", err)
+	}
+
+	agentManifest, err := agent_yaml.LoadAndValidateAgentManifest(content)
+	if err != nil {
+		return fmt.Errorf("validating agent.yaml: %w", err)
+	}
+
+	fmt.Println("✓ Found and validated agent.yaml from template")
+
+	// 5. Prompt for agent name (default from manifest)
+	defaultName := agentManifest.Name
+	if defaultName == "" {
+		defaultName = "my-agent"
+	}
+
+	promptResp, err := a.azdClient.Prompt().Prompt(ctx, &azdext.PromptRequest{
+		Options: &azdext.PromptOptions{
+			Message:      "Enter a name for your agent:",
+			DefaultValue: defaultName,
+		},
+	})
+	if err != nil {
+		if exterrors.IsCancellation(err) {
+			return exterrors.Cancelled("agent name prompt was cancelled")
+		}
+		return fmt.Errorf("failed to prompt for agent name: %w", err)
+	}
+	agentName := sanitizeAgentName(promptResp.Value)
+	agentManifest.Name = agentName
+
+	// 6. Create azd environment (deferred - like init-with-code)
+	if a.environment == nil {
+		if err := a.createEnvironment(ctx, agentName+"-dev"); err != nil {
+			return fmt.Errorf("failed to create azd environment: %w", err)
+		}
+	}
+
+	// 7. Determine target directory for the agent source
+	targetDir := a.flags.src
+	if targetDir == "" {
+		relPath, relErr := filepath.Rel(projectPath, filepath.Dir(agentYamlPath))
+		if relErr == nil && relPath != "." {
+			targetDir = relPath
+		} else {
+			targetDir = filepath.Join("src", agentName)
+		}
+	}
+
+	// If src path is absolute, convert it to relative path compared to the azd project path
+	if filepath.IsAbs(targetDir) {
+		relPath, relErr := filepath.Rel(projectPath, targetDir)
+		if relErr != nil {
+			return fmt.Errorf("failed to convert src path to relative path: %w", relErr)
+		}
+		targetDir = relPath
+	}
+
+	// 8. Process manifest parameters (use defaults where available)
+	agentManifest, err = registry_api.ProcessManifestParameters(ctx, agentManifest, a.azdClient, a.flags.NoPrompt)
+	if err != nil {
+		return fmt.Errorf("failed to process manifest parameters: %w", err)
+	}
+
+	// 9. Process models using the init-with-code flow (Deploy new / Use existing / Skip)
+	agentManifest, err = a.processModelsInteractive(ctx, agentManifest)
+	if err != nil {
+		return fmt.Errorf("failed to process models: %w", err)
+	}
+
+	// 10. Write the processed agent.yaml back
+	templateContent, err := yaml.Marshal(agentManifest.Template)
+	if err != nil {
+		return fmt.Errorf("marshaling agent manifest to YAML: %w", err)
+	}
+
+	annotation := "# yaml-language-server: $schema=https://raw.githubusercontent.com/microsoft/AgentSchema/refs/heads/main/schemas/v1.0/ContainerAgent.yaml"
+	agentFilePath := filepath.Join(projectPath, targetDir, "agent.yaml")
+	agentFileContent := annotation + "\n\n" + string(templateContent)
+	if err := os.WriteFile(agentFilePath, []byte(agentFileContent), 0644); err != nil {
+		return fmt.Errorf("writing agent.yaml: %w", err)
+	}
+
+	// 11. Add to project with smart defaults
+	if err := a.addToProject(ctx, targetDir, agentManifest); err != nil {
+		return fmt.Errorf("failed to add agent to azure.yaml: %w", err)
+	}
+
+	color.Green("\nAI agent initialized from template successfully!")
+	fmt.Printf("Next steps:\n")
+	if len(a.deploymentDetails) > 0 {
+		fmt.Printf("  Run %s to provision infrastructure and deploy the model.\n", color.HiBlueString("azd provision"))
+	}
+	fmt.Printf("  Run %s to run your agent locally.\n", color.HiBlueString("azd ai agent run"))
+	fmt.Printf("  Run %s to deploy your agent to Microsoft Foundry.\n", color.HiBlueString("azd ai agent deploy"))
+
+	return nil
+}
+
+// scaffoldFromTemplate downloads a GitHub template repo into the current directory,
+// checking for file collisions before writing. Unlike scaffoldTemplate in init_from_code.go,
+// this downloads ALL files from the repo (not just infra/ and azure.yaml).
+func (a *InitFromTemplateAction) scaffoldFromTemplate(ctx context.Context, repoSlug string, branch string) error {
+	ghToken := gitHubToken()
+
+	apiUrl := fmt.Sprintf("https://api.github.com/repos/%s/git/trees/%s?recursive=1", repoSlug, branch)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, apiUrl, nil)
+	if err != nil {
+		return fmt.Errorf("creating tree request: %w", err)
+	}
+	req.Header.Set("Accept", "application/vnd.github.v3+json")
+	setGitHubAuthHeader(req, ghToken)
+
+	resp, err := a.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("fetching repo tree: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		if resp.StatusCode == http.StatusForbidden || resp.StatusCode == http.StatusTooManyRequests {
+			return fmt.Errorf(
+				"fetching repo tree: status %d (GitHub API rate limit may have been exceeded; "+
+					"set GITHUB_TOKEN or GH_TOKEN environment variable to increase the limit)",
+				resp.StatusCode,
+			)
+		}
+		return fmt.Errorf("fetching repo tree: status %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("reading tree response: %w", err)
+	}
+
+	var treeResp struct {
+		Tree []struct {
+			Path string `json:"path"`
+			Type string `json:"type"`
+		} `json:"tree"`
+	}
+	if err := json.Unmarshal(body, &treeResp); err != nil {
+		return fmt.Errorf("parsing tree response: %w", err)
+	}
+
+	// Collect all blob files from the repo
+	var files []templateFileInfo
+	for _, entry := range treeResp.Tree {
+		if entry.Type != "blob" {
+			continue
+		}
+		cleanPath := posixpath.Clean(entry.Path)
+		if posixpath.IsAbs(cleanPath) || strings.HasPrefix(cleanPath, "..") {
+			return fmt.Errorf("invalid path in repository tree: %s", entry.Path)
+		}
+		downloadURL := fmt.Sprintf("https://raw.githubusercontent.com/%s/%s/%s", repoSlug, branch, cleanPath)
+		collides := false
+		if _, statErr := os.Stat(filepath.FromSlash(cleanPath)); statErr == nil {
+			collides = true
+		}
+		files = append(files, templateFileInfo{
+			Path:     cleanPath,
+			URL:      downloadURL,
+			Collides: collides,
+		})
+	}
+
+	if len(files) == 0 {
+		return fmt.Errorf("template repository %s has no files", repoSlug)
+	}
+
+	// Sort for consistent display
+	slices.SortFunc(files, func(a, b templateFileInfo) int {
+		return strings.Compare(a.Path, b.Path)
+	})
+
+	// Classify into new and colliding
+	var newFiles, collidingFiles []templateFileInfo
+	for _, f := range files {
+		if f.Collides {
+			collidingFiles = append(collidingFiles, f)
+		} else {
+			newFiles = append(newFiles, f)
+		}
+	}
+
+	// Display the file list, collapsing infra/ files into a single summary line
+	fmt.Print("\nThe following files will be created from the template:\n\n")
+	infraCount := 0
+	infraCollides := false
+	for _, f := range files {
+		if strings.HasPrefix(f.Path, "infra/") {
+			infraCount++
+			if f.Collides {
+				infraCollides = true
+			}
+			continue
+		}
+		if f.Collides {
+			fmt.Printf("  %s  %s\n", color.YellowString("!"), color.YellowString(f.Path))
+		} else {
+			fmt.Printf("  %s  %s\n", color.GreenString("+"), color.GreenString(f.Path))
+		}
+	}
+	if infraCount > 0 {
+		summary := fmt.Sprintf("infra/ (+%d files)", infraCount)
+		if infraCollides {
+			fmt.Printf("  %s  %s\n", color.YellowString("!"), color.YellowString(summary))
+		} else {
+			fmt.Printf("  %s  %s\n", color.GreenString("+"), color.GreenString(summary))
+		}
+	}
+	fmt.Println()
+
+	// Handle collisions
+	overwriteCollisions := false
+	if len(collidingFiles) > 0 {
+		fmt.Printf("%s %d file(s) already exist and would be overwritten.\n\n",
+			color.YellowString("Warning:"), len(collidingFiles))
+
+		conflictChoices := []*azdext.SelectChoice{
+			{Label: "Overwrite existing files", Value: "overwrite"},
+			{Label: "Skip existing files (keep my versions)", Value: "skip"},
+			{Label: "Cancel", Value: "cancel"},
+		}
+
+		conflictResp, err := a.azdClient.Prompt().Select(ctx, &azdext.SelectRequest{
+			Options: &azdext.SelectOptions{
+				Message: "How would you like to handle existing files?",
+				Choices: conflictChoices,
+			},
+		})
+		if err != nil {
+			return fmt.Errorf("prompting for conflict resolution: %w", err)
+		}
+
+		selectedValue := conflictChoices[*conflictResp.Value].Value
+		switch selectedValue {
+		case "overwrite":
+			overwriteCollisions = true
+		case "skip":
+			overwriteCollisions = false
+		case "cancel":
+			return fmt.Errorf("operation cancelled, no changes were made")
+		}
+	} else {
+		// No collisions - confirm to proceed
+		confirmResp, err := a.azdClient.Prompt().Confirm(ctx, &azdext.ConfirmRequest{
+			Options: &azdext.ConfirmOptions{
+				Message:      "Initialize from the template?",
+				DefaultValue: to.Ptr(true),
+			},
+		})
+		if err != nil {
+			return fmt.Errorf("prompting for confirmation: %w", err)
+		}
+		if !*confirmResp.Value {
+			return fmt.Errorf("operation cancelled, no changes were made")
+		}
+	}
+
+	// Download and write files
+	filesToWrite := newFiles
+	if overwriteCollisions {
+		filesToWrite = files
+	}
+
+	spinner := ux.NewSpinner(&ux.SpinnerOptions{
+		Text:        fmt.Sprintf("Downloading template (%d files)...", len(filesToWrite)),
+		ClearOnStop: true,
+	})
+	if err := spinner.Start(ctx); err != nil {
+		return fmt.Errorf("starting spinner: %w", err)
+	}
+
+	for _, f := range filesToWrite {
+		localPath := filepath.FromSlash(f.Path)
+
+		dir := filepath.Dir(localPath)
+		if dir != "." {
+			if err := os.MkdirAll(dir, 0755); err != nil {
+				_ = spinner.Stop(ctx)
+				return fmt.Errorf("creating directory %s: %w", dir, err)
+			}
+		}
+
+		fileReq, err := http.NewRequestWithContext(ctx, http.MethodGet, f.URL, nil)
+		if err != nil {
+			_ = spinner.Stop(ctx)
+			return fmt.Errorf("creating request for %s: %w", f.Path, err)
+		}
+		setGitHubAuthHeader(fileReq, ghToken)
+
+		fileResp, err := a.httpClient.Do(fileReq)
+		if err != nil {
+			_ = spinner.Stop(ctx)
+			return fmt.Errorf("downloading %s: %w", f.Path, err)
+		}
+		if fileResp.StatusCode != http.StatusOK {
+			fileResp.Body.Close()
+			_ = spinner.Stop(ctx)
+			return fmt.Errorf("downloading %s: status %d", f.Path, fileResp.StatusCode)
+		}
+
+		fileContent, err := io.ReadAll(fileResp.Body)
+		fileResp.Body.Close()
+		if err != nil {
+			_ = spinner.Stop(ctx)
+			return fmt.Errorf("reading %s: %w", f.Path, err)
+		}
+
+		if err := os.WriteFile(localPath, fileContent, 0644); err != nil {
+			_ = spinner.Stop(ctx)
+			return fmt.Errorf("writing %s: %w", localPath, err)
+		}
+	}
+
+	if err := spinner.Stop(ctx); err != nil {
+		return fmt.Errorf("stopping spinner: %w", err)
+	}
+
+	skipped := len(files) - len(filesToWrite)
+	if skipped > 0 {
+		fmt.Printf("  Template initialized: %d file(s) written, %d file(s) skipped.\n", len(filesToWrite), skipped)
+	} else {
+		fmt.Printf("  Template initialized: %d file(s) written.\n", len(filesToWrite))
+	}
+
+	return nil
+}
+
+// resolveTemplateUrl resolves a template URL to a full GitHub URL and optional branch.
+// Supports:
+//   - Full GitHub URL: https://github.com/owner/repo → as-is
+//   - Full URL with /tree/branch: https://github.com/owner/repo/tree/main → repo URL + branch
+//   - owner/repo → https://github.com/owner/repo
+//   - repo → https://github.com/Azure-Samples/repo
+func resolveTemplateUrl(templateUrl string) (repoUrl string, branch string) {
+	// Handle full URLs
+	if strings.HasPrefix(templateUrl, "https://") || strings.HasPrefix(templateUrl, "http://") {
+		// Check for /tree/branch pattern in the URL
+		if idx := strings.Index(templateUrl, "/tree/"); idx != -1 {
+			repoUrl = templateUrl[:idx]
+			branch = templateUrl[idx+len("/tree/"):]
+			// Strip trailing slash from branch if present
+			branch = strings.TrimRight(branch, "/")
+			return repoUrl, branch
+		}
+		return templateUrl, ""
+	}
+
+	// Handle owner/repo format (contains a slash)
+	if strings.Contains(templateUrl, "/") {
+		return "https://github.com/" + templateUrl, ""
+	}
+
+	// Handle bare repo name → Azure-Samples/{repo}
+	return "https://github.com/Azure-Samples/" + templateUrl, ""
+}
+
+// downloadTemplate downloads a template repository using shallow clone, falling back to GitHub API.
+// Returns a path to a temporary directory containing the template files.
+func (a *InitFromTemplateAction) downloadTemplate(ctx context.Context, repoUrl string, branch string) (string, error) {
+	tmpDir, err := os.MkdirTemp("", "azd-agent-template-*")
+	if err != nil {
+		return "", fmt.Errorf("creating temp directory: %w", err)
+	}
+
+	spinner := ux.NewSpinner(&ux.SpinnerOptions{
+		Text:        "Downloading template...",
+		ClearOnStop: true,
+	})
+	if err := spinner.Start(ctx); err != nil {
+		os.RemoveAll(tmpDir)
+		return "", fmt.Errorf("starting spinner: %w", err)
+	}
+
+	// Try shallow clone first
+	cloneErr := a.shallowClone(ctx, repoUrl, branch, tmpDir)
+	if cloneErr != nil {
+		// Fall back to GitHub API download
+		fmt.Printf("Git clone failed (%v), falling back to GitHub API download...\n", cloneErr)
+
+		// Clean up the temp dir and recreate
+		os.RemoveAll(tmpDir)
+		tmpDir, err = os.MkdirTemp("", "azd-agent-template-*")
+		if err != nil {
+			_ = spinner.Stop(ctx)
+			return "", fmt.Errorf("creating temp directory: %w", err)
+		}
+
+		if apiErr := a.downloadViaGitHubAPI(ctx, repoUrl, branch, tmpDir); apiErr != nil {
+			_ = spinner.Stop(ctx)
+			os.RemoveAll(tmpDir)
+			return "", exterrors.Dependency(
+				exterrors.CodeTemplateDownloadFailed,
+				fmt.Sprintf("failed to download template from %s: clone error: %v, API error: %v", repoUrl, cloneErr, apiErr),
+				"verify the URL is correct and you have access to the repository",
+			)
+		}
+	}
+
+	if err := spinner.Stop(ctx); err != nil {
+		os.RemoveAll(tmpDir)
+		return "", fmt.Errorf("stopping spinner: %w", err)
+	}
+
+	return tmpDir, nil
+}
+
+// shallowClone performs a git clone --depth 1 into the target directory.
+func (a *InitFromTemplateAction) shallowClone(ctx context.Context, repoUrl string, branch string, target string) error {
+	args := []string{"clone", "--depth", "1"}
+	if branch != "" {
+		args = append(args, "--branch", branch)
+	}
+	args = append(args, repoUrl, target)
+
+	cmd := exec.CommandContext(ctx, "git", args...)
+	cmd.Stdout = io.Discard
+	cmd.Stderr = io.Discard
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("git clone: %w", err)
+	}
+
+	// Strip .git directory
+	if err := os.RemoveAll(filepath.Join(target, ".git")); err != nil {
+		return fmt.Errorf("removing .git: %w", err)
+	}
+
+	return nil
+}
+
+// downloadViaGitHubAPI downloads a repository's files using the GitHub API tree endpoint.
+func (a *InitFromTemplateAction) downloadViaGitHubAPI(ctx context.Context, repoUrl string, branch string, target string) error {
+	// Extract owner/repo from the URL
+	repoSlug := extractRepoSlug(repoUrl)
+	if repoSlug == "" {
+		return fmt.Errorf("could not extract owner/repo from URL: %s", repoUrl)
+	}
+
+	if branch == "" {
+		branch = "main"
+	}
+
+	ghToken := gitHubToken()
+	apiUrl := fmt.Sprintf("https://api.github.com/repos/%s/git/trees/%s?recursive=1", repoSlug, branch)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, apiUrl, nil)
+	if err != nil {
+		return fmt.Errorf("creating tree request: %w", err)
+	}
+	req.Header.Set("Accept", "application/vnd.github.v3+json")
+	setGitHubAuthHeader(req, ghToken)
+
+	resp, err := a.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("fetching repo tree: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("fetching repo tree: status %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("reading tree response: %w", err)
+	}
+
+	var treeResp struct {
+		Tree []struct {
+			Path string `json:"path"`
+			Type string `json:"type"`
+		} `json:"tree"`
+	}
+	if err := json.Unmarshal(body, &treeResp); err != nil {
+		return fmt.Errorf("parsing tree response: %w", err)
+	}
+
+	// Download all blob files
+	for _, entry := range treeResp.Tree {
+		if entry.Type != "blob" {
+			continue
+		}
+
+		cleanPath := posixpath.Clean(entry.Path)
+		if posixpath.IsAbs(cleanPath) || strings.HasPrefix(cleanPath, "..") {
+			return fmt.Errorf("invalid path in repository tree: %s", entry.Path)
+		}
+
+		localPath := filepath.Join(target, filepath.FromSlash(cleanPath))
+		dir := filepath.Dir(localPath)
+		if err := os.MkdirAll(dir, 0755); err != nil {
+			return fmt.Errorf("creating directory %s: %w", dir, err)
+		}
+
+		downloadURL := fmt.Sprintf("https://raw.githubusercontent.com/%s/%s/%s", repoSlug, branch, cleanPath)
+		fileReq, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
+		if err != nil {
+			return fmt.Errorf("creating request for %s: %w", cleanPath, err)
+		}
+		setGitHubAuthHeader(fileReq, ghToken)
+
+		fileResp, err := a.httpClient.Do(fileReq)
+		if err != nil {
+			return fmt.Errorf("downloading %s: %w", cleanPath, err)
+		}
+		if fileResp.StatusCode != http.StatusOK {
+			fileResp.Body.Close()
+			return fmt.Errorf("downloading %s: status %d", cleanPath, fileResp.StatusCode)
+		}
+
+		fileContent, err := io.ReadAll(fileResp.Body)
+		fileResp.Body.Close()
+		if err != nil {
+			return fmt.Errorf("reading %s: %w", cleanPath, err)
+		}
+
+		if err := os.WriteFile(localPath, fileContent, 0644); err != nil {
+			return fmt.Errorf("writing %s: %w", localPath, err)
+		}
+	}
+
+	return nil
+}
+
+// extractRepoSlug extracts "owner/repo" from a GitHub URL.
+func extractRepoSlug(repoUrl string) string {
+	// Strip protocol and check for github.com
+	url := repoUrl
+	for _, prefix := range []string{"https://github.com/", "http://github.com/"} {
+		if strings.HasPrefix(url, prefix) {
+			url = strings.TrimPrefix(url, prefix)
+			// Split remaining path and take first two segments
+			parts := strings.SplitN(strings.TrimRight(url, "/"), "/", 3)
+			if len(parts) >= 2 && parts[0] != "" && parts[1] != "" {
+				return parts[0] + "/" + parts[1]
+			}
+			return ""
+		}
+	}
+
+	return ""
+}
+
+// agentYamlNames lists the recognized agent definition/manifest filenames in priority order.
+var agentYamlNames = []string{"agent.yaml", "agent.yml", "agent.manifest.yaml", "agent.manifest.yml"}
+
+// findAgentYaml searches for agent.yaml in the downloaded template directory.
+// Search order: root → src/*/ → **/
+func findAgentYaml(dir string) (string, error) {
+	// 1. Check root
+	for _, name := range agentYamlNames {
+		p := filepath.Join(dir, name)
+		if _, err := os.Stat(p); err == nil {
+			return p, nil
+		}
+	}
+
+	// 2. Check src/*/
+	srcDir := filepath.Join(dir, "src")
+	if entries, err := os.ReadDir(srcDir); err == nil {
+		for _, entry := range entries {
+			if !entry.IsDir() {
+				continue
+			}
+			for _, name := range agentYamlNames {
+				p := filepath.Join(srcDir, entry.Name(), name)
+				if _, err := os.Stat(p); err == nil {
+					return p, nil
+				}
+			}
+		}
+	}
+
+	// 3. Recursive search
+	agentYamlNameSet := make(map[string]bool, len(agentYamlNames))
+	for _, name := range agentYamlNames {
+		agentYamlNameSet[name] = true
+	}
+
+	var found string
+	_ = filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
+		if err != nil || found != "" {
+			return filepath.SkipDir
+		}
+		base := filepath.Base(path)
+		if agentYamlNameSet[base] {
+			found = path
+			return filepath.SkipAll
+		}
+		return nil
+	})
+
+	if found != "" {
+		return found, nil
+	}
+
+	return "", exterrors.Dependency(
+		exterrors.CodeAgentYamlNotFound,
+		"no agent manifest found in the template repository",
+		"ensure the template repo contains an agent.yaml or agent.manifest.yaml file at the root, in src/<name>/, or in a subdirectory",
+	)
+}
+
+// processModelsInteractive uses the init-with-code model selection flow
+// (Deploy new / Use existing / Skip) instead of the manifest flow's automatic model processing.
+func (a *InitFromTemplateAction) processModelsInteractive(ctx context.Context, manifest *agent_yaml.AgentManifest) (*agent_yaml.AgentManifest, error) {
+	// Check if the manifest has model resources
+	hasModelResources := false
+	for _, resource := range manifest.Resources {
+		resourceBytes, err := yaml.Marshal(resource)
+		if err != nil {
+			continue
+		}
+		var resourceDef agent_yaml.Resource
+		if err := yaml.Unmarshal(resourceBytes, &resourceDef); err != nil {
+			continue
+		}
+		if resourceDef.Kind == agent_yaml.ResourceKindModel {
+			hasModelResources = true
+			break
+		}
+	}
+
+	if !hasModelResources {
+		return manifest, nil
+	}
+
+	// Ask user how they want to configure the model
+	modelConfigChoices := []*azdext.SelectChoice{
+		{Label: "Deploy a new model from the catalog", Value: "new"},
+		{Label: "Select an existing model deployment from a Foundry project", Value: "existing"},
+		{Label: "Skip model configuration", Value: "skip"},
+	}
+
+	modelConfigResp, err := a.azdClient.Prompt().Select(ctx, &azdext.SelectRequest{
+		Options: &azdext.SelectOptions{
+			Message: "How would you like to configure a model for your agent?",
+			Choices: modelConfigChoices,
+		},
+	})
+	if err != nil {
+		if exterrors.IsCancellation(err) {
+			return nil, exterrors.Cancelled("model configuration choice was cancelled")
+		}
+		return nil, fmt.Errorf("failed to prompt for model configuration choice: %w", err)
+	}
+	modelConfigChoice := modelConfigChoices[*modelConfigResp.Value].Value
+
+	switch modelConfigChoice {
+	case "new":
+		if err := a.ensureSubscriptionAndLocation(ctx); err != nil {
+			return nil, err
+		}
+
+		selectedModel, err := a.selectNewModel(ctx)
+		if err != nil {
+			return nil, fmt.Errorf("failed to select new model: %w", err)
+		}
+
+		modelDetails, err := a.resolveModelDeploymentNoPrompt(ctx, selectedModel, a.azureContext.Scope.Location)
+		if err != nil {
+			return nil, fmt.Errorf("failed to resolve model deployment: %w", err)
+		}
+
+		a.deploymentDetails = append(a.deploymentDetails, project.Deployment{
+			Name: modelDetails.ModelName,
+			Model: project.DeploymentModel{
+				Name:    modelDetails.ModelName,
+				Format:  modelDetails.Format,
+				Version: modelDetails.Version,
+			},
+			Sku: project.DeploymentSku{
+				Name:     modelDetails.Sku.Name,
+				Capacity: int(modelDetails.Capacity),
+			},
+		})
+
+	case "existing":
+		if err := a.ensureSubscription(ctx); err != nil {
+			return nil, err
+		}
+
+		spinner := ux.NewSpinner(&ux.SpinnerOptions{
+			Text:        "Searching for Foundry projects in your subscription...",
+			ClearOnStop: true,
+		})
+		if err := spinner.Start(ctx); err != nil {
+			return nil, fmt.Errorf("failed to start spinner: %w", err)
+		}
+
+		projects, err := a.listFoundryProjects(ctx, a.azureContext.Scope.SubscriptionId)
+		if stopErr := spinner.Stop(ctx); stopErr != nil {
+			return nil, stopErr
+		}
+		if err != nil {
+			return nil, fmt.Errorf("failed to list Foundry projects: %w", err)
+		}
+
+		if len(projects) == 0 {
+			fmt.Println("No Foundry projects found. Skipping model configuration.")
+			return manifest, nil
+		}
+
+		// Let user pick a Foundry project
+		projectChoices := make([]*azdext.SelectChoice, len(projects))
+		for i, p := range projects {
+			projectChoices[i] = &azdext.SelectChoice{
+				Label: fmt.Sprintf("%s / %s (%s)", p.AccountName, p.ProjectName, p.Location),
+				Value: fmt.Sprintf("%d", i),
+			}
+		}
+
+		projectResp, err := a.azdClient.Prompt().Select(ctx, &azdext.SelectRequest{
+			Options: &azdext.SelectOptions{
+				Message: "Select a Foundry project:",
+				Choices: projectChoices,
+			},
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to prompt for project selection: %w", err)
+		}
+
+		selectedProject := projects[*projectResp.Value]
+		a.azureContext.Scope.Location = selectedProject.Location
+
+		if err := a.processExistingFoundryProject(ctx, selectedProject); err != nil {
+			return nil, fmt.Errorf("failed to process Foundry project: %w", err)
+		}
+
+		// List deployments
+		depSpinner := ux.NewSpinner(&ux.SpinnerOptions{
+			Text:        "Searching for model deployments...",
+			ClearOnStop: true,
+		})
+		if err := depSpinner.Start(ctx); err != nil {
+			return nil, fmt.Errorf("starting spinner: %w", err)
+		}
+
+		deployments, err := a.listProjectDeployments(ctx, selectedProject.SubscriptionId, selectedProject.ResourceGroupName, selectedProject.AccountName)
+		if stopErr := depSpinner.Stop(ctx); stopErr != nil {
+			return nil, stopErr
+		}
+		if err != nil {
+			return nil, fmt.Errorf("listing deployments: %w", err)
+		}
+
+		if len(deployments) == 0 {
+			fmt.Println("No existing deployments found. Skipping model configuration.")
+			return manifest, nil
+		}
+
+		deployChoices := make([]*azdext.SelectChoice, len(deployments))
+		for i, d := range deployments {
+			label := fmt.Sprintf("%s (%s v%s, %s)", d.Name, d.ModelName, d.Version, d.SkuName)
+			deployChoices[i] = &azdext.SelectChoice{
+				Label: label,
+				Value: d.Name,
+			}
+		}
+
+		deployResp, err := a.azdClient.Prompt().Select(ctx, &azdext.SelectRequest{
+			Options: &azdext.SelectOptions{
+				Message: "Select a model deployment:",
+				Choices: deployChoices,
+			},
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to prompt for deployment selection: %w", err)
+		}
+
+		d := deployments[*deployResp.Value]
+		a.deploymentDetails = append(a.deploymentDetails, project.Deployment{
+			Name: d.Name,
+			Model: project.DeploymentModel{
+				Name:    d.ModelName,
+				Format:  d.ModelFormat,
+				Version: d.Version,
+			},
+			Sku: project.DeploymentSku{
+				Name:     d.SkuName,
+				Capacity: d.SkuCapacity,
+			},
+		})
+
+		if err := a.setEnvVar(ctx, "AZURE_AI_MODEL_DEPLOYMENT_NAME", d.Name); err != nil {
+			return nil, fmt.Errorf("failed to set AZURE_AI_MODEL_DEPLOYMENT_NAME: %w", err)
+		}
+
+	case "skip":
+		// Nothing to do
+	}
+
+	return manifest, nil
+}
+
+// addToProject adds the agent service to the azd project with smart defaults.
+func (a *InitFromTemplateAction) addToProject(ctx context.Context, targetDir string, agentManifest *agent_yaml.AgentManifest) error {
+	containerSettings, err := promptContainerPreset(ctx, a.azdClient)
+	if err != nil {
+		return fmt.Errorf("failed to populate container settings: %w", err)
+	}
+
+	agentConfig := project.ServiceTargetAgentConfig{
+		Deployments: a.deploymentDetails,
+		Container:   containerSettings,
+	}
+
+	// Handle tool resources that require connection names - use resource ID as default
+	if agentManifest.Resources != nil {
+		for _, resource := range agentManifest.Resources {
+			if toolResource, ok := resource.(agent_yaml.ToolResource); ok {
+				if toolResource.Id == "bing_grounding" || toolResource.Id == "azure_ai_search" {
+					agentConfig.Resources = append(agentConfig.Resources, project.Resource{
+						Resource:       toolResource.Id,
+						ConnectionName: toolResource.Id,
+					})
+				}
+			}
+		}
+	}
+
+	var agentConfigStruct *structpb.Struct
+	if agentConfigStruct, err = project.MarshalStruct(&agentConfig); err != nil {
+		return fmt.Errorf("failed to marshal agent config: %w", err)
+	}
+
+	serviceConfig := &azdext.ServiceConfig{
+		Name:         strings.ReplaceAll(agentManifest.Name, " ", ""),
+		RelativePath: targetDir,
+		Host:         AiAgentHost,
+		Language:     "docker",
+		Config:       agentConfigStruct,
+		Docker: &azdext.DockerProjectOptions{
+			RemoteBuild: true,
+		},
+	}
+
+	// Prompt for startup command
+	absDir, dirErr := resolveProjectDir(ctx, a.azdClient, targetDir)
+	if dirErr != nil {
+		return fmt.Errorf("resolving project directory: %w", dirErr)
+	}
+
+	startupCmd, cmdErr := promptStartupCommand(ctx, a.azdClient, absDir, a.flags.startupCommand, a.flags.NoPrompt)
+	if cmdErr != nil {
+		return fmt.Errorf("prompting for startup command: %w", cmdErr)
+	}
+	if startupCmd != "" {
+		serviceConfig.AdditionalProperties, err = structpb.NewStruct(map[string]interface{}{
+			"startupCommand": startupCmd,
+		})
+		if err != nil {
+			return fmt.Errorf("creating additional properties: %w", err)
+		}
+	}
+
+	req := &azdext.AddServiceRequest{Service: serviceConfig}
+	if _, err := a.azdClient.Project().AddService(ctx, req); err != nil {
+		return fmt.Errorf("adding agent service to project: %w", err)
+	}
+
+	fmt.Printf("\nAdded your agent as a service entry named '%s' under the file azure.yaml.\n", agentManifest.Name)
+	fmt.Printf("Run %s to run your agent locally, or %s to deploy.\n",
+		color.HiBlueString("azd ai agent run"),
+		color.HiBlueString("azd ai agent deploy"))
+	return nil
+}
+
+// The following methods delegate to InitFromCodeAction's implementations for shared functionality.
+// This avoids duplication while keeping the template action as a separate type.
+
+func (a *InitFromTemplateAction) ensureProject(ctx context.Context) (*azdext.ProjectConfig, error) {
+	codeAction := &InitFromCodeAction{
+		azdClient:  a.azdClient,
+		flags:      a.flags,
+		httpClient: a.httpClient,
+	}
+	return codeAction.ensureProject(ctx)
+}
+
+func (a *InitFromTemplateAction) createEnvironment(ctx context.Context, envName string) error {
+	envName = sanitizeAgentName(envName)
+
+	workflow := &azdext.Workflow{
+		Name: "env new",
+		Steps: []*azdext.WorkflowStep{
+			{Command: &azdext.WorkflowCommand{Args: []string{"env", "new", envName}}},
+		},
+	}
+
+	_, err := a.azdClient.Workflow().Run(ctx, &azdext.RunWorkflowRequest{
+		Workflow: workflow,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to create environment %s: %w", envName, err)
+	}
+
+	fmt.Printf("  %s  %s\n", color.GreenString("+"), color.GreenString(".azure/%s/.env", envName))
+
+	a.flags.env = envName
+	env := getExistingEnvironment(ctx, a.flags, a.azdClient)
+	if env == nil {
+		return fmt.Errorf("environment %s was created but could not be found", envName)
+	}
+
+	a.environment = env
+	return nil
+}
+
+func (a *InitFromTemplateAction) setEnvVar(ctx context.Context, key, value string) error {
+	_, err := a.azdClient.Environment().SetValue(ctx, &azdext.SetEnvRequest{
+		EnvName: a.environment.Name,
+		Key:     key,
+		Value:   value,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to set environment variable %s=%s: %w", key, value, err)
+	}
+	return nil
+}
+
+func (a *InitFromTemplateAction) ensureSubscriptionAndLocation(ctx context.Context) error {
+	if a.azureContext.Scope.SubscriptionId == "" {
+		if err := a.ensureSubscription(ctx); err != nil {
+			return err
+		}
+	}
+	if a.azureContext.Scope.Location == "" {
+		if err := a.ensureLocation(ctx); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (a *InitFromTemplateAction) ensureSubscription(ctx context.Context) error {
+	codeAction := &InitFromCodeAction{
+		azdClient:    a.azdClient,
+		flags:        a.flags,
+		azureContext: a.azureContext,
+		environment:  a.environment,
+		credential:   a.credential,
+		httpClient:   a.httpClient,
+	}
+	err := codeAction.ensureSubscription(ctx)
+	if err != nil {
+		return err
+	}
+	// Copy back state
+	a.azureContext = codeAction.azureContext
+	a.credential = codeAction.credential
+	return nil
+}
+
+func (a *InitFromTemplateAction) ensureLocation(ctx context.Context) error {
+	codeAction := &InitFromCodeAction{
+		azdClient:    a.azdClient,
+		flags:        a.flags,
+		azureContext: a.azureContext,
+		environment:  a.environment,
+		credential:   a.credential,
+		httpClient:   a.httpClient,
+	}
+	err := codeAction.ensureLocation(ctx)
+	if err != nil {
+		return err
+	}
+	a.azureContext = codeAction.azureContext
+	return nil
+}
+
+func (a *InitFromTemplateAction) selectNewModel(ctx context.Context) (*azdext.AiModel, error) {
+	promptReq := &azdext.PromptAiModelRequest{
+		AzureContext: a.azureContext,
+		SelectOptions: &azdext.SelectOptions{
+			Message: "Select a model",
+		},
+		Quota: &azdext.QuotaCheckOptions{
+			MinRemainingCapacity: 1,
+		},
+		Filter: &azdext.AiModelFilterOptions{
+			Locations: []string{a.azureContext.Scope.Location},
+		},
+		DefaultValue: "gpt-4.1-mini",
+	}
+
+	modelResp, err := a.azdClient.Prompt().PromptAiModel(ctx, promptReq)
+	if err != nil {
+		return nil, fmt.Errorf("failed to prompt for model selection: %w", err)
+	}
+
+	return modelResp.Model, nil
+}
+
+func (a *InitFromTemplateAction) resolveModelDeploymentNoPrompt(ctx context.Context, model *azdext.AiModel, location string) (*azdext.AiModelDeployment, error) {
+	codeAction := &InitFromCodeAction{
+		azdClient:    a.azdClient,
+		flags:        a.flags,
+		azureContext: a.azureContext,
+		environment:  a.environment,
+		credential:   a.credential,
+		httpClient:   a.httpClient,
+	}
+	return codeAction.resolveModelDeploymentNoPrompt(ctx, model, location)
+}
+
+func (a *InitFromTemplateAction) listFoundryProjects(ctx context.Context, subscriptionId string) ([]FoundryProjectInfo, error) {
+	codeAction := &InitFromCodeAction{
+		azdClient:    a.azdClient,
+		flags:        a.flags,
+		azureContext: a.azureContext,
+		environment:  a.environment,
+		credential:   a.credential,
+		httpClient:   a.httpClient,
+	}
+	return codeAction.listFoundryProjects(ctx, subscriptionId)
+}
+
+func (a *InitFromTemplateAction) listProjectDeployments(ctx context.Context, subscriptionId, resourceGroup, accountName string) ([]FoundryDeploymentInfo, error) {
+	codeAction := &InitFromCodeAction{
+		azdClient:    a.azdClient,
+		flags:        a.flags,
+		azureContext: a.azureContext,
+		environment:  a.environment,
+		credential:   a.credential,
+		httpClient:   a.httpClient,
+	}
+	return codeAction.listProjectDeployments(ctx, subscriptionId, resourceGroup, accountName)
+}
+
+func (a *InitFromTemplateAction) processExistingFoundryProject(ctx context.Context, foundryProject FoundryProjectInfo) error {
+	codeAction := &InitFromCodeAction{
+		azdClient:    a.azdClient,
+		flags:        a.flags,
+		azureContext: a.azureContext,
+		environment:  a.environment,
+		credential:   a.credential,
+		httpClient:   a.httpClient,
+	}
+	err := codeAction.processExistingFoundryProject(ctx, foundryProject)
+	if err != nil {
+		return err
+	}
+	a.azureContext = codeAction.azureContext
+	return nil
+}
diff --git a/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_template_test.go b/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_template_test.go
new file mode 100644
index 00000000000..3b899916b1f
--- /dev/null
+++ b/cli/azd/extensions/azure.ai.agents/internal/cmd/init_from_template_test.go
@@ -0,0 +1,319 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package cmd
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestResolveTemplateUrl(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name           string
+		input          string
+		expectedUrl    string
+		expectedBranch string
+	}{
+		{
+			name:           "full GitHub URL",
+			input:          "https://github.com/owner/repo",
+			expectedUrl:    "https://github.com/owner/repo",
+			expectedBranch: "",
+		},
+		{
+			name:           "full GitHub URL with trailing slash",
+			input:          "https://github.com/owner/repo/",
+			expectedUrl:    "https://github.com/owner/repo/",
+			expectedBranch: "",
+		},
+		{
+			name:           "GitHub URL with tree/branch",
+			input:          "https://github.com/owner/repo/tree/main",
+			expectedUrl:    "https://github.com/owner/repo",
+			expectedBranch: "main",
+		},
+		{
+			name:           "GitHub URL with tree/branch trailing slash",
+			input:          "https://github.com/owner/repo/tree/main/",
+			expectedUrl:    "https://github.com/owner/repo",
+			expectedBranch: "main",
+		},
+		{
+			name:           "GitHub URL with tree/feature-branch",
+			input:          "https://github.com/owner/repo/tree/feature/my-branch",
+			expectedUrl:    "https://github.com/owner/repo",
+			expectedBranch: "feature/my-branch",
+		},
+		{
+			name:           "owner/repo format",
+			input:          "myorg/my-template",
+			expectedUrl:    "https://github.com/myorg/my-template",
+			expectedBranch: "",
+		},
+		{
+			name:           "bare repo name",
+			input:          "azd-ai-starter-basic",
+			expectedUrl:    "https://github.com/Azure-Samples/azd-ai-starter-basic",
+			expectedBranch: "",
+		},
+		{
+			name:           "http URL",
+			input:          "http://github.com/owner/repo",
+			expectedUrl:    "http://github.com/owner/repo",
+			expectedBranch: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			url, branch := resolveTemplateUrl(tt.input)
+			if url != tt.expectedUrl {
+				t.Errorf("resolveTemplateUrl(%q) url = %q, want %q", tt.input, url, tt.expectedUrl)
+			}
+			if branch != tt.expectedBranch {
+				t.Errorf("resolveTemplateUrl(%q) branch = %q, want %q", tt.input, branch, tt.expectedBranch)
+			}
+		})
+	}
+}
+
+func TestExtractRepoSlug(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "full HTTPS URL",
+			input:    "https://github.com/owner/repo",
+			expected: "owner/repo",
+		},
+		{
+			name:     "HTTPS URL with trailing slash",
+			input:    "https://github.com/owner/repo/",
+			expected: "owner/repo",
+		},
+		{
+			name:     "HTTPS URL with extra path",
+			input:    "https://github.com/owner/repo/tree/main",
+			expected: "owner/repo",
+		},
+		{
+			name:     "HTTP URL",
+			input:    "http://github.com/owner/repo",
+			expected: "owner/repo",
+		},
+		{
+			name:     "non-GitHub URL",
+			input:    "https://gitlab.com/owner/repo",
+			expected: "",
+		},
+		{
+			name:     "just owner no repo",
+			input:    "https://github.com/owner",
+			expected: "",
+		},
+		{
+			name:     "empty string",
+			input:    "",
+			expected: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := extractRepoSlug(tt.input)
+			if result != tt.expected {
+				t.Errorf("extractRepoSlug(%q) = %q, want %q", tt.input, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestFindAgentYaml(t *testing.T) {
+	t.Parallel()
+
+	t.Run("finds agent.yaml at root", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+		agentPath := filepath.Join(dir, "agent.yaml")
+		os.WriteFile(agentPath, []byte("name: test"), 0644)
+
+		result, err := findAgentYaml(dir)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != agentPath {
+			t.Errorf("findAgentYaml() = %q, want %q", result, agentPath)
+		}
+	})
+
+	t.Run("finds agent.yml at root", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+		agentPath := filepath.Join(dir, "agent.yml")
+		os.WriteFile(agentPath, []byte("name: test"), 0644)
+
+		result, err := findAgentYaml(dir)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != agentPath {
+			t.Errorf("findAgentYaml() = %q, want %q", result, agentPath)
+		}
+	})
+
+	t.Run("finds agent.yaml in src subdirectory", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+		srcDir := filepath.Join(dir, "src", "my-agent")
+		os.MkdirAll(srcDir, 0755)
+		agentPath := filepath.Join(srcDir, "agent.yaml")
+		os.WriteFile(agentPath, []byte("name: test"), 0644)
+
+		result, err := findAgentYaml(dir)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != agentPath {
+			t.Errorf("findAgentYaml() = %q, want %q", result, agentPath)
+		}
+	})
+
+	t.Run("finds agent.yaml in nested directory", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+		nestedDir := filepath.Join(dir, "deep", "nested")
+		os.MkdirAll(nestedDir, 0755)
+		agentPath := filepath.Join(nestedDir, "agent.yaml")
+		os.WriteFile(agentPath, []byte("name: test"), 0644)
+
+		result, err := findAgentYaml(dir)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != agentPath {
+			t.Errorf("findAgentYaml() = %q, want %q", result, agentPath)
+		}
+	})
+
+	t.Run("prefers root over src subdirectory", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+
+		// Create both root and src/agent.yaml
+		rootPath := filepath.Join(dir, "agent.yaml")
+		os.WriteFile(rootPath, []byte("name: root"), 0644)
+
+		srcDir := filepath.Join(dir, "src", "my-agent")
+		os.MkdirAll(srcDir, 0755)
+		os.WriteFile(filepath.Join(srcDir, "agent.yaml"), []byte("name: nested"), 0644)
+
+		result, err := findAgentYaml(dir)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != rootPath {
+			t.Errorf("findAgentYaml() = %q, want root %q", result, rootPath)
+		}
+	})
+
+	t.Run("returns error when not found", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+
+		_, err := findAgentYaml(dir)
+		if err == nil {
+			t.Fatal("expected error, got nil")
+		}
+	})
+
+	t.Run("finds agent.manifest.yaml at root", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+		agentPath := filepath.Join(dir, "agent.manifest.yaml")
+		os.WriteFile(agentPath, []byte("name: test"), 0644)
+
+		result, err := findAgentYaml(dir)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != agentPath {
+			t.Errorf("findAgentYaml() = %q, want %q", result, agentPath)
+		}
+	})
+
+	t.Run("finds agent.manifest.yml at root", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+		agentPath := filepath.Join(dir, "agent.manifest.yml")
+		os.WriteFile(agentPath, []byte("name: test"), 0644)
+
+		result, err := findAgentYaml(dir)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != agentPath {
+			t.Errorf("findAgentYaml() = %q, want %q", result, agentPath)
+		}
+	})
+
+	t.Run("finds agent.manifest.yaml in src subdirectory", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+		srcDir := filepath.Join(dir, "src", "my-agent")
+		os.MkdirAll(srcDir, 0755)
+		agentPath := filepath.Join(srcDir, "agent.manifest.yaml")
+		os.WriteFile(agentPath, []byte("name: test"), 0644)
+
+		result, err := findAgentYaml(dir)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != agentPath {
+			t.Errorf("findAgentYaml() = %q, want %q", result, agentPath)
+		}
+	})
+
+	t.Run("finds agent.manifest.yaml in nested directory", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+		nestedDir := filepath.Join(dir, "deep", "nested")
+		os.MkdirAll(nestedDir, 0755)
+		agentPath := filepath.Join(nestedDir, "agent.manifest.yaml")
+		os.WriteFile(agentPath, []byte("name: test"), 0644)
+
+		result, err := findAgentYaml(dir)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != agentPath {
+			t.Errorf("findAgentYaml() = %q, want %q", result, agentPath)
+		}
+	})
+
+	t.Run("prefers agent.yaml over agent.manifest.yaml at root", func(t *testing.T) {
+		t.Parallel()
+		dir := t.TempDir()
+
+		manifestPath := filepath.Join(dir, "agent.manifest.yaml")
+		os.WriteFile(manifestPath, []byte("name: manifest"), 0644)
+
+		agentPath := filepath.Join(dir, "agent.yaml")
+		os.WriteFile(agentPath, []byte("name: agent"), 0644)
+
+		result, err := findAgentYaml(dir)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if result != agentPath {
+			t.Errorf("findAgentYaml() = %q, want agent.yaml %q", result, agentPath)
+		}
+	})
+}
diff --git a/cli/azd/extensions/azure.ai.agents/internal/cmd/invoke.go b/cli/azd/extensions/azure.ai.agents/internal/cmd/invoke.go
new file mode 100644
index 00000000000..277a3e30ed7
--- /dev/null
+++ b/cli/azd/extensions/azure.ai.agents/internal/cmd/invoke.go
@@ -0,0 +1,449 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package cmd
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
+	"github.com/azure/azure-dev/cli/azd/pkg/azdext"
+	"github.com/spf13/cobra"
+)
+
+type invokeFlags struct {
+	message    string
+	remote     bool
+	name       string
+	port       int
+	session    string
+	newSession bool
+}
+
+type InvokeAction struct {
+	flags *invokeFlags
+}
+
+func newInvokeCommand() *cobra.Command {
+	flags := &invokeFlags{}
+
+	cmd := &cobra.Command{
+		Use:   "invoke [message]",
+		Short: "Send a message to your agent.",
+		Long: `Send a message to your agent.
+
+By default targets localhost:8088 (local dev).
+Use --remote or --name <agent> to invoke on Foundry.
+
+Sessions are persisted per-agent — consecutive invokes reuse the same
+session automatically. Pass --new-session to force a reset.`,
+		Example: `  # Invoke locally (agent must be running via 'azd ai agent run')
+  azd ai agent invoke "Hello!"
+
+  # Invoke the remote agent on Foundry (auto-detects agent from azure.yaml)
+  azd ai agent invoke --remote "Hello!"
+
+  # Invoke a specific remote agent by name
+  azd ai agent invoke --name my-agent "Hello!"
+
+  # Start a new session (discard conversation history)
+  azd ai agent invoke --remote --new-session "Hello!"`,
+		Args: cobra.MaximumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := azdext.WithAccessToken(cmd.Context())
+			setupDebugLogging(cmd.Flags())
+
+			// Resolve message: positional arg > --message flag > default
+			msg := "hello"
+			if len(args) > 0 {
+				msg = args[0]
+			} else if flags.message != "" {
+				msg = flags.message
+			}
+			flags.message = msg
+
+			// --name implies --remote
+			if flags.name != "" {
+				flags.remote = true
+			}
+
+			action := &InvokeAction{flags: flags}
+			return action.Run(ctx)
+		},
+	}
+
+	cmd.Flags().StringVarP(&flags.message, "message", "m", "", "Message to send (alternative to positional argument)")
+	cmd.Flags().BoolVarP(&flags.remote, "remote", "r", false, "Invoke on Foundry instead of localhost")
+	cmd.Flags().StringVarP(&flags.name, "name", "n", "", "Agent name (implies --remote)")
+	cmd.Flags().IntVar(&flags.port, "port", DefaultPort, "Local server port")
+	cmd.Flags().StringVarP(&flags.session, "session", "s", "", "Explicit session ID override")
+	cmd.Flags().BoolVar(&flags.newSession, "new-session", false, "Force a new session (discard saved one)")
+
+	return cmd
+}
+
+func (a *InvokeAction) Run(ctx context.Context) error {
+	if a.flags.remote {
+		return a.invokeRemote(ctx)
+	}
+	return a.invokeLocal()
+}
+
+func (a *InvokeAction) invokeLocal() error {
+	port := a.flags.port
+	msg := a.flags.message
+
+	fmt.Printf("Target:  localhost:%d (local)\n", port)
+	fmt.Printf("Message: %q\n\n", msg)
+
+	body := map[string]interface{}{
+		"input": msg,
+	}
+	payload, err := json.Marshal(body)
+	if err != nil {
+		return fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	url := fmt.Sprintf("http://localhost:%d/responses", port)
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(payload))
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{Timeout: 120 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("could not connect to localhost:%d — is the agent running? Start it with: azd ai agent run", port)
+	}
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read response: %w", err)
+	}
+
+	if resp.StatusCode >= 400 {
+		requestID := resp.Header.Get("apim-request-id")
+		if requestID != "" {
+			fmt.Printf("Trace ID: %s\n", requestID)
+		}
+		return fmt.Errorf("HTTP %d: %s\n%s", resp.StatusCode, resp.Status, string(respBody))
+	}
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(respBody, &result); err != nil {
+		// Not JSON — just print raw response
+		fmt.Println(string(respBody))
+		return nil
+	}
+
+	return printAgentResponse(result, "local")
+}
+
+func (a *InvokeAction) invokeRemote(ctx context.Context) error {
+	name := a.flags.name
+
+	// Auto-resolve agent name from azure.yaml
+	if info, err := resolveAgentServiceFromProject(ctx, name); err == nil {
+		if name == "" && info.AgentName != "" {
+			name = info.AgentName
+		}
+	}
+
+	if name == "" {
+		return fmt.Errorf("agent name is required; use --name or define an azure.ai.agent service in azure.yaml")
+	}
+
+	endpoint, err := resolveAgentEndpoint(ctx, "", "")
+	if err != nil {
+		return err
+	}
+
+	msg := a.flags.message
+
+	fmt.Printf("Agent:   %s (remote)\n", name)
+	fmt.Printf("Message: %q\n\n", msg)
+
+	// Build request body — uses streaming to receive the full agent response.
+	body := map[string]interface{}{
+		"input": msg,
+		"agent": map[string]string{
+			"name": name,
+			"type": "agent_reference",
+		},
+		"stream": true,
+	}
+
+	// Session ID — routes to the same microVM container instance
+	sid := resolveSessionID(ctx, name, a.flags.session, a.flags.newSession)
+	body["session_id"] = sid
+
+	// Conversation ID — enables multi-turn memory via Foundry Conversations API
+	convID := resolveConversationID(ctx, name, a.flags.newSession)
+	if convID == "" {
+		// Create a new conversation
+		newConvID, err := createConversation(ctx, endpoint)
+		if err != nil {
+			fmt.Printf("Warning: could not create conversation; multi-turn memory disabled (%v)\n", err)
+		} else {
+			convID = newConvID
+			saveConversationID(ctx, name, convID)
+		}
+	}
+	if convID != "" {
+		body["conversation"] = map[string]string{"id": convID}
+	}
+
+	// Make the API call
+	credential, err := newAgentCredential()
+	if err != nil {
+		return err
+	}
+
+	token, err := credential.GetToken(ctx, policy.TokenRequestOptions{
+		Scopes: []string{"https://ai.azure.com/.default"},
+	})
+	if err != nil {
+		return fmt.Errorf("failed to get auth token: %w", err)
+	}
+
+	payload, err := json.Marshal(body)
+	if err != nil {
+		return fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	url := fmt.Sprintf("%s/openai/responses?api-version=%s", endpoint, DefaultAgentAPIVersion)
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(payload))
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+token.Token)
+
+	client := &http.Client{Timeout: 120 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	requestID := resp.Header.Get("apim-request-id")
+	if requestID != "" {
+		fmt.Printf("Trace ID: %s\n", requestID)
+	}
+
+	if resp.StatusCode >= 400 {
+		respBody, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("HTTP %d: %s\n%s", resp.StatusCode, resp.Status, string(respBody))
+	}
+
+	// Parse SSE stream for agent output
+	return readSSEStream(resp.Body, name)
+}
+
+// createConversation creates a new Foundry conversation for multi-turn memory.
+func createConversation(ctx context.Context, endpoint string) (string, error) {
+	credential, err := newAgentCredential()
+	if err != nil {
+		return "", err
+	}
+
+	token, err := credential.GetToken(ctx, policy.TokenRequestOptions{
+		Scopes: []string{"https://ai.azure.com/.default"},
+	})
+	if err != nil {
+		return "", err
+	}
+
+	url := fmt.Sprintf("%s/openai/conversations?api-version=%s", endpoint, DefaultAgentAPIVersion)
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader([]byte("{}")))
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+token.Token)
+
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		return "", fmt.Errorf("failed to create conversation: HTTP %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(body, &result); err != nil {
+		return "", err
+	}
+
+	if id, ok := result["id"].(string); ok {
+		return id, nil
+	}
+	return "", fmt.Errorf("conversation response missing 'id' field")
+}
+
+// readSSEStream reads a Server-Sent Events stream from the Foundry Responses API,
+// printing text deltas in real-time and returning the final response or any error.
+func readSSEStream(body io.Reader, agentName string) error {
+	scanner := bufio.NewScanner(body)
+	// Allow large SSE data lines (up to 1 MB)
+	scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+
+	var currentEvent string
+	var printed bool
+
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		if strings.HasPrefix(line, "event: ") {
+			currentEvent = strings.TrimPrefix(line, "event: ")
+			continue
+		}
+
+		if strings.HasPrefix(line, "data: ") {
+			data := strings.TrimPrefix(line, "data: ")
+
+			switch currentEvent {
+			case "response.output_text.delta":
+				var delta struct {
+					Delta string `json:"delta"`
+				}
+				if err := json.Unmarshal([]byte(data), &delta); err == nil && delta.Delta != "" {
+					if !printed {
+						fmt.Printf("[%s] ", agentName)
+						printed = true
+					}
+					fmt.Print(delta.Delta)
+				}
+
+			case "response.completed":
+				if printed {
+					fmt.Println()
+				}
+				// Parse the completed response to check for errors
+				var event struct {
+					Response json.RawMessage `json:"response"`
+				}
+				if err := json.Unmarshal([]byte(data), &event); err == nil && event.Response != nil {
+					var result map[string]interface{}
+					if err := json.Unmarshal(event.Response, &result); err == nil {
+						if status, _ := result["status"].(string); status == "failed" {
+							if errObj, ok := result["error"].(map[string]interface{}); ok {
+								msg, _ := errObj["message"].(string)
+								code, _ := errObj["code"].(string)
+								return fmt.Errorf("agent failed (%s): %s", code, msg)
+							}
+							return fmt.Errorf("agent returned failed status")
+						}
+						// If no text was streamed, extract output from the completed response
+						if !printed {
+							return printAgentResponse(result, agentName)
+						}
+					}
+				}
+				return nil
+
+			case "error":
+				if printed {
+					fmt.Println()
+				}
+				var sseErr struct {
+					Code    string `json:"code"`
+					Message string `json:"message"`
+				}
+				if err := json.Unmarshal([]byte(data), &sseErr); err == nil {
+					return fmt.Errorf("agent error (%s): %s", sseErr.Code, sseErr.Message)
+				}
+				return fmt.Errorf("agent stream error: %s", data)
+			}
+
+			currentEvent = ""
+			continue
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return fmt.Errorf("error reading response stream: %w", err)
+	}
+
+	if printed {
+		fmt.Println()
+	}
+	return nil
+}
+
+// printAgentResponse pretty-prints the output_text items from an agent response.
+func printAgentResponse(result map[string]interface{}, title string) error {
+	// Check for agent-level errors (e.g., agent runtime failures)
+	if status, _ := result["status"].(string); status == "failed" {
+		if errObj, ok := result["error"].(map[string]interface{}); ok {
+			msg, _ := errObj["message"].(string)
+			code, _ := errObj["code"].(string)
+			return fmt.Errorf("agent failed (%s): %s", code, msg)
+		}
+		return fmt.Errorf("agent returned failed status")
+	}
+
+	// Check for server-level errors (e.g., local agentserver: {"code": "server_error", "message": "..."})
+	if code, ok := result["code"].(string); ok && code != "" {
+		msg, _ := result["message"].(string)
+		return fmt.Errorf("agent error (%s): %s", code, msg)
+	}
+
+	outputItems, ok := result["output"].([]interface{})
+	if !ok {
+		// Try printing the whole response as formatted JSON
+		jsonBytes, _ := json.MarshalIndent(result, "", "  ")
+		fmt.Println(string(jsonBytes))
+		return nil
+	}
+
+	printed := false
+	for _, item := range outputItems {
+		itemMap, ok := item.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		contentItems, ok := itemMap["content"].([]interface{})
+		if !ok {
+			continue
+		}
+		for _, content := range contentItems {
+			contentMap, ok := content.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			if contentMap["type"] == "output_text" {
+				if text, ok := contentMap["text"].(string); ok {
+					fmt.Printf("[%s] %s\n", title, text)
+					printed = true
+				}
+			}
+		}
+	}
+
+	if !printed {
+		jsonBytes, _ := json.MarshalIndent(result, "", "  ")
+		fmt.Println(string(jsonBytes))
+	}
+	return nil
+}
+
+
diff --git a/cli/azd/extensions/azure.ai.agents/internal/cmd/list.go b/cli/azd/extensions/azure.ai.agents/internal/cmd/list.go
new file mode 100644
index 00000000000..246541f6ab6
--- /dev/null
+++ b/cli/azd/extensions/azure.ai.agents/internal/cmd/list.go
@@ -0,0 +1,117 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"text/tabwriter"
+
+	"github.com/azure/azure-dev/cli/azd/pkg/azdext"
+	"github.com/spf13/cobra"
+)
+
+type listFlags struct {
+	output string
+}
+
+func newListCommand() *cobra.Command {
+	flags := &listFlags{}
+
+	cmd := &cobra.Command{
+		Use:   "list",
+		Short: "List agent services in the project.",
+		Long: `List agent services defined in azure.yaml.
+
+Shows each azure.ai.agent service with its name and relative path.
+The currently active agent (set via AZD_AI_AGENT_INVOKE_NAME) is marked with an arrow.`,
+		Example: `  # List agents in the project
+  azd ai agent list
+
+  # List agents in JSON format
+  azd ai agent list --output json`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := azdext.WithAccessToken(cmd.Context())
+			setupDebugLogging(cmd.Flags())
+
+			return runList(ctx, flags)
+		},
+	}
+
+	cmd.Flags().StringVarP(&flags.output, "output", "o", "table", "Output format (json or table)")
+
+	return cmd
+}
+
+// agentServiceEntry represents an agent service for display.
+type agentServiceEntry struct {
+	Name         string `json:"name"`
+	RelativePath string `json:"relativePath"`
+	Active       bool   `json:"active"`
+}
+
+func runList(ctx context.Context, flags *listFlags) error {
+	azdClient, err := azdext.NewAzdClient()
+	if err != nil {
+		return fmt.Errorf("failed to create azd client: %w", err)
+	}
+	defer azdClient.Close()
+
+	projectResponse, err := azdClient.Project().Get(ctx, &azdext.EmptyRequest{})
+	if err != nil || projectResponse.Project == nil {
+		return fmt.Errorf("failed to read azure.yaml: %w", err)
+	}
+
+	activeAgent := getInvokeEnvValue(ctx, EnvKeyAgentInvokeName)
+
+	var entries []agentServiceEntry
+	for _, svc := range projectResponse.Project.Services {
+		if svc.Host != AiAgentHost {
+			continue
+		}
+		entries = append(entries, agentServiceEntry{
+			Name:         svc.Name,
+			RelativePath: svc.RelativePath,
+			Active:       svc.Name == activeAgent,
+		})
+	}
+
+	if len(entries) == 0 {
+		fmt.Println("No agent services found in azure.yaml.")
+		return nil
+	}
+
+	switch flags.output {
+	case "json":
+		jsonBytes, err := json.MarshalIndent(entries, "", "  ")
+		if err != nil {
+			return fmt.Errorf("failed to marshal to JSON: %w", err)
+		}
+		fmt.Println(string(jsonBytes))
+	default:
+		w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+		fmt.Fprintln(w, "\tNAME\tPATH")
+		fmt.Fprintln(w, "\t----\t----")
+
+		for _, e := range entries {
+			marker := ""
+			if e.Active {
+				marker = "→"
+			}
+			fmt.Fprintf(w, "%s\t%s\t%s\n", marker, e.Name, e.RelativePath)
+		}
+
+		if err := w.Flush(); err != nil {
+			return err
+		}
+
+		if activeAgent != "" {
+			fmt.Printf("\n→ = active invoke target (%s)\n", EnvKeyAgentInvokeName)
+		}
+	}
+
+	return nil
+}
diff --git a/cli/azd/extensions/azure.ai.agents/internal/cmd/monitor.go b/cli/azd/extensions/azure.ai.agents/internal/cmd/monitor.go
index 3e11267778d..3a8618a5842 100644
--- a/cli/azd/extensions/azure.ai.agents/internal/cmd/monitor.go
+++ b/cli/azd/extensions/azure.ai.agents/internal/cmd/monitor.go
@@ -40,13 +40,13 @@ func newMonitorCommand() *cobra.Command {
 Streams console output (stdout/stderr) or system events from an agent container.
 Use --follow to stream logs in real-time, or omit it to fetch recent logs and exit.
 This is useful for troubleshooting agent startup issues or monitoring agent behavior.`,
-		Example: `  # Fetch the last 50 lines of console logs
-  azd ai agent monitor --name my-agent --version 1
+		Example: `  # Fetch the last 50 lines of console logs (auto-detects agent)
+  azd ai agent monitor
 
   # Stream console logs in real-time
-  azd ai agent monitor --name my-agent --version 1 --follow
+  azd ai agent monitor --follow
 
-  # Fetch system event logs
+  # Fetch system event logs for a specific agent
   azd ai agent monitor --name my-agent --version 1 --type system
 
   # Fetch last 100 lines with explicit account
@@ -59,6 +59,26 @@ This is useful for troubleshooting agent startup issues or monitoring agent beha
 			ctx := azdext.WithAccessToken(cmd.Context())
 			setupDebugLogging(cmd.Flags())
 
+			// Auto-resolve name from azure.yaml if not provided
+			if flags.name == "" {
+				if info, err := resolveAgentServiceFromProject(ctx, ""); err == nil {
+					flags.name = info.AgentName
+				}
+			}
+
+			if flags.name == "" {
+				return fmt.Errorf("agent name is required; use --name or define an azure.ai.agent service in azure.yaml")
+			}
+
+			// Auto-resolve version from API if not provided
+			if flags.version == "" {
+				v, err := resolveLatestVersion(ctx, flags.accountName, flags.projectName, flags.name)
+				if err != nil {
+					return fmt.Errorf("agent version is required; use --version or deploy the agent first with 'azd deploy'")
+				}
+				flags.version = v
+			}
+
 			agentContext, err := newAgentContext(ctx, flags.accountName, flags.projectName, flags.name, flags.version)
 			if err != nil {
 				return err
@@ -75,15 +95,12 @@ This is useful for troubleshooting agent startup issues or monitoring agent beha
 
 	cmd.Flags().StringVarP(&flags.accountName, "account-name", "a", "", "Cognitive Services account name")
 	cmd.Flags().StringVarP(&flags.projectName, "project-name", "p", "", "AI Foundry project name")
-	cmd.Flags().StringVarP(&flags.name, "name", "n", "", "Name of the hosted agent (required)")
-	cmd.Flags().StringVarP(&flags.version, "version", "v", "", "Version of the hosted agent (required)")
+	cmd.Flags().StringVarP(&flags.name, "name", "n", "", "Name of the hosted agent")
+	cmd.Flags().StringVarP(&flags.version, "version", "v", "", "Version of the hosted agent")
 	cmd.Flags().BoolVarP(&flags.follow, "follow", "f", false, "Stream logs in real-time")
 	cmd.Flags().IntVarP(&flags.tail, "tail", "l", 50, "Number of trailing log lines to fetch (1-300)")
 	cmd.Flags().StringVarP(&flags.logType, "type", "t", "console", "Type of logs: 'console' (stdout/stderr) or 'system' (container events)")
 
-	_ = cmd.MarkFlagRequired("name")
-	_ = cmd.MarkFlagRequired("version")
-
 	return cmd
 }
 
diff --git a/cli/azd/extensions/azure.ai.agents/internal/cmd/root.go b/cli/azd/extensions/azure.ai.agents/internal/cmd/root.go
index b26f5a4933a..4c674c991ec 100644
--- a/cli/azd/extensions/azure.ai.agents/internal/cmd/root.go
+++ b/cli/azd/extensions/azure.ai.agents/internal/cmd/root.go
@@ -53,6 +53,9 @@ func NewRootCommand() *cobra.Command {
 	rootCmd.AddCommand(newMetadataCommand())
 	rootCmd.AddCommand(newShowCommand())
 	rootCmd.AddCommand(newMonitorCommand())
+	rootCmd.AddCommand(newListCommand())
+	rootCmd.AddCommand(newInvokeCommand())
+	rootCmd.AddCommand(newRunCommand())
 
 	return rootCmd
 }
diff --git a/cli/azd/extensions/azure.ai.agents/internal/cmd/show.go b/cli/azd/extensions/azure.ai.agents/internal/cmd/show.go
index d31e8761b1e..17998ebfa20 100644
--- a/cli/azd/extensions/azure.ai.agents/internal/cmd/show.go
+++ b/cli/azd/extensions/azure.ai.agents/internal/cmd/show.go
@@ -40,18 +40,41 @@ func newShowCommand() *cobra.Command {
 
 Retrieves the runtime status of a hosted agent container, including its current state,
 replica configuration, and any error messages.`,
-		Example: `  # Show status using azd environment configuration
+		Example: `  # Show status (auto-detects agent from azure.yaml)
+  azd ai agent show
+
+  # Show status for a specific agent
   azd ai agent show --name my-agent --version 1
 
   # Show status with explicit account and project
   azd ai agent show --name my-agent --version 1 --account-name myAccount --project-name myProject
 
   # Show status in table format
-  azd ai agent show --name my-agent --version 1 --output table`,
+  azd ai agent show --output table`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := azdext.WithAccessToken(cmd.Context())
 			setupDebugLogging(cmd.Flags())
 
+			// Auto-resolve name from azure.yaml if not provided
+			if flags.name == "" {
+				if info, err := resolveAgentServiceFromProject(ctx, ""); err == nil {
+					flags.name = info.AgentName
+				}
+			}
+
+			if flags.name == "" {
+				return fmt.Errorf("agent name is required; use --name or define an azure.ai.agent service in azure.yaml")
+			}
+
+			// Auto-resolve version from API if not provided
+			if flags.version == "" {
+				v, err := resolveLatestVersion(ctx, flags.accountName, flags.projectName, flags.name)
+				if err != nil {
+					return fmt.Errorf("agent version is required; use --version or deploy the agent first with 'azd deploy'")
+				}
+				flags.version = v
+			}
+
 			agentContext, err := newAgentContext(ctx, flags.accountName, flags.projectName, flags.name, flags.version)
 			if err != nil {
 				return err
@@ -68,13 +91,10 @@ replica configuration, and any error messages.`,
 
 	cmd.Flags().StringVarP(&flags.accountName, "account-name", "a", "", "Cognitive Services account name")
 	cmd.Flags().StringVarP(&flags.projectName, "project-name", "p", "", "AI Foundry project name")
-	cmd.Flags().StringVarP(&flags.name, "name", "n", "", "Name of the hosted agent (required)")
-	cmd.Flags().StringVarP(&flags.version, "version", "v", "", "Version of the hosted agent (required)")
+	cmd.Flags().StringVarP(&flags.name, "name", "n", "", "Name of the hosted agent")
+	cmd.Flags().StringVarP(&flags.version, "version", "v", "", "Version of the hosted agent")
 	cmd.Flags().StringVarP(&flags.output, "output", "o", "json", "Output format (json or table)")
 
-	_ = cmd.MarkFlagRequired("name")
-	_ = cmd.MarkFlagRequired("version")
-
 	return cmd
 }
 
diff --git a/cli/azd/extensions/azure.ai.agents/internal/exterrors/codes.go b/cli/azd/extensions/azure.ai.agents/internal/exterrors/codes.go
index 4a2dfff5bcb..8b3c72590a7 100644
--- a/cli/azd/extensions/azure.ai.agents/internal/exterrors/codes.go
+++ b/cli/azd/extensions/azure.ai.agents/internal/exterrors/codes.go
@@ -17,6 +17,7 @@ const (
 	CodeInvalidAiProjectId        = "invalid_ai_project_id"
 	CodeInvalidServiceConfig      = "invalid_service_config"
 	CodeInvalidAgentRequest       = "invalid_agent_request"
+	CodeInvalidArgs               = "invalid_args"
 	CodeUnsupportedHost           = "unsupported_host"
 	CodeUnsupportedAgentKind      = "unsupported_agent_kind"
 	CodeMissingAgentKind          = "missing_agent_kind"
@@ -39,6 +40,8 @@ const (
 	CodeMissingAzureSubscription  = "missing_azure_subscription_id"
 	CodeMissingAgentEnvVars       = "missing_agent_env_vars"
 	CodeGitHubDownloadFailed      = "github_download_failed"
+	CodeTemplateDownloadFailed    = "template_download_failed"
+	CodeAgentYamlNotFound         = "agent_yaml_not_found"
 )
 
 // Error codes for auth errors.
diff --git a/cli/azd/extensions/azure.ai.agents/internal/project/config.go b/cli/azd/extensions/azure.ai.agents/internal/project/config.go
index d3c09ee2797..c123b096231 100644
--- a/cli/azd/extensions/azure.ai.agents/internal/project/config.go
+++ b/cli/azd/extensions/azure.ai.agents/internal/project/config.go
@@ -19,6 +19,22 @@ const (
 	DefaultMaxReplicas = 1
 )
 
+// ContainerPreset defines a named configuration for container resources.
+type ContainerPreset struct {
+	Label       string
+	Cpu         string
+	Memory      string
+	MinReplicas int
+	MaxReplicas int
+}
+
+// ContainerPresets defines the available container configuration tiers.
+var ContainerPresets = []ContainerPreset{
+	{Label: "Cost Effective — 0.25 CPU, 0.5 GB RAM, 0–1 replicas", Cpu: "0.25", Memory: "0.5Gi", MinReplicas: 0, MaxReplicas: 1},
+	{Label: "Balanced — 0.5 CPU, 1.0 GB RAM, 0–3 replicas", Cpu: "0.5", Memory: "1.0Gi", MinReplicas: 0, MaxReplicas: 3},
+	{Label: "Performance — 1.0 CPU, 2.0 GB RAM, 1–5 replicas", Cpu: "1.0", Memory: "2.0Gi", MinReplicas: 1, MaxReplicas: 5},
+}
+
 // ServiceTargetAgentConfig provides custom configuration for the Azure AI Service target
 type ServiceTargetAgentConfig struct {
 	Environment map[string]string  `json:"env,omitempty"`