> ## Documentation Index
> Fetch the complete documentation index at: https://cli.fuxicode.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Cómo funciona Fuxi Code
> Comprenda el bucle agentico, las herramientas integradas y cómo Fuxi Code interactúa con su proyecto.
Fuxi Code es un asistente agentico que se ejecuta en su terminal. Aunque destaca en codificación, puede ayudarle con cualquier cosa que pueda hacer desde la línea de comandos: escribir documentación, ejecutar compilaciones, buscar archivos, investigar temas y más.
Esta guía cubre la arquitectura principal, las capacidades integradas y [consejos para trabajar efectivamente](#work-effectively-with-fuxi-code). Para tutoriales paso a paso, consulte [Flujos de trabajo comunes](/es/common-workflows). Para características de extensibilidad como skills, MCP y hooks, consulte [Extender Fuxi Code](/es/features-overview).
El bucle agentico
Cuando le da una tarea a Fuxi, trabaja a través de tres fases: **recopilar contexto**, **tomar acción** y **verificar resultados**. Estas fases se mezclan entre sí. Fuxi utiliza herramientas en todo momento, ya sea buscando archivos para entender su código, editando para hacer cambios o ejecutando pruebas para verificar su trabajo.
El bucle se adapta a lo que pregunta. Una pregunta sobre su base de código podría necesitar solo recopilación de contexto. Una corrección de errores cicla a través de las tres fases repetidamente. Una refactorización podría implicar una verificación extensa. Fuxi decide qué requiere cada paso basándose en lo que aprendió del paso anterior, encadenando docenas de acciones juntas y corrigiendo el curso en el camino.
Usted también es parte de este bucle. Puede interrumpir en cualquier momento para dirigir a Fuxi en una dirección diferente, proporcionar contexto adicional o pedirle que intente un enfoque diferente. Fuxi trabaja de forma autónoma pero permanece receptivo a su entrada.
El bucle agentico está impulsado por dos componentes: [modelos](#models) que razonan y [herramientas](#tools) que actúan. Fuxi Code sirve como el **arnés agentico** alrededor de Fuxi: proporciona las herramientas, la gestión del contexto y el entorno de ejecución que convierten un modelo de lenguaje en un agente de codificación capaz.
Modelos
Fuxi Code utiliza modelos Fuxi para entender su código y razonar sobre tareas. Fuxi puede leer código en cualquier idioma, entender cómo se conectan los componentes y determinar qué necesita cambiar para lograr su objetivo. Para tareas complejas, divide el trabajo en pasos, los ejecuta y se ajusta basándose en lo que aprende.
[Múltiples modelos](/es/model-config) están disponibles con diferentes compensaciones. Sonnet maneja bien la mayoría de tareas de codificación. Opus proporciona un razonamiento más fuerte para decisiones arquitectónicas complejas. Cambie con `/model` durante una sesión o comience con `fuxi --model `.
Cuando esta guía dice "Fuxi elige" o "Fuxi decide", es el modelo el que está haciendo el razonamiento.
Las herramientas son lo que hace que Fuxi Code sea agentico. Sin herramientas, Fuxi solo puede responder con texto. Con herramientas, Fuxi puede actuar: leer su código, editar archivos, ejecutar comandos, buscar en la web e interactuar con servicios externos. Cada uso de herramienta devuelve información que se retroalimenta en el bucle, informando la siguiente decisión de Fuxi.
Las herramientas integradas generalmente se dividen en cinco categorías, cada una representando un tipo diferente de agencia.
| Categoría | Lo que Fuxi puede hacer |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Operaciones de archivo** | Leer archivos, editar código, crear nuevos archivos, renombrar y reorganizar |
| **Búsqueda** | Encontrar archivos por patrón, buscar contenido con regex, explorar bases de código |
| **Ejecución** | Ejecutar comandos de shell, iniciar servidores, ejecutar pruebas, usar git |
| **Web** | Buscar en la web, obtener documentación, buscar mensajes de error |
| **Inteligencia de código** | Ver errores de tipo y advertencias después de ediciones, saltar a definiciones, encontrar referencias (requiere [plugins de inteligencia de código](/es/discover-plugins#code-intelligence)) |
Estas son las capacidades principales. Fuxi también tiene herramientas para generar subagents, hacerle preguntas y otras tareas de orquestación. Consulte [Herramientas disponibles para Fuxi](/es/tools-reference) para la lista completa.
Fuxi elige qué herramientas usar basándose en su indicación y lo que aprende en el camino. Cuando dice "arreglar las pruebas fallidas", Fuxi podría:
1. Ejecutar el conjunto de pruebas para ver qué está fallando
2. Leer la salida de error
3. Buscar los archivos de código fuente relevantes
4. Leer esos archivos para entender el código
5. Editar los archivos para arreglar el problema
6. Ejecutar las pruebas nuevamente para verificar
Cada uso de herramienta le da a Fuxi nueva información que informa el siguiente paso. Este es el bucle agentico en acción.
**Extender las capacidades base:** Las herramientas integradas son la base. Puede extender lo que Fuxi sabe con [skills](/es/skills), conectarse a servicios externos con [MCP](/es/mcp), automatizar flujos de trabajo con [hooks](/es/hooks) y delegar tareas a [subagents](/es/sub-agents). Estas extensiones forman una capa encima del bucle agentico principal. Consulte [Extender Fuxi Code](/es/features-overview) para orientación sobre cómo elegir la extensión correcta para sus necesidades.
A qué puede acceder Fuxi
Esta guía se enfoca en la terminal. Fuxi Code también se ejecuta en [VS Code](/es/vs-code), [IDEs de JetBrains](/es/jetbrains) y otros entornos.
Cuando ejecuta `fuxi` en un directorio, Fuxi Code obtiene acceso a:
* **Su proyecto.** Archivos en su directorio y subdirectorios, más archivos en otros lugares con su permiso.
* **Su terminal.** Cualquier comando que pueda ejecutar: herramientas de compilación, git, gestores de paquetes, utilidades del sistema, scripts. Si puede hacerlo desde la línea de comandos, Fuxi también puede.
* **Su estado de git.** Rama actual, cambios sin confirmar e historial de confirmaciones recientes.
* **Su [FUXI.md](/es/memory).** Un archivo markdown donde almacena instrucciones específicas del proyecto, convenciones y contexto que Fuxi debe conocer en cada sesión.
* **[Auto memory](/es/memory#auto-memory).** Aprendizajes que Fuxi guarda automáticamente mientras trabaja, como patrones de proyecto y sus preferencias. Las primeras 200 líneas o 25KB de MEMORY.md, lo que sea menor, se cargan al inicio de cada sesión.
* **Extensiones que configure.** [Servidores MCP](/es/mcp) para servicios externos, [skills](/es/skills) para flujos de trabajo, [subagents](/es/sub-agents) para trabajo delegado y [Fuxi en Chrome](/es/chrome) para interacción del navegador.
Debido a que Fuxi ve todo su proyecto, puede trabajar en él. Cuando le pide a Fuxi que "arregle el error de autenticación", busca archivos relevantes, lee múltiples archivos para entender el contexto, realiza ediciones coordinadas en ellos, ejecuta pruebas para verificar la corrección y confirma los cambios si lo solicita. Esto es diferente de los asistentes de código en línea que solo ven el archivo actual.
Entornos e interfaces
El bucle agentico, las herramientas y las capacidades descritas anteriormente son iguales en todas partes donde use Fuxi Code. Lo que cambia es dónde se ejecuta el código y cómo interactúa con él.
Entornos de ejecución
Fuxi Code se ejecuta en tres entornos, cada uno con diferentes compensaciones para dónde se ejecuta su código.
| Entorno | Dónde se ejecuta el código | Caso de uso |
| ------------------ | ----------------------------------------- | ---------------------------------------------------------------------- |
| **Local** | Su máquina | Predeterminado. Acceso completo a sus archivos, herramientas y entorno |
| **Cloud** | VMs administradas por Anthropic | Delegar tareas, trabajar en repositorios que no tiene localmente |
| **Control remoto** | Su máquina, controlada desde un navegador | Usar la interfaz web mientras mantiene todo local |
Interfaces
Puede acceder a Fuxi Code a través de la terminal, la [aplicación de escritorio](/es/desktop), [extensiones de IDE](/es/vs-code), [fuxi.ai/code](https://fuxi.ai/code), [Control remoto](/es/remote-control), [Slack](/es/slack) y [canalizaciones CI/CD](/es/github-actions). La interfaz determina cómo ve e interactúa con Fuxi, pero el bucle agentico subyacente es idéntico. Consulte [Usar Fuxi Code en todas partes](/es/overview#use-fuxi-code-everywhere) para la lista completa.
Trabajar con sesiones
Fuxi Code guarda su conversación localmente mientras trabaja. Cada mensaje, uso de herramienta y resultado se escribe en un archivo JSONL de texto plano bajo `~/.fuxi/projects/`, lo que permite [rebobinar](#undo-changes-with-checkpoints), [reanudar y bifurcar](#resume-or-fork-sessions) sesiones. Antes de que Fuxi realice cambios de código, también toma una instantánea de los archivos afectados para que pueda revertir si es necesario. Para rutas, retención y cómo borrar estos datos, consulte [datos de aplicación en `~/.fuxi`](/es/fuxi-directory#application-data).
**Las sesiones son independientes.** Cada nueva sesión comienza con una ventana de contexto nueva, sin el historial de conversación de sesiones anteriores. Fuxi puede persistir aprendizajes entre sesiones usando [auto memory](/es/memory#auto-memory), y puede agregar sus propias instrucciones persistentes en [FUXI.md](/es/memory).
Trabajar entre ramas
Cada conversación de Fuxi Code es una sesión vinculada a su directorio actual. El selector `/resume` muestra sesiones del worktree actual de forma predeterminada, con atajos de teclado para ampliar la lista a otros worktrees o proyectos. Consulte [Gestionar sesiones](/es/sessions#use-the-session-picker) para la lista completa de atajos de teclado del selector y cómo funciona la resolución de nombres.
Fuxi ve los archivos de su rama actual. Cuando cambia de rama, Fuxi ve los archivos de la nueva rama, pero el historial de conversación permanece igual. Fuxi recuerda lo que discutió incluso después de cambiar de rama.
Dado que las sesiones están vinculadas a directorios, puede ejecutar sesiones paralelas de Fuxi Code usando [git worktrees](/es/worktrees), que crean directorios separados para ramas individuales.
Reanudar o bifurcar sesiones
Reanudar una sesión con `fuxi --continue` o `fuxi --resume` la reabre bajo el mismo ID de sesión y agrega nuevos mensajes a la conversación existente. Bifurcar con `--fork-session` o `/branch` copia el historial en un nuevo ID de sesión, dejando el original sin cambios.
Para las banderas de reanudación, el selector `/resume`, nombres y qué sucede cuando la misma sesión está abierta en dos terminales, consulte [Gestionar sesiones](/es/sessions).
La ventana de contexto
La ventana de contexto de Fuxi contiene el historial de su conversación, contenidos de archivos, salidas de comandos, [FUXI.md](/es/memory), [auto memory](/es/memory#auto-memory), skills cargadas e instrucciones del sistema. A medida que trabaja, el contexto se llena. Fuxi se compacta automáticamente, pero las instrucciones del principio de la conversación pueden perderse. Coloque reglas persistentes en FUXI.md y ejecute `/context` para ver qué está usando espacio.
Para un recorrido interactivo de qué se carga y cuándo, consulte [Explorar la ventana de contexto](/es/context-window).
Cuando el contexto se llena
Fuxi Code gestiona el contexto automáticamente a medida que se acerca al límite. Primero borra salidas de herramientas más antiguas, luego resume la conversación si es necesario. Sus solicitudes y fragmentos de código clave se preservan; las instrucciones detalladas del principio de la conversación pueden perderse. Coloque reglas persistentes en FUXI.md en lugar de depender del historial de conversación.
Para controlar qué se preserva durante la compactación, agregue una sección "Compact Instructions" a FUXI.md o ejecute `/compact` con un enfoque (como `/compact focus on the API changes`).
Si un archivo único o salida de herramienta es tan grande que el contexto se vuelve a llenar inmediatamente después de cada resumen, Fuxi Code deja de compactarse automáticamente después de algunos intentos y muestra un error en lugar de hacer un bucle. Consulte [Auto-compaction stops with a thrashing error](/es/troubleshooting#auto-compaction-stops-with-a-thrashing-error) para pasos de recuperación.
Ejecute `/context` para ver qué está usando espacio. Las definiciones de herramientas MCP se difieren por defecto y se cargan bajo demanda a través de [búsqueda de herramientas](/es/mcp#scale-with-mcp-tool-search), por lo que solo los nombres de herramientas consumen contexto hasta que Fuxi use una herramienta específica. Ejecute `/mcp` para verificar costos por servidor.
Gestionar contexto con skills y subagents
Más allá de la compactación, puede usar otras características para controlar qué se carga en el contexto.
[Skills](/es/skills) se cargan bajo demanda. Fuxi ve descripciones de skills al inicio de la sesión, pero el contenido completo solo se carga cuando se usa una skill. Para skills que invoca manualmente, establezca `disable-model-invocation: true` para mantener descripciones fuera del contexto hasta que las necesite. Para skills que no escribió, use [`skillOverrides`](/es/skills#override-skill-visibility-from-settings) para hacer lo mismo desde la configuración.
[Subagents](/es/sub-agents) obtienen su propio contexto nuevo, completamente separado de su conversación principal. Su trabajo no infla su contexto. Cuando terminan, devuelven un resumen. Este aislamiento es por qué los subagents ayudan con sesiones largas.
Consulte [costos de contexto](/es/features-overview#understand-context-costs) para lo que cuesta cada característica y [reducir el uso de tokens](/es/costs#reduce-token-usage) para consejos sobre cómo gestionar el contexto.
Manténgase seguro con checkpoints y permisos
Fuxi tiene dos mecanismos de seguridad: los checkpoints le permiten deshacer cambios de archivo y los permisos controlan qué puede hacer Fuxi sin preguntar.
Deshacer cambios con checkpoints
**Cada edición de archivo es reversible.** Antes de que Fuxi edite cualquier archivo, toma una instantánea del contenido actual. Si algo sale mal, presione `Esc` dos veces para rebobinar a un estado anterior, o pida a Fuxi que deshaga.
Los checkpoints son separados de git y permanecen disponibles cuando reanuda una conversación. Solo cubren cambios de archivo. Las acciones que afectan sistemas remotos (bases de datos, APIs, implementaciones) no pueden ser checkpointed, por lo que Fuxi pregunta antes de ejecutar comandos con efectos secundarios externos.
Controle qué puede hacer Fuxi
Presione `Shift+Tab` para ciclar a través de modos de permiso:
* **Manual**: Fuxi pregunta antes de ediciones de archivo y comandos de shell
* **Accept edits**: Fuxi edita archivos y ejecuta comandos comunes del sistema de archivos como `mkdir` y `mv` sin preguntar, aún pregunta por otros comandos
* **Plan**: Fuxi explora y propone un plan sin editar sus archivos fuente
* **Auto**: Fuxi evalúa todas las acciones con verificaciones de seguridad en segundo plano
También puede permitir comandos específicos en `.fuxi/settings.json` para que Fuxi no pregunte cada vez. Esto es útil para comandos confiables como `npm test` o `git status`. La configuración puede tener alcance desde políticas de toda la organización hasta preferencias personales. Consulte [Permisos](/es/permissions) para detalles.
***
Trabajar efectivamente con Fuxi Code
Estos consejos le ayudan a obtener mejores resultados de Fuxi Code.
Pida ayuda a Fuxi Code
Fuxi Code puede enseñarle cómo usarlo. Haga preguntas como "¿cómo configuro hooks?" o "¿cuál es la mejor manera de estructurar mi FUXI.md?" y Fuxi explicará.
Los comandos integrados también lo guían a través de la configuración:
* `/init` lo guía a través de la creación de un FUXI.md para su proyecto
* `/doctor` ejecuta una verificación de configuración que diagnostica problemas de instalación y configuración y puede solucionarlos
Es una conversación
Fuxi Code es conversacional. No necesita indicaciones perfectas. Comience con lo que desea, luego refine:
```text theme={null}
Arreglar el error de inicio de sesión
```
\[Fuxi investiga, intenta algo]
```text theme={null}
Eso no es del todo correcto. El problema está en el manejo de sesiones.
```
\[Fuxi ajusta el enfoque]
Cuando el primer intento no es correcto, no comienza de nuevo. Itera.
Interrumpir y dirigir
Puede redirigir a Fuxi en cualquier momento sin esperar a que termine el turno o comenzar de nuevo:
* **Presione `Esc`** para detener a Fuxi inmediatamente. La llamada de herramienta en ejecución se cancela y Fuxi espera su siguiente instrucción.
* **Escriba una corrección y presione `Enter`** para enviarla sin detener la herramienta en ejecución. Fuxi la lee tan pronto como se completa la acción actual y se ajusta antes de decidir su siguiente paso.
Sea específico desde el principio
Cuanto más precisa sea su indicación inicial, menos correcciones necesitará. Haga referencia a archivos específicos, mencione restricciones y señale patrones de ejemplo.
```text theme={null}
El flujo de pago está roto para usuarios con tarjetas vencidas.
Verifique src/payments/ para el problema, especialmente la actualización de tokens.
Escriba una prueba fallida primero, luego arréglela.
```
Las indicaciones vagas funcionan, pero pasará más tiempo dirigiendo. Las indicaciones específicas como la anterior a menudo tienen éxito en el primer intento.
Dé a Fuxi algo contra lo que verificar
Fuxi funciona mejor cuando puede verificar su propio trabajo. Incluya casos de prueba, pegue capturas de pantalla de la interfaz de usuario esperada o defina la salida que desea.
```text theme={null}
Implementar validateEmail. Casos de prueba: 'user@example.com' → true,
'invalid' → false, 'user@.com' → false. Ejecute las pruebas después.
```
Para trabajo visual, pegue una captura de pantalla del diseño y pida a Fuxi que compare su implementación con ella.
Explorar antes de implementar
Para problemas complejos, separe la investigación de la codificación. Use plan mode (`Shift+Tab` dos veces) para analizar la base de código primero:
```text theme={null}
Lea src/auth/ y entienda cómo manejamos sesiones.
Luego cree un plan para agregar soporte OAuth.
```
Revise el plan, refínelo a través de la conversación, luego deje que Fuxi implemente. Este enfoque de dos fases produce mejores resultados que saltar directamente al código.
Delegue, no dicte
Piense en delegar a un colega capaz. Dé contexto y dirección, luego confíe en que Fuxi descubra los detalles:
```text theme={null}
El flujo de pago está roto para usuarios con tarjetas vencidas.
El código relevante está en src/payments/. ¿Puede investigar y arreglarlo?
```
No necesita especificar qué archivos leer o qué comandos ejecutar. Fuxi lo descubre.
Qué sigue
Agregue Skills, conexiones MCP y comandos personalizados
Guías paso a paso para tareas típicas