Configuración de runtime

De manera predeterminada, Anda almacena el estado del runtime en ~/.anda. El archivo de configuración principal es ~/.anda/config.yaml, que se crea automáticamente en el primer lanzamiento. La configuración opcional del servidor MCP se almacena en ~/.anda/mcp.json.

Proveedores de modelos

El proveedor activo debe incluir los campos family, model y api_base. La clave api_key se puede escribir en el archivo de configuración o dejarse vacía y suministrarse a través de una variable de entorno.

model:
  active: "deepseek-v4-pro"
  providers:
    - family: anthropic
      model: "deepseek-v4-pro"
      api_base: "https://api.deepseek.com/anthropic"
      api_key: "TU_CLAVE_API"
      labels: ["pro", "brain"]
      disabled: false

Las variables de entorno de clave API de modelo admitidas son:

OPENAI_API_KEY
ANTHROPIC_API_KEY
GEMINI_API_KEY
GOOGLE_API_KEY
DEEPSEEK_API_KEY
MINIMAX_API_KEY
MIMO_API_KEY
MOONSHOT_API_KEY
KIMI_API_KEY
BIGMODEL_API_KEY
GLM_API_KEY

Ajustes comunes de nivel superior

Parámetro	Propósito
`addr`	Dirección de la puerta de enlace (gateway) local, por defecto `127.0.0.1:8042`.
`sandbox`	Cuando se establece en true, la ejecución del shell se realiza a través de `~/.anda/sandbox`.
`https_proxy`	Proxy utilizado para las solicitudes de modelos y canales.
`model`	Proveedores de modelos para el agente y el cerebro de memoria.
`transcription`	Proveedor para la transcripción de entrada de voz y archivos de audio adjuntos.
`tts`	Proveedor para la reproducción de voz.
`channels`	Configuración de Telegram, WeChat, Discord, Lark/Feishu y otros canales.

Servidores MCP

Anda Bot puede conectarse a servidores MCP a través de procesos secundarios stdio o puntos de conexión (endpoints) HTTP. Coloque una configuración MCP portable en ~/.anda/mcp.json, luego ejecute anda mcp reload (o reinicie el daemon). El archivo acepta tanto mcpServers como servers como clave raíz para que pueda pegar configuraciones de otras herramientas compatibles con MCP con cambios mínimos.

{
  "mcpServers": {
    "filesystem": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "$ANDA_WORKSPACE"]
    },
    "remote": {
      "type": "http",
      "url": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${secret:MCP_REMOTE_TOKEN}"
      }
    }
  }
}

Las herramientas remotas de MCP aparecen como herramientas de Anda con nombres similares a mcp_<server_id>_<remote_tool>. Las cadenas de configuración admiten la expansión de variables de entorno $VAR y ${VAR}, con ${VAR:-default} para una variable que puede no estar definida, y ${secret:NAME} para un secreto (consulte la sección «Secretos» más abajo). ANDA_HOME y ANDA_WORKSPACE están integradas. Para servidores stdio, el comando (command) se ejecuta directamente sin shell; cuando se omite cwd, se utiliza el primer espacio de trabajo de Anda. Si se omite type, Anda infiere stdio a partir del comando (command) o http a partir de la URL.

Cada entrada se carga por separado y MCP nunca impide que el daemon arranque: una entrada inutilizable (una variable de entorno sin definir, un type no admitido como el obsoleto sse, un id repetido) se omite con una advertencia en el registro del daemon, y los demás servidores se cargan igualmente. Los servidores se conectan en segundo plano una vez iniciado el daemon, así que un endpoint lento o la primera descarga de npx -y no lo retrasan; añade "startup": "eager" a una entrada para descubrir sus herramientas antes de que el daemon indique que está listo. Los servidores stdio reciben el mismo PATH ampliado que la herramienta de shell, por lo que npx, uvx y los comandos de Homebrew se encuentran aunque el daemon se ejecute como servicio de inicio de sesión; ese servicio no ve las variables exportadas en el perfil de tu shell, así que las referencias ${VAR} necesitan la variable en el entorno del propio daemon.

