agent-devkit 0.3.0 → 0.3.2

package/runtime/cli/aikit/llm.py

@@ -14,6 +14,14 @@ from pathlib import Path
 from typing import Any
 
 from cli.aikit.app_home import app_home, config_path as app_config_path, ensure_app_home
+from cli.aikit.embedded_mini_brain import (
+    EMBEDDED_BACKEND_ID,
+    EMBEDDED_MODEL_ID,
+    EmbeddedMiniBrainError,
+    embedded_backend_config,
+    embedded_backend_doctor,
+    invoke_embedded_mini_brain,
+)
 from cli.aikit.identity import host_cli_prompt, identity_system_prompt
 
 
@@ -33,6 +41,14 @@ class LlmBackend:
 
 
 BACKENDS: dict[str, LlmBackend] = {
+    EMBEDDED_BACKEND_ID: LlmBackend(
+        id=EMBEDDED_BACKEND_ID,
+        display_name="Embedded mini-brain",
+        kind="embedded-local",
+        auth="none",
+        default_model=EMBEDDED_MODEL_ID,
+        notes="Uses the Agent DevKit embedded mini-brain for setup, onboarding and low-risk conversation.",
+    ),
     "openai": LlmBackend(
         id="openai",
         display_name="OpenAI API",
@@ -100,7 +116,7 @@ BACKENDS: dict[str, LlmBackend] = {
 
 ENV_VAR_NAME_PATTERN = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
 DEFAULT_AGENT_TIMEOUT_SECONDS = 120
-DEFAULT_FALLBACK_ORDER = ("claude-code", "codex-cli", "openai", "anthropic", "openrouter", "ollama")
+DEFAULT_FALLBACK_ORDER = ("claude-code", "codex-cli", "openai", "anthropic", "openrouter", "ollama", EMBEDDED_BACKEND_ID)
 
 
 def config_home() -> Path:
@@ -323,6 +339,8 @@ def normalize_backend_order(order: str | list[str] | tuple[str, ...]) -> list[st
 
 
 def default_backend_config(backend: LlmBackend) -> dict[str, Any]:
+    if backend.id == EMBEDDED_BACKEND_ID:
+        return embedded_backend_config()
     entry: dict[str, Any] = {"kind": backend.kind, "auth": backend.auth}
     if backend.auth == "api-key-env":
         entry["api_key_ref"] = f"env:{backend.api_key_env}"
@@ -346,7 +364,8 @@ def doctor_backends(backend_id: str | None = None) -> dict[str, Any]:
 
     checks = [doctor_backend(BACKENDS[item], config) for item in ids]
     status = "ok"
-    if any(item["status"] == "missing" for item in checks):
+    missing_statuses = {"missing", "not-installed", "dependency-missing", "invalid-model"}
+    if any(item["status"] in missing_statuses for item in checks):
         status = "partial" if not backend_id else "missing"
     if any(item["status"] == "error" for item in checks):
         status = "error"
@@ -361,6 +380,8 @@ def doctor_backends(backend_id: str | None = None) -> dict[str, Any]:
 
 
 def doctor_backend(backend: LlmBackend, config: dict[str, Any]) -> dict[str, Any]:
+    if backend.id == EMBEDDED_BACKEND_ID:
+        return embedded_backend_doctor()
     configured = config.get("llm", {}).get("backends", {}).get(backend.id, {})
     if not isinstance(configured, dict):
         configured = {}
@@ -616,6 +637,11 @@ class LlmPolicyError(LlmInvocationError):
 def invoke_resolved_backend(backend: dict[str, Any], prompt: str, *, public_name: str = "Agent DevKit") -> str:
     kind = backend.get("kind")
     backend_id = backend.get("id")
+    if kind == "embedded-local" and backend_id == EMBEDDED_BACKEND_ID:
+        try:
+            return invoke_embedded_mini_brain(prompt, public_name=public_name)
+        except EmbeddedMiniBrainError as exc:
+            raise LlmInvocationError(str(exc)) from exc
     if kind == "openai-compatible":
         return invoke_openai_compatible(backend, prompt, public_name=public_name)
     if kind == "anthropic":

package/runtime/cli/aikit/local_llm.py

@@ -6,6 +6,7 @@ import shutil
 import subprocess
 from typing import Any
 
+from cli.aikit.embedded_mini_brain import EMBEDDED_BACKEND_ID, EMBEDDED_MODEL_ID, embedded_mini_brain_status
 from cli.aikit.mini_brain import DEFAULT_OLLAMA_MODEL, mini_brain_contract
 from cli.aikit.model_router import build_model_plan
 from cli.aikit.ollama import ollama_models, ollama_pull, ollama_status
@@ -28,7 +29,9 @@ def local_llm_list() -> dict[str, Any]:
         "kind": "local-llm",
         "schema_version": LOCAL_LLM_SCHEMA_VERSION,
         "status": "ok",
-        "provider": "ollama",
+        "provider": EMBEDDED_BACKEND_ID,
+        "optional_providers": ["ollama"],
+        "embedded": embedded_mini_brain_status(),
         "mini_brain": contract,
         "workers": [{"id": worker_id, "purpose": purpose} for worker_id, purpose in LOCAL_WORKERS],
         "models": {
@@ -42,12 +45,14 @@ def local_llm_doctor() -> dict[str, Any]:
     status = ollama_status()
     contract = mini_brain_contract(ollama_payload=status)
     model_plan = build_model_plan("resuma estes logs operacionais")
-    ok = status.get("status") == "ok" and contract.get("enabled") is True
+    ok = contract.get("available") is True
     return {
         "kind": "local-llm-doctor",
         "schema_version": LOCAL_LLM_SCHEMA_VERSION,
         "status": "ok" if ok else "partial",
-        "provider": "ollama",
+        "provider": EMBEDDED_BACKEND_ID,
+        "optional_providers": ["ollama"],
+        "embedded": embedded_mini_brain_status(),
         "ollama": status,
         "mini_brain": contract,
         "model_plan": {
@@ -63,9 +68,19 @@ def local_llm_doctor() -> dict[str, Any]:
 
 def local_llm_models() -> dict[str, Any]:
     payload = ollama_models()
+    embedded = embedded_mini_brain_status()
     payload["kind"] = "local-llm-models"
     payload["schema_version"] = LOCAL_LLM_SCHEMA_VERSION
-    payload["provider"] = "ollama"
+    payload["provider"] = EMBEDDED_BACKEND_ID
+    payload["embedded"] = {
+        "status": embedded.get("status"),
+        "provider": EMBEDDED_BACKEND_ID,
+        "model": EMBEDDED_MODEL_ID,
+        "installed": embedded.get("model_file_valid") is True,
+        "available": embedded.get("available") is True,
+        "install_command": embedded.get("install_command"),
+    }
+    payload["optional_provider"] = "ollama"
     return payload
 
 

package/runtime/cli/aikit/local_llm_operator.py

@@ -24,7 +24,7 @@ FORBIDDEN_DELEGATION_MARKERS = (
 
 
 def maybe_delegate_local_llm(prompt: str, model_plan: dict[str, Any]) -> dict[str, Any]:
-    """Execute a bounded operational task with Ollama when the model plan selected it."""
+    """Execute a bounded operational task with the selected local worker."""
     delegation = model_plan.get("delegation") if isinstance(model_plan.get("delegation"), dict) else {}
     if model_plan.get("strategy") != "mini-brain":
         return skipped(
@@ -38,6 +38,12 @@ def maybe_delegate_local_llm(prompt: str, model_plan: dict[str, Any]) -> dict[st
             "High-risk tasks cannot be delegated to local LLM workers.",
             model_plan=model_plan,
         )
+    if model_plan.get("local_llm_role") != "operational-worker":
+        return skipped(
+            "not-operational-worker",
+            "The embedded mini-brain is acting as the bootstrap coordinator, not as a delegated worker.",
+            model_plan=model_plan,
+        )
     if int(model_plan.get("max_llm_calls") or 0) <= 0:
         return skipped(
             "llm-budget-not-available",
@@ -50,9 +56,10 @@ def maybe_delegate_local_llm(prompt: str, model_plan: dict[str, Any]) -> dict[st
     if any(marker in lowered for marker in FORBIDDEN_DELEGATION_MARKERS):
         return skipped("forbidden", "Prompt contains an action that local LLM workers cannot execute.", model_plan=model_plan)
     delegated_prompt = build_delegated_prompt(prompt, model_plan)
+    provider = str(model_plan.get("local_llm_provider") or "ollama")
     result = invoke_agent_prompt(
         delegated_prompt,
-        "ollama",
+        provider,
         public_name="Local LLM Operator",
         allow_fallback=False,
     )
@@ -64,7 +71,7 @@ def maybe_delegate_local_llm(prompt: str, model_plan: dict[str, Any]) -> dict[st
         "status": "ok" if result.get("ok") else result.get("status", "failed"),
         "ok": bool(result.get("ok")),
         "llm_backend": result.get("llm_backend"),
-        "model_provider": "ollama",
+        "model_provider": provider,
         "mini_brain": summarize_mini_brain(model_plan.get("mini_brain")),
         "strategy": model_plan.get("strategy"),
         "risk": model_plan.get("risk"),
@@ -108,7 +115,7 @@ def enrich_prompt_with_local_result(prompt: str, local_execution: dict[str, Any]
         [
             prompt,
             "",
-            "Contexto operacional produzido pelo local-llm-operator/Ollama:",
+            f"Contexto operacional produzido pelo local-llm-operator/{local_execution.get('model_provider') or local_execution.get('llm_backend') or 'local'}:",
             str(local_execution["response"]),
             "",
             "Use esse contexto apenas como apoio. A decisao, resposta final e revisao continuam sob responsabilidade do coordenador.",
@@ -131,7 +138,10 @@ def skipped(reason: str, message: str, *, model_plan: dict[str, Any]) -> dict[st
         "strategy": model_plan.get("strategy"),
         "risk": model_plan.get("risk"),
         "confidence": model_plan.get("confidence"),
-        "requires_review": bool(model_plan.get("local_llm_recommended") or model_plan.get("local_llm_selected")),
+        "requires_review": bool(
+            model_plan.get("local_llm_role") == "operational-worker"
+            and (model_plan.get("local_llm_recommended") or model_plan.get("local_llm_selected"))
+        ),
     }
 
 

package/runtime/cli/aikit/mini_brain.py

@@ -5,14 +5,20 @@ from __future__ import annotations
 from datetime import datetime, timezone
 from typing import Any
 
+from cli.aikit.embedded_mini_brain import (
+    EMBEDDED_BACKEND_ID,
+    EMBEDDED_MODEL_ID,
+    embedded_mini_brain_status,
+    setup_embedded_mini_brain,
+)
 from cli.aikit.llm import BACKENDS, configure_backend, doctor_backend, load_config, save_config
-from cli.aikit.ollama import ollama_pull, ollama_status
+from cli.aikit.ollama import ollama_status
 
 
 MINI_BRAIN_CONFIG_KEY = "mini_brain"
-DEFAULT_HF_MODEL = "Qwen/Qwen3-0.6B"
+DEFAULT_HF_MODEL = EMBEDDED_MODEL_ID
 DEFAULT_OLLAMA_MODEL = "qwen3:0.6b"
-DEFAULT_PROVIDER = "ollama"
+DEFAULT_PROVIDER = EMBEDDED_BACKEND_ID
 DEFAULT_BASE_URL = "http://localhost:11434/v1"
 ALLOWED_TASKS = [
     "setup_help",
@@ -50,14 +56,15 @@ def mini_brain_contract(
 ) -> dict[str, Any]:
     config = load_config() if config is None else config
     stored = config.get(MINI_BRAIN_CONFIG_KEY) if isinstance(config.get(MINI_BRAIN_CONFIG_KEY), dict) else {}
-    enabled = bool(stored.get("enabled"))
+    enabled = bool(stored.get("enabled", True))
     provider = stored.get("provider") or stored.get("runtime") or DEFAULT_PROVIDER
     hf_model = stored.get("hf_model") or stored.get("model") or DEFAULT_HF_MODEL
     ollama_model = stored.get("ollama_model") or DEFAULT_OLLAMA_MODEL
+    embedded = embedded_mini_brain_status()
     ollama_payload = ollama_status() if ollama_payload is None else ollama_payload
     ollama_backend = doctor_backend(BACKENDS["ollama"], config) if ollama_backend is None else ollama_backend
-    backend_configured = ollama_backend.get("status") == "ok"
-    runtime_available = ollama_payload.get("status") == "ok" or backend_configured
+    ollama_configured = ollama_backend.get("configured") is True
+    runtime_available = embedded.get("available") is True
     available = enabled and provider == DEFAULT_PROVIDER and runtime_available
     status = "ok" if available else "disabled" if not enabled else "unavailable"
     return {
@@ -65,7 +72,8 @@ def mini_brain_contract(
         "status": status,
         "enabled": enabled,
         "available": available,
-        "configured": enabled and provider == DEFAULT_PROVIDER and backend_configured,
+        "configured": available,
+        "embedded_configured": provider == DEFAULT_PROVIDER,
         "provider": provider,
         "runtime": provider,
         "hf_model": hf_model,
@@ -76,6 +84,7 @@ def mini_brain_contract(
         "limits": dict_value(stored.get("limits"), DEFAULT_LIMITS),
         "guardrails": list_value(stored.get("guardrails"), DEFAULT_GUARDRAILS),
         "stored_secret": False,
+        "embedded": embedded,
         "ollama": {
             "status": ollama_payload.get("status"),
             "daemon": (ollama_payload.get("daemon") or {}).get("status")
@@ -87,6 +96,7 @@ def mini_brain_contract(
             "status": ollama_backend.get("status"),
             "model": ollama_backend.get("model"),
             "base_url": ollama_backend.get("base_url"),
+            "configured": ollama_configured,
         },
     }
 
@@ -98,6 +108,7 @@ def setup_mini_brain(
     set_default: bool = False,
     model: str = DEFAULT_OLLAMA_MODEL,
 ) -> dict[str, Any]:
+    embedded = embedded_mini_brain_status()
     if dry_run or not yes:
         status = "planned" if dry_run else "needs-confirmation"
         needs_confirmation = not dry_run and not yes
@@ -110,53 +121,46 @@ def setup_mini_brain(
             "yes": yes,
             "stored_secret": False,
             "mini_brain": planned_contract(model=model),
-            "pull": ollama_pull(model, yes=False, dry_run=dry_run),
+            "embedded": embedded,
+            "embedded_install": setup_embedded_mini_brain(dry_run=True, yes=False),
+            "ollama_setup": {
+                "status": "skipped",
+                "ok": True,
+                "provider": "ollama",
+                "model": model,
+                "message": "Ollama is optional; use `agent local-llm install` to add local worker models.",
+            },
             "next_steps": ["agent setup mini-brain --yes"],
-            "message": "Use --yes to pull Qwen3-0.6B with Ollama and enable the mini-brain.",
+            "message": "Use --yes to download and enable the embedded Qwen2.5-0.5B mini-brain.",
         }
 
-    pull = ollama_pull(model, yes=True, dry_run=False)
-    toolchain_install = None
-    if pull.get("status") == "missing":
-        from cli.aikit.toolchain import install_toolchain
-
-        toolchain_install = install_toolchain(None, "ollama", dry_run=False, yes=True)
-        if toolchain_install.get("status") == "installed":
-            pull = ollama_pull(model, yes=True, dry_run=False)
-    if not pull.get("ok"):
-        payload = {
+    embedded_install = setup_embedded_mini_brain(dry_run=False, yes=True)
+    embedded = embedded_mini_brain_status()
+    if embedded_install.get("ok") is not True:
+        return {
             "kind": "mini-brain-setup",
             "status": "failed",
             "ok": False,
-            "exit_code": int(pull.get("exit_code") or 2),
+            "exit_code": embedded_install.get("exit_code", 1),
             "dry_run": False,
             "yes": True,
             "stored_secret": False,
-            "mini_brain": planned_contract(model=model),
-            "pull": pull,
-            "next_steps": ["Install Ollama or run agent ollama pull qwen3:0.6b --yes"],
-            "message": pull.get("message") or "Could not pull the mini-brain model.",
+            "mini_brain": mini_brain_contract(),
+            "embedded": embedded,
+            "embedded_install": embedded_install,
+            "ollama_setup": {
+                "status": "skipped",
+                "ok": True,
+                "provider": "ollama",
+                "model": model,
+                "message": "Ollama remains optional for additional local worker models.",
+            },
+            "message": "Embedded mini-brain setup failed before the backend could be enabled.",
         }
-        if toolchain_install:
-            payload["toolchain_install"] = toolchain_install
-            payload["next_steps"] = [
-                "Review `agent toolchain doctor ollama`.",
-                "Run `agent toolchain install ollama --yes` if you approve external installation.",
-                "Then run `agent setup mini-brain --yes` again.",
-            ]
-        return payload
-
-    existing_config = load_config()
-    existing_ollama = (
-        existing_config.get("llm", {}).get("backends", {}).get(DEFAULT_PROVIDER)
-        if isinstance(existing_config.get("llm"), dict)
-        else {}
-    )
-    existing_base_url = existing_ollama.get("base_url") if isinstance(existing_ollama, dict) else None
+
     configured = configure_backend(
         DEFAULT_PROVIDER,
-        base_url=existing_base_url or DEFAULT_BASE_URL,
-        model=model,
+        model=DEFAULT_HF_MODEL,
         set_default=set_default,
     )
     config = load_config()
@@ -172,8 +176,15 @@ def setup_mini_brain(
         "stored_secret": False,
         "config_path": str(written_path),
         "mini_brain": contract,
-        "pull": pull,
-        "toolchain_install": toolchain_install,
+        "embedded": embedded,
+        "embedded_install": embedded_install,
+        "ollama_setup": {
+            "status": "skipped",
+            "ok": True,
+            "provider": "ollama",
+            "model": model,
+            "message": "Ollama remains optional for additional local worker models.",
+        },
         "llm_configure": configured,
         "next_steps": ["Use low-risk setup, wizard and summary prompts normally."],
     }
@@ -196,6 +207,7 @@ def planned_contract(*, model: str = DEFAULT_OLLAMA_MODEL) -> dict[str, Any]:
         "limits": dict(DEFAULT_LIMITS),
         "guardrails": list(DEFAULT_GUARDRAILS),
         "stored_secret": False,
+        "embedded": embedded_mini_brain_status(),
     }
 
 

package/runtime/cli/aikit/model_router.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import re
 from typing import Any
 
+from cli.aikit.embedded_mini_brain import EMBEDDED_BACKEND_ID
 from cli.aikit.llm import BACKENDS, doctor_backend, llm_preference, load_config
 from cli.aikit.mini_brain import mini_brain_contract
 from cli.aikit.ollama import ollama_status
@@ -14,6 +15,9 @@ from cli.aikit.write_policy import normalize_write_policy, write_policy_public_f
 OPERATIONAL_PATTERN = re.compile(
     r"(?i)\b(resum\w*|sumari\w*|classifi\w*|extra(?:i|ir|ia|cao|ção)\w*|normaliz\w*|compar\w*|logs?|rascunho|agrupe|agrupar)\b"
 )
+SIMPLE_CHAT_SETUP_PATTERN = re.compile(
+    r"(?i)\b(ol[aá]|oi|bom dia|boa tarde|boa noite|ajuda|help|comec(?:ar|o)|começ(?:ar|o)|setup|onboard|configur|instal|usar)\b"
+)
 HIGH_LEVEL_PATTERN = re.compile(
     r"(?i)\b(arquitet|decid|aprovar|reprovar|especifica|requisit|implemente|codigo|c[oó]digo|documento|automac|deploy|seguran)\b"
 )
@@ -48,7 +52,9 @@ def build_model_plan(
     mini_brain = mini_brain_contract(config=config, ollama_payload=ollama, ollama_backend=ollama_backend)
     local_available = mini_brain.get("available") is True
     operational = bool(OPERATIONAL_PATTERN.search(prompt))
+    simple_chat_setup = bool(SIMPLE_CHAT_SETUP_PATTERN.search(prompt))
     high_level = bool(HIGH_LEVEL_PATTERN.search(prompt))
+    local_provider = select_local_provider(ollama_payload=ollama, ollama_backend=ollama_backend, mini_brain=mini_brain)
     policy = choose_model_strategy(
         prompt,
         route=route,
@@ -56,10 +62,12 @@ def build_model_plan(
         specialist_tasks=specialist_tasks or [],
         configuration_tasks=configuration_tasks or [],
         operational=operational,
+        simple_chat_setup=simple_chat_setup,
         high_level=high_level,
         local_available=local_available,
     )
     use_local = policy["strategy"] == "mini-brain" and local_available
+    delegate_local = use_local and operational
     return {
         "kind": "model-plan",
         "status": "planned",
@@ -73,22 +81,30 @@ def build_model_plan(
         "max_llm_calls": policy["max_llm_calls"],
         "intent": route.get("intent") if route else "llm",
         "primary_coordinators": coordinator_order(preference),
-        "local_llm_role": "operational-worker",
+        "local_llm_role": "operational-worker" if operational else "bootstrap-coordinator",
         "local_llm_available": local_available,
-        "local_llm_provider": mini_brain.get("provider") or "ollama",
-        "local_llm_backend_configured": ollama_backend.get("status") == "ok",
+        "local_llm_provider": local_provider,
+        "local_llm_backend_configured": ollama_backend.get("configured") is True if local_provider == "ollama" else True,
         "local_llm_runtime": {
-            "binary_status": ollama.get("status"),
+            "provider": local_provider,
+            "binary_status": ollama.get("status") if local_provider == "ollama" else "embedded",
             "backend_status": ollama_backend.get("status"),
-            "model": mini_brain.get("ollama_model") or ollama_backend.get("model"),
-            "base_url": ollama_backend.get("base_url"),
+            "model": (mini_brain.get("ollama_model") or ollama_backend.get("model")) if local_provider == "ollama" else mini_brain.get("hf_model"),
+            "base_url": ollama_backend.get("base_url") if local_provider == "ollama" else None,
+        },
+        "optional_local_providers": {
+            "ollama": {
+                "status": ollama.get("status"),
+                "backend_status": ollama_backend.get("status"),
+                "model_count": ollama.get("model_count"),
+            }
         },
         "mini_brain": mini_brain,
         "local_llm_recommended": operational,
         "local_llm_selected": use_local,
         "delegation": {
-            "allowed": policy["strategy"] == "mini-brain",
-            "selected": use_local,
+            "allowed": policy["strategy"] == "mini-brain" and operational,
+            "selected": delegate_local,
             "reason": local_reason(
                 operational=operational,
                 local_available=local_available,
@@ -110,6 +126,7 @@ def choose_model_strategy(
     specialist_tasks: list[dict[str, Any]],
     configuration_tasks: list[dict[str, Any]],
     operational: bool,
+    simple_chat_setup: bool,
     high_level: bool,
     local_available: bool,
 ) -> dict[str, Any]:
@@ -154,7 +171,7 @@ def choose_model_strategy(
             max_llm_calls=0,
             matrix="Conhecida + estruturada + baixo risco -> automacao",
         )
-    if operational and not high_level:
+    if (operational or simple_chat_setup) and not high_level:
         return policy(
             "mini-brain" if local_available else "external-llm",
             "The prompt is operational and low-risk; local mini-brain is preferred when available.",
@@ -241,3 +258,19 @@ def local_reason(*, operational: bool, local_available: bool, high_level: bool,
     if operational and not local_available:
         return "Task is operational, but the local mini-brain is not enabled or available; coordinator/API fallback should execute."
     return "Task requires coordinator-level reasoning or review."
+
+
+def select_local_provider(
+    *,
+    ollama_payload: dict[str, Any],
+    ollama_backend: dict[str, Any],
+    mini_brain: dict[str, Any],
+) -> str:
+    ollama_ready = (
+        ollama_payload.get("status") == "ok"
+        and ollama_backend.get("status") == "ok"
+        and (ollama_backend.get("configured") is True or int(ollama_payload.get("model_count") or 0) > 0)
+    )
+    if ollama_ready:
+        return "ollama"
+    return str(mini_brain.get("provider") or EMBEDDED_BACKEND_ID)

package/runtime/cli/aikit/natural_prompt_runtime.py

@@ -62,6 +62,21 @@ def clean_requested_name(value: str) -> str | None:
     return cleaned[:80]
 
 
+def rename_response(updated: dict[str, Any]) -> str:
+    name = updated.get("agent_name")
+    alias = updated.get("alias") if isinstance(updated.get("alias"), dict) else {}
+    alias_name = alias.get("name") or alias.get("suggested_name")
+    path_status = alias.get("path_status") if isinstance(alias.get("path_status"), dict) else {}
+    if alias_name and path_status.get("setup_required"):
+        return (
+            f"Pronto. Meu nome local agora e {name}, e criei o comando {alias_name}. "
+            "Para chama-lo diretamente em novas sessoes do shell, execute `agent alias path --yes`."
+        )
+    if alias_name:
+        return f"Pronto. Meu nome local agora e {name}, e voce tambem pode me chamar com o comando {alias_name}."
+    return f"Pronto. Meu nome local agora e {name}."
+
+
 def is_capabilities_help_prompt(prompt: str) -> bool:
     normalized = normalize_text(prompt)
     if normalized in {"ajuda", "help", "o que voce faz", "o que voce consegue fazer"}:
@@ -138,6 +153,42 @@ def local_capabilities_help_response(prompt: str, *, name: str) -> dict[str, Any
     }
 
 
+def embedded_mini_brain_install_response(prompt: str, *, name: str, model_plan: dict[str, Any]) -> dict[str, Any]:
+    embedded = (
+        ((model_plan.get("mini_brain") or {}).get("embedded") or {})
+        if isinstance(model_plan.get("mini_brain"), dict)
+        else {}
+    )
+    status = embedded.get("status") or "not-installed"
+    response = (
+        f"Eu sou {name}. Consigo orientar o setup inicial localmente, mas o mini-cerebro local ainda nao esta instalado "
+        f"(status: {status}). Para habilitar conversa local sem Claude, Codex, Ollama ou API externa, execute "
+        "`agent setup mini-brain --yes`. Sem esse download, posso continuar com onboarding, memoria, wizards e "
+        "capabilities deterministicas."
+    )
+    return {
+        "kind": "agent",
+        "status": "needs-setup",
+        "ok": False,
+        "requires_llm": False,
+        "prompt_received": True,
+        "prompt_length": len(prompt),
+        "mode": "embedded-mini-brain-not-installed",
+        "identity": {"name": name, "source": "local"},
+        "llm_backend": "embedded-mini-brain",
+        "mini_brain": model_plan.get("mini_brain"),
+        "response": response,
+        "message": "Embedded mini-brain is not installed yet.",
+        "next_steps": [
+            "agent setup mini-brain --dry-run",
+            "agent setup mini-brain --yes",
+            "agent llm configure claude-code --set-default",
+            "agent llm configure codex-cli --set-default",
+        ],
+        "exit_code": 2,
+    }
+
+
 def agent_requires_llm(args: argparse.Namespace) -> dict[str, Any]:
     prompt = " ".join(args.prompt).strip()
     return run_agent_prompt_request(
@@ -184,7 +235,8 @@ def run_agent_prompt_request(request: AgentPromptRequest) -> dict[str, Any]:
             "prompt_length": len(prompt),
             "identity": {"name": updated.get("agent_name"), "source": "local"},
             "action": "rename",
-            "response": f"Pronto. Meu nome local agora e {updated.get('agent_name')}.",
+            "response": rename_response(updated),
+            "alias": updated.get("alias"),
         }
         return finalize_agent_session(result, session, prompt, backend=request.llm)
     if is_identity_question(prompt):
@@ -237,9 +289,15 @@ def run_agent_prompt_request(request: AgentPromptRequest) -> dict[str, Any]:
     )
     local_llm_execution = maybe_delegate_local_llm(prompt, model_plan)
     coordinator_prompt = enrich_prompt_with_local_result(contextual_prompt, local_llm_execution)
+    requested_backend = request.llm
+    if should_prompt_for_embedded_install(model_plan, requested_backend=request.llm):
+        result = embedded_mini_brain_install_response(prompt, name=name, model_plan=model_plan)
+        return finalize_agent_session(result, session, prompt, backend="embedded-mini-brain")
+    if should_use_embedded_coordinator(model_plan, requested_backend=request.llm):
+        requested_backend = "embedded-mini-brain"
     result = invoke_agent_prompt(
         coordinator_prompt,
-        request.llm,
+        requested_backend,
         public_name=name,
         allow_fallback=not request.no_llm_fallback,
     )
@@ -278,6 +336,32 @@ def run_agent_prompt_request(request: AgentPromptRequest) -> dict[str, Any]:
     return finalize_agent_session(result, session, prompt, backend=result.get("llm_backend") or request.llm)
 
 
+def should_use_embedded_coordinator(model_plan: dict[str, Any], *, requested_backend: str | None) -> bool:
+    if requested_backend:
+        return False
+    return (
+        model_plan.get("strategy") == "mini-brain"
+        and model_plan.get("local_llm_provider") == "embedded-mini-brain"
+        and model_plan.get("risk") == "low"
+    )
+
+
+def should_prompt_for_embedded_install(model_plan: dict[str, Any], *, requested_backend: str | None) -> bool:
+    if requested_backend:
+        return False
+    embedded = (
+        ((model_plan.get("mini_brain") or {}).get("embedded") or {})
+        if isinstance(model_plan.get("mini_brain"), dict)
+        else {}
+    )
+    return (
+        model_plan.get("strategy") in {"mini-brain", "external-llm"}
+        and model_plan.get("local_llm_provider") == "embedded-mini-brain"
+        and embedded.get("available") is not True
+        and model_plan.get("fallback") == "configure-local-mini-brain-or-use-external-llm"
+    )
+
+
 def mark_review_task_needs_review(execution_plan: dict[str, Any], review_result: dict[str, Any]) -> dict[str, Any]:
     task = dict(execution_plan.get("review_task") or {})
     if task:

package/runtime/cli/aikit/onboarding.py

@@ -106,16 +106,16 @@ def onboarding_plan(root: Path, mode: str) -> dict[str, Any]:
         ),
         plan_step(
             "coordinator-llm",
-            "Registrar Claude Code, Codex CLI ou API como coordenador/planejador/revisor.",
+            "Registrar Claude Code, Codex CLI ou API como coordenador/planejador/revisor opcional para tarefas de alto nivel.",
             "agent llm list",
             write_policy="local_config_write",
         ),
         plan_step(
             "mini-brain",
-            "Habilitar Qwen3-0.6B via Ollama para conversa simples, setup e tarefas operacionais leves.",
+            "Validar o mini cerebro embarcado Qwen2.5-0.5B para conversa simples, setup e tarefas operacionais leves.",
             "agent setup mini-brain --dry-run",
             write_policy="local_config_write",
-            model="qwen3:0.6b",
+            model="Qwen/Qwen2.5-0.5B-Instruct",
         ),
         plan_step(
             "sessions-and-memory",

package/runtime/cli/aikit/personality.py

@@ -6,6 +6,7 @@ import re
 from pathlib import Path
 from typing import Any
 
+from cli.aikit.aliases import ensure_alias_for_agent_name
 from cli.aikit.identity import DEFAULT_PUBLIC_NAME
 from cli.aikit.memory import MEMORY_FILE_TEMPLATES, ensure_memory, memory_home
 
@@ -60,6 +61,8 @@ def update_personality(
     path.write_text(render_personality(values), encoding="utf-8")
     payload = load_personality()
     payload["status"] = "updated"
+    if agent_name is not None and payload.get("agent_name") != DEFAULT_PUBLIC_NAME:
+        payload["alias"] = ensure_alias_for_agent_name(str(payload["agent_name"]))
     return payload