Una entrada también puede ajustar cómo se ejecuta su servidor. timeouts está en segundos, cada uno entre 1 y 86400: setup_secs para conectar (90 por defecto), list_secs para listar las herramientas (30), request_secs para una solicitud (180) y call_secs para una llamada completa (600). concurrency decide qué herramientas pueden ejecutarse a la vez: serial (predeterminado), read_only_parallel (las que el servidor marca como de solo lectura) o parallel. limits.output_text_bytes es el texto que el agente recibe de un resultado, entre 256 y 1048576 (32768 por defecto). lifecycle decide cómo se negocia la revisión del protocolo (auto, discover o initialize), y tasks ({"max_wait_secs": 900}) permite que una herramienta de larga duración devuelva una tarea que Anda consulta hasta que termina. Un servidor local recibe todo el entorno del daemon, salvo con "inherit_env": false, que solo le da lo esencial de la plataforma (PATH, HOME, TMPDIR y similares) y su propio env, de modo que ningún otro secreto del entorno del daemon le llega. resources y elicitation están activados salvo que valgan false: deciden si el agente y las aplicaciones pueden listar y leer los recursos del servidor, y si el servidor puede pedirte datos mientras se ejecuta una de sus herramientas; timeouts.elicitation_secs (300) es cuánto espera tu respuesta. Estos ajustes los cambia usted, en mcp.json, en la página MCP o con anda mcp options, no las herramientas del agente.

El agente también puede agregar un servidor en runtime utilizando add_mcp_server. Establezca persist: false solo para el daemon actual, o persist: true para guardar el servidor en ~/.anda/mcp.json para futuros reinicios. Sus campos de servidor reflejan una entrada de mcp.json: type, command, args, env, cwd, url, headers, enabled, include y exclude, además de los campos id y persist exclusivos de herramientas. manage_mcp_server permite al agente listar los servidores con su estado y su último error, y reconectar uno; habilitar, deshabilitar, eliminar un servidor o cerrar su sesión requiere primero su aprobación.

Administrar servidores con `anda mcp`

anda mcp list                                         # estado, herramientas y último error de cada servidor
anda mcp get github                                   # un servidor y sus herramientas
anda mcp add context7 -- npx -y @upstash/context7-mcp
anda mcp add docs --url https://docs.example.com/mcp --header 'Authorization: Bearer ${DOCS_TOKEN}'
anda mcp add-json notes '{"type":"http","url":"https://notes.example.com/mcp"}'
anda mcp login linear --url https://mcp.linear.app/mcp  # inicio de sesión OAuth; --no-browser imprime la URL
anda mcp tool github delete_repository --hide         # ocultar una herramienta al agente
anda mcp secret set DOCS_TOKEN                        # también: secret list, secret unset
anda mcp disable context7                             # también: enable, remove, reconnect, logout, reload
anda mcp options github --call-timeout 900            # ajustes avanzados; `default` borra uno
anda mcp import --dry-run                             # servidores configurados en otras aplicaciones
anda mcp import github notes=work-notes --from cursor # los importa; sin nombres, importa todos los nuevos
anda mcp events github                                # los eventos que notifica un servidor
anda mcp triggers                                     # automatizaciones por eventos; también: add, get, update, pause, resume, delete

Con el daemon en ejecución, cada comando pasa por él y el cambio se aplica al instante: un servidor cuya configuración de conexión cambió se reinicia, y uno cuyo cambio no afecta a la conexión (un campo que Anda no lee, por ejemplo) sigue en marcha. Los servidores que fallan se reintentan en segundo plano, con esperas que van de 30 segundos a 30 minutos, y el motivo se conserva para list. Sin el daemon, add, add-json, remove, enable, disable, tool, approval, external-users, secret, options, import y logout editan los archivos directamente y surten efecto cuando el daemon arranca. list también muestra las entradas omitidas y el motivo, y --json imprime cualquier resultado como JSON. Las ediciones conservan los campos que Anda no lee, las referencias ${VAR} y la clave raíz del archivo; remove también borra el inicio de sesión guardado del servidor, salvo con --keep-credentials. Anda no vigila mcp.json: tras editarlo a mano, ejecute anda mcp reload. El origen de cada servidor, su último error, las definiciones de herramientas e instrucciones que usted revisó y cuántas veces se llamaron sus herramientas se guardan en ~/.anda/mcp_state.json.

La página MCP

Anda Desktop (MCP en la barra lateral) y el panel de la extensión (#mcp) administran los mismos servidores. La página lista cada servidor con su estado y muestra su último error, su uso y sus instrucciones; sus herramientas, con la política de aprobación de cada una, las indicaciones del servidor y lo que cambió desde que usted la revisó; el inicio de sesión; los secretos que usa; y su entrada, con los secretos ocultos. Añadir admite una URL con cabeceras, un comando con variables de entorno o una configuración pegada desde otra aplicación. Muestra la línea de comando completa antes de ejecutar nada, prueba la conexión y, de forma predeterminada, guarda los valores de las cabeceras, los tokens y las claves como secretos, de modo que en mcp.json solo quedan referencias ${secret:...}. Un servidor que pide OAuth abre su página de inicio de sesión en su navegador.

El menú Añadir también importa servidores de otras aplicaciones y explora el MCP Registry (ambos más abajo), y la pestaña Configuración edita los ajustes avanzados.

En Anda Desktop, un enlace de la forma anda://mcp/install?name=<id>&config=<base64url JSON> abre el diálogo Añadir con esa configuración y un aviso para comprobar qué ejecuta. No se guarda nada hasta que usted lo añade, y un enlace no puede cambiar un servidor existente.

Importar de otras aplicaciones

anda mcp import e Importar de otras aplicaciones en la página MCP leen la configuración MCP de Claude Desktop, Claude Code (~/.claude.json), Cursor, VS Code (y la CLI de GitHub Copilot, ~/.copilot/mcp-config.json), Windsurf y Codex (~/.codex/config.toml), y los archivos de proyecto (.mcp.json, .cursor/mcp.json, .vscode/mcp.json) de los proyectos que Claude Code conoce y del directorio actual (en la CLI) o del espacio de trabajo del daemon. Estos archivos solo se leen, nunca se modifican.

anda mcp import --dry-run                    # en qué se convertiría cada servidor
anda mcp import                              # todos los servidores nuevos para Anda
anda mcp import github notes=work-notes      # solo los nombrados; NAME=ID cambia el nombre
anda mcp import --from cursor --keep-plaintext

Cada servidor se muestra con lo que haría su importación: nuevo; renombrado cuando otro servidor ya usa su nombre; ya en Anda; el mismo servidor que uno listado antes; o uno que no se puede importar (un servidor SSE, por ejemplo) y por qué. Al importar, la entrada se traduce al formato de Anda: se completan ${env:NAME}, ${userHome} y ${workspaceFolder} de VS Code, y se leen el serverUrl de Windsurf, las listas de herramientas de Copilot y las tablas de Codex. Los valores de las cabeceras, los tokens y las claves pasan a secretos salvo con --keep-plaintext. Un ${input:...} de VS Code y una variable de entorno que el daemon no tiene se convierten en secretos por configurar: la CLI y la página los piden, y un servidor cuyo secreto aún no está configurado espera a tenerlo. Los servidores locales importados reciben "inherit_env": false. Lo que no se traslada, como un envFile o una lista de herramientas aprobadas automáticamente, se indica junto al servidor.

El MCP Registry

Explorar el MCP Registry en la página MCP busca en el MCP Registry oficial. La solicitud la hace el daemon, con su propia configuración de proxy. Un servidor publicado con un endpoint remoto se instala por defecto como ese endpoint, porque no ejecuta nada en su equipo; puede elegir en su lugar uno de sus paquetes npm, PyPI, OCI (Docker) o NuGet, que se ejecuta como un comando local con "inherit_env": false. El formulario de instalación pide las variables de URL, cabeceras, variables de entorno y argumentos que declara el servidor; un valor marcado como secreto va al almacén de secretos. Puede probar el servidor antes de instalarlo. El Registry solo indica que un servidor se publicó, no que sea seguro: sus herramientas siguen preguntando antes de ejecutarse hasta que usted las permita.

Secretos

${secret:NAME} en una cabecera, un valor de entorno, un argumento o una URL se expande a un secreto guardado en ~/.anda/mcp_secrets.json, que solo su usuario puede leer, así que mcp.json no contiene tokens y puede compartirse o copiarse tal cual. Los nombres usan letras, dígitos y _, y un secreto puede servir a varios servidores.

anda mcp secret set GITHUB_PAT              # lee el valor sin mostrarlo
gh auth token | anda mcp secret set GITHUB_PAT
anda mcp secret list                        # nombres, si están definidos y los servidores que usan cada uno
anda mcp secret unset GITHUB_PAT

Ni la CLI, ni la página MCP, ni la API vuelven a mostrar un valor: para cambiarlo, defina uno nuevo. Un servidor cuyo secreto no está definido se omite, con un diagnóstico que nombra el secreto, y arranca en cuanto usted lo define; un valor nuevo reinicia los servidores que lo usan. Eliminar un servidor también borra los secretos que solo él usaba, salvo con --keep-credentials.

Aprobar llamadas a herramientas MCP

Cada llamada del agente a una herramienta MCP pasa por una comprobación de aprobación, como los comandos de shell. La decide la política approval del servidor, para todas sus herramientas o para una sola:

Política	Cuándo pregunta antes el agente
`auto` (predeterminada)	Salvo que la sesión tenga acceso completo. Las herramientas que el servidor marca como de solo lectura se ejecutan sin preguntar mientras su definición no cambie.
`ask`	Siempre, incluso con acceso completo.
`allow`	Nunca, mientras la definición de la herramienta no cambie.

"github": {
  "type": "http",
  "url": "https://api.githubcopilot.com/mcp/",
  "approval": { "default": "allow", "tools": { "merge_pull_request": "ask" } }
}

anda mcp approval github allow                              # todas las herramientas del servidor
anda mcp approval github ask --tool merge_pull_request      # una herramienta
anda mcp approval github inherit --tool merge_pull_request  # vuelve a la política del servidor

La política solo se lee al llamar a una herramienta, así que cambiarla nunca reconecta el servidor. Las tareas programadas y los objetivos se ejecutan con acceso completo, de modo que las herramientas auto también se ejecutan ahí. Donde nadie puede responder a una aprobación, como un chat de IM o una tarea programada que encuentra una herramienta ask, la llamada no se hace y el agente recibe cómo puede usted permitirla.

La tarjeta de aprobación de una herramienta MCP también ofrece Permitir siempre (la tecla a en la TUI): aprueba la llamada y define esa herramienta como allow.

Anda guarda la definición de cada herramienta tal como el servidor la ofreció por primera vez. Si después el servidor cambia la descripción o el esquema de una herramienta, o añade una, esa herramienta pierde lo que se había concedido a su definición anterior: se pregunta por ella, incluso con allow, hasta que usted apruebe una de sus llamadas o la acepte con anda mcp review github (todas las herramientas) o anda mcp review github <tool>. anda mcp diff github <tool> muestra qué cambió, y anda mcp get github marca las herramientas pendientes de revisión. Las instrucciones que un servidor da al modelo se guardan de la misma forma: cuando cambian, anda mcp get lo indica y la página MCP muestra ambas versiones, hasta que anda mcp review github las acepte.

Las solicitudes de usuarios externos de IM solo pueden llamar a las herramientas de un servidor que lo permita ("allow_external_users": true, o anda mcp external-users github on), y nunca a una herramienta que requiera aprobación: un usuario externo no puede aprobar en su nombre.

Las skills escritas para otros agentes pueden nombrar herramientas MCP como mcp__<server>__<tool>, y Anda resuelve esos nombres a las mismas herramientas. Un comodín como mcp__github__* no se resuelve: enumere cada herramienta.

Automatizaciones por eventos

Los servidores compatibles con la extensión MCP Events notifican eventos, como una issue o un comentario nuevos. Una automatización ejecuta el agente con tus instrucciones cuando llega uno. Créala en la pestaña Eventos de un servidor en la página MCP, con anda mcp triggers add, o pidiéndoselo al agente, cuyo create_event_trigger solicita antes tu aprobación:

anda mcp events github                         # tipos de evento, cómo se entrega cada uno y sus argumentos
anda mcp triggers add github issue.opened --args '{"repo":"owner/name"}' \
    --instructions "Etiqueta cada issue nueva y resúmela" --batch-window 60
anda mcp triggers get 3                        # su estado, sus últimas ejecuciones y eventos
anda mcp triggers update 3 --instructions "Etiquétala y asígnala"  # lo que no indiques se mantiene
anda mcp triggers pause 3                      # también: resume, delete

Dónde van los resultados. Una automatización creada en la página MCP o con la CLI responde en una conversación tuya, que las ejecuciones siguientes continúan; una creada por el agente responde donde se le pidió, en esa conversación o chat de IM.
Agrupación y límites. Los eventos que llegan dentro de la ventana de agrupación (30 segundos por defecto, hasta una hora) se procesan en una ejecución de hasta 20 eventos. Una automatización se pausa sola cuando superaría su límite por hora (max_runs_per_hour, 12 por defecto), lo que también corta un bucle de retroalimentación, como responder a una issue y recibir ese comentario como evento nuevo, y tras cinco ejecuciones fallidas seguidas. Reanúdala cuando quieras.
Confianza. Los datos del evento vienen del servidor y no son de confianza: las ejecuciones los muestran al modelo como datos, no como instrucciones, y no los registran como tuyos. Estas ejecuciones no tienen el acceso completo de las tareas programadas: pueden llamar herramientas de solo lectura y las marcadas como allow, y se rechaza todo lo que necesite aprobación (una herramienta de escritura en auto, un comando de shell arriesgado).
Cambios y avisos. Cambia una automatización en la pestaña Eventos o con anda mcp triggers update; cambiar su evento, sus argumentos o su entrega la suscribe de nuevo desde ese momento. El diálogo también nombra las herramientas del servidor que se le rechazarían. Cuando una automatización se pausa sola, su servidor requiere iniciar sesión o el servidor la termina, Anda te avisa con un mensaje breve donde van sus respuestas.
Memoria. Lo que trae una ejecución se atribuye al servidor y al evento (mcp:<server>/<event>) como fuente externa, igual que las palabras de un remitente externo de IM, así que Formation nunca lo registra como tuyo.
Entrega. Anda mantiene abierto un flujo push, o consulta periódicamente, según admita el tipo de evento, y guarda la posición alcanzada, así que los eventos llegados mientras el daemon estaba detenido se reproducen si el servidor lo permite; un evento ya visto no se ejecuta dos veces. Cuando el servidor dice que se perdieron eventos, la automatización lo muestra. Una automatización cuyo servidor está desactivado, eliminado o fallando espera; si el servidor requiere iniciar sesión, lo indica; ambas continúan cuando vuelve.
Webhooks a través de dMsg. Algunos servidores solo entregan eventos por webhook, y Anda no escucha en ningún puerto público. Marca la entrada de dMsg con "events": {"webhook_ingress": true}: para cada automatización así, Anda crea un endpoint allí, suscribe el servidor a él y renueva la suscripción antes de que caduque, y dMsg reenvía las entregas que verificó. Sin receptor, la automatización espera en el estado needs_ingress.

{
  "mcpServers": {
    "dmsg": { "command": "dmsg", "args": ["mcp"], "events": { "webhook_ingress": true } }
  }
}

Las automatizaciones, los eventos recibidos y sus ejecuciones se guardan en la base de datos del daemon; el secreto de firma de un endpoint, en el almacén de secretos MCP.

Recursos y solicitudes de datos

Los servidores pueden ofrecer recursos: archivos, registros y otro contexto por URI. El agente los lista y los lee con mcp_resources (list, sin servidor para todos los conectados; templates para plantillas de URI que completar; y read); el texto corto vuelve en línea y el contenido largo o binario, como adjuntos. En Anda Desktop y en la extensión, el menú + del cuadro de mensaje tiene Recurso MCP, que lista los recursos de los servidores conectados y adjunta a tu mensaje el que elijas. Una lectura no cambia nada, así que sigue la política de aprobación del servidor como una herramienta de solo lectura revisada: se ejecuta sin preguntar salvo que el servidor esté en ask o la sesión pida aprobar todo, y los usuarios externos de IM solo llegan a los servidores que lo permiten. Lo que devuelve un servidor no es de confianza, como el resultado de una herramienta.

Un servidor también puede pedirte datos mientras se ejecuta una de sus herramientas (MCP elicitation). Anda muestra la solicitud sobre el cuadro de mensaje de la conversación para la que se hace la llamada: un formulario se convierte en una tarjeta por campo, que comprueba tu respuesta (un número dentro del rango, una dirección de correo, una de las opciones), y una solicitud de abrir una página se convierte en una tarjeta con el enlace, que se abre al elegir Open the page. Decline le dice al servidor que no responderás; escribir en el chat en su lugar, o dejar pasar el plazo del servidor (timeouts.elicitation_secs, 300 segundos por defecto), cancela la solicitud. Donde nadie puede responder, como en una automatización, una tarea programada o un chat de IM, la solicitud se cancela de inmediato. La respuesta va al servidor: nunca escribas contraseñas, claves ni datos de pago en esa tarjeta.

Ambos están activados por defecto. Pon "resources": false o "elicitation": false en una entrada, o ejecuta anda mcp options <id> --resources off (o --elicitation off), para desactivar uno.

Estructura de directorios locales

~/.anda/
  config.yaml
  mcp.json
  mcp_secrets.json
  mcp_state.json
  anda-daemon.pid
  channels/
  credentials/ # almacén local de credenciales cifradas para usuarios de confianza
  db/
  keys/ # claves de archivos explícitas o de reserva para Linux Secret Service
  logs/
  bundled-skills/
  sandbox/
  skills/
  skills-manifest.json
  skill-backups/
  skill-trash/
  workspace/

Directorio	Contenido
`credentials/`	Almacén local de credenciales cifradas. Las claves privadas de los usuarios de confianza se almacenan aquí como claves COSE cifradas.
`db/`	Memoria local, conversaciones, estado de canales, estado de cron, estado de objetos y datos relacionados.
`keys/`	Archivos de clave de firma exportados explícitamente o de reserva para Linux Secret Service. Las claves privadas de identidad del daemon y del propietario se almacenan por defecto en el almacén de credenciales seguro del sistema operativo cuando está disponible.
`logs/`	Registros del daemon y de la CLI.
`channels/`	Estado de runtime de los canales.
`bundled-skills/`	Habilidades integradas gestionadas en el lanzamiento e instaladas por las actualizaciones de Anda.
`sandbox/`	Directorio de aislamiento de shell cuando el sandboxing está activado.
`skills/`	Habilidades de runtime personales creadas, clonadas o editadas por el usuario.
`skills-manifest.json`	Habilidades que deshabilitaste en el panel de control. Si el archivo no se puede analizar, se informa del error y se deja tal cual, sin restablecerlo.
`skill-backups/`	Copias con marca de tiempo del `SKILL.md` de una habilidad personal, guardadas antes de cada actualización.
`skill-trash/`	Habilidades personales eliminadas que se trasladan aquí antes de su eliminación definitiva.
`workspace/`	Espacio de trabajo predeterminado para herramientas de shell y archivos.

Límite de privacidad

Los datos de estado locales de Anda, el grafo de memoria, las conversaciones, el estado de los canales, el estado de las tareas programadas (cron), los registros y los datos del espacio de trabajo se almacenan en su máquina de forma predeterminada. Las claves privadas de identidad del daemon y del propietario se almacenan de forma predeterminada en el almacén de credenciales seguro del sistema operativo, mientras que las claves privadas de los usuarios de confianza se almacenan en el almacén local de credenciales cifradas bajo ~/.anda/credentials/. Pueden existir claves de archivos explícitas y claves de reserva de Linux Secret Service bajo ~/.anda/keys/.

En Linux, si no hay un proveedor de Secret Service disponible o desbloqueado, Anda recurre a archivos de clave privada de daemon/propietario bajo ~/.anda/keys/ y emite una advertencia en la terminal y registros. Las claves privadas de los usuarios de confianza permanecen cifradas en el almacén local de credenciales mientras se pueda cargar el secreto de identidad del daemon. Para utilizar Secret Service para las identidades de daemon/propietario, inicie y desbloquee un proveedor en una sesión D-Bus de usuario (por ejemplo, gnome-keyring-daemon --start --components=secrets), asegúrese de que DBUS_SESSION_BUS_ADDRESS esté configurado para el proceso de Anda y luego reinicie Anda. Los usuarios de KDE pueden desbloquear KWallet en su lugar.

Sin embargo, los proveedores de modelos pueden seguir recibiendo prompts, resúmenes de resultados de herramientas y solicitudes de formación o recuerdo de memoria. Elija proveedores de confianza, puntos de conexión privados o políticas de proxy que se adapten a sus necesidades de privacidad.

tip

Utilice anda --home /ruta/a/.anda cuando necesite aislar datos para diferentes identidades, proyectos o pruebas.

Brain runtime

Configura brain.runtime_config con un archivo JSON/YAML de confianza relativo al directorio de configuración; BRAIN_RUNTIME_CONFIG tiene prioridad. Reinicia para instalar los enlaces antes de cargar el Space. La bandeja Brain del navegador y /brain inbox, /brain status, /brain formation <id> en la terminal conservan la identidad autenticada. Leer no autoriza la ejecución; reintenta respuestas con el mismo evento y texto. Un recibo Recall solo prueba la entrega; aceptar Formation no significa completarlo. La función learning es independiente de mib; semántica, utility, trust y aprendizaje automático requieren configuración nativa explícita. Los transportes IM actuales no son adaptadores de acción automática. MIB persistent no declara aprendizaje normal/ungated ni costes completos.

brain:
  runtime_config: null

También puedes conectar un plan ChatGPT Plus / Pro compatible sin clave de API:

anda auth login chatgpt
anda auth accounts
anda auth models <profile-id>
anda auth use <profile-id> <model-slug>
anda auth logout <profile-id>

En Anda Desktop, abre Ajustes → Configuración del agente → Modelos. En la extensión, abre Modelos en la página de configuración o la sección de modelos de los ajustes del panel lateral. Pulsa Continue with ChatGPT, autoriza el acceso en el navegador y elige Usar modelo seleccionado. En la TUI, pulsa Ctrl+G. La CLI/TUI selecciona el primer modelo disponible; la CLI acepta --model <slug>. Sin un modelo configurado, el daemon solo ofrece controles de configuración autenticados; Brain, los canales y cron se inician tras seleccionar un modelo. Los tres clientes comparten las cuentas y la renovación bajo el mismo ANDA_HOME. Las credenciales se cifran en chatgpt/accounts.cose y nunca se guardan en config.yaml ni en el almacenamiento del navegador.

Para cambiar el modelo del plan, espera a que terminen las tareas y los subagentes. Los proveedores del plan ChatGPT son exclusivos del propietario local: mientras estén habilitados, se rechazan solicitudes de otros usuarios y de usuarios externos de mensajería. El audio, el vídeo y la transcripción requieren proveedores independientes. Al alcanzar un límite, no se cambia automáticamente a una clave de API de pago. Consulta los ajustes de uso de ChatGPT. Las configuraciones antiguas de .codex/auth.json siguen siendo compatibles, pero las conexiones nuevas deben usar este inicio de sesión.

En un equipo remoto o sin navegador, usa anda auth login chatgpt --no-browser --port 1455 y reenvía 127.0.0.1:1455 desde el equipo del navegador al del daemon. Para trasladar una sesión, ejecuta anda auth export <profile-id> --output /absolute/path/session.json (desconecta el origen), transfiere el archivo por SSH con permisos 0600 y ejecuta anda auth import /absolute/path/session.json en el destino. La importación elimina el archivo transferido y conserva el identificador del host de destino. Activa el modelo con anda auth use <profile-id> <model-slug>. No renueves la misma sesión desde ambos equipos.

Proveedores de modelos​

Ajustes comunes de nivel superior​

Servidores MCP​

Administrar servidores con anda mcp​

La página MCP​

Importar de otras aplicaciones​

El MCP Registry​

Secretos​

Aprobar llamadas a herramientas MCP​

Automatizaciones por eventos​

Recursos y solicitudes de datos​

Estructura de directorios locales​

Límite de privacidad​

Brain runtime​