> ## 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.
# Como Fuxi Code funciona
> Entenda o loop agentic, as ferramentas integradas e como Fuxi Code interage com seu projeto.
Fuxi Code é um assistente agentic que funciona em seu terminal. Embora se destaque em codificação, pode ajudar com qualquer coisa que você possa fazer a partir da linha de comando: escrever documentação, executar compilações, pesquisar arquivos, pesquisar tópicos e muito mais.
Este guia cobre a arquitetura principal, capacidades integradas e [dicas para trabalhar efetivamente](#work-effectively-with-fuxi-code). Para instruções passo a passo, consulte [Fluxos de trabalho comuns](/pt/common-workflows). Para recursos de extensibilidade como skills, MCP e hooks, consulte [Estender Fuxi Code](/pt/features-overview).
O loop agentic
Quando você dá uma tarefa a Fuxi, ele trabalha através de três fases: **reunir contexto**, **tomar ação** e **verificar resultados**. Essas fases se misturam. Fuxi usa ferramentas ao longo do processo, seja pesquisando arquivos para entender seu código, editando para fazer alterações ou executando testes para verificar seu trabalho.
O loop se adapta ao que você pede. Uma pergunta sobre sua base de código pode precisar apenas de coleta de contexto. Uma correção de bug passa por todas as três fases repetidamente. Uma refatoração pode envolver verificação extensiva. Fuxi decide o que cada etapa requer com base no que aprendeu da etapa anterior, encadeando dezenas de ações e se autocorrigindo ao longo do caminho.
Você também faz parte deste loop. Você pode interromper em qualquer ponto para orientar Fuxi em uma direção diferente, fornecer contexto adicional ou pedir que tente uma abordagem diferente. Fuxi trabalha autonomamente, mas permanece responsivo à sua entrada.
O loop agentic é alimentado por dois componentes: [modelos](#models) que raciocinam e [ferramentas](#tools) que agem. Fuxi Code serve como o **agentic harness** ao redor de Fuxi: fornece as ferramentas, gerenciamento de contexto e ambiente de execução que transformam um modelo de linguagem em um agente de codificação capaz.
Models
Fuxi Code usa modelos Fuxi para entender seu código e raciocinar sobre tarefas. Fuxi pode ler código em qualquer linguagem, entender como os componentes se conectam e descobrir o que precisa mudar para alcançar seu objetivo. Para tarefas complexas, ele divide o trabalho em etapas, as executa e se ajusta com base no que aprende.
[Múltiplos modelos](/pt/model-config) estão disponíveis com diferentes compensações. Sonnet lida bem com a maioria das tarefas de codificação. Opus fornece raciocínio mais forte para decisões arquitetônicas complexas. Mude com `/model` durante uma sessão ou comece com `fuxi --model `.
Quando este guia diz "Fuxi escolhe" ou "Fuxi decide", é o modelo fazendo o raciocínio.
Ferramentas são o que tornam Fuxi Code agentic. Sem ferramentas, Fuxi pode apenas responder com texto. Com ferramentas, Fuxi pode agir: ler seu código, editar arquivos, executar comandos, pesquisar a web e interagir com serviços externos. Cada uso de ferramenta retorna informações que alimentam o loop, informando a próxima decisão de Fuxi.
As ferramentas integradas geralmente se enquadram em cinco categorias, cada uma representando um tipo diferente de agência.
| Categoria | O que Fuxi pode fazer |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Operações de arquivo** | Ler arquivos, editar código, criar novos arquivos, renomear e reorganizar |
| **Pesquisa** | Encontrar arquivos por padrão, pesquisar conteúdo com regex, explorar bases de código |
| **Execução** | Executar comandos shell, iniciar servidores, executar testes, usar git |
| **Web** | Pesquisar a web, buscar documentação, procurar mensagens de erro |
| **Inteligência de código** | Ver erros de tipo e avisos após edições, pular para definições, encontrar referências (requer [plugins de inteligência de código](/pt/discover-plugins#code-intelligence)) |
Essas são as capacidades principais. Fuxi também tem ferramentas para gerar subagents, fazer perguntas a você e outras tarefas de orquestração. Consulte [Ferramentas disponíveis para Fuxi](/pt/tools-reference) para a lista completa.
Fuxi escolhe quais ferramentas usar com base em seu prompt e no que aprende ao longo do caminho. Quando você diz "corrigir os testes falhando", Fuxi pode:
1. Executar o conjunto de testes para ver o que está falhando
2. Ler a saída de erro
3. Pesquisar os arquivos de código-fonte relevantes
4. Ler esses arquivos para entender o código
5. Editar os arquivos para corrigir o problema
6. Executar os testes novamente para verificar
Cada uso de ferramenta dá a Fuxi novas informações que informam a próxima etapa. Este é o loop agentic em ação.
**Estendendo as capacidades base:** As ferramentas integradas são a base. Você pode estender o que Fuxi sabe com [skills](/pt/skills), conectar a serviços externos com [MCP](/pt/mcp), automatizar fluxos de trabalho com [hooks](/pt/hooks) e delegar tarefas a [subagents](/pt/sub-agents). Essas extensões formam uma camada sobre o loop agentic principal. Consulte [Estender Fuxi Code](/pt/features-overview) para orientação sobre como escolher a extensão certa para suas necessidades.
O que Fuxi pode acessar
Este guia se concentra no terminal. Fuxi Code também funciona em [VS Code](/pt/vs-code), [IDEs JetBrains](/pt/jetbrains) e outros ambientes.
Quando você executa `fuxi` em um diretório, Fuxi Code ganha acesso a:
* **Seu projeto.** Arquivos em seu diretório e subdiretórios, além de arquivos em outro lugar com sua permissão.
* **Seu terminal.** Qualquer comando que você possa executar: ferramentas de compilação, git, gerenciadores de pacotes, utilitários do sistema, scripts. Se você pode fazer a partir da linha de comando, Fuxi também pode.
* **Seu estado git.** Branch atual, alterações não confirmadas e histórico de commits recentes.
* **Seu [FUXI.md](/pt/memory).** Um arquivo markdown onde você armazena instruções específicas do projeto, convenções e contexto que Fuxi deve conhecer a cada sessão.
* **[Auto memory](/pt/memory#auto-memory).** Aprendizados que Fuxi salva automaticamente conforme você trabalha, como padrões de projeto e suas preferências. As primeiras 200 linhas ou 25KB de MEMORY.md, o que vier primeiro, são carregadas no início de cada sessão.
* **Extensões que você configura.** [Servidores MCP](/pt/mcp) para serviços externos, [skills](/pt/skills) para fluxos de trabalho, [subagents](/pt/sub-agents) para trabalho delegado e [Fuxi no Chrome](/pt/chrome) para interação com navegador.
Como Fuxi vê seu projeto inteiro, pode trabalhar em todo ele. Quando você pede a Fuxi para "corrigir o bug de autenticação", ele pesquisa arquivos relevantes, lê múltiplos arquivos para entender o contexto, faz edições coordenadas entre eles, executa testes para verificar a correção e confirma as alterações se você pedir. Isso é diferente de assistentes de código inline que apenas veem o arquivo atual.
Ambientes e interfaces
O loop agentic, ferramentas e capacidades descritos acima são os mesmos em qualquer lugar que você use Fuxi Code. O que muda é onde o código é executado e como você interage com ele.
Ambientes de execução
Fuxi Code funciona em três ambientes, cada um com diferentes compensações para onde seu código é executado.
| Ambiente | Onde o código é executado | Caso de uso |
| ------------------ | ------------------------------------------------ | ---------------------------------------------------------------------- |
| **Local** | Sua máquina | Padrão. Acesso completo aos seus arquivos, ferramentas e ambiente |
| **Cloud** | VMs gerenciadas pela Anthropic | Delegar tarefas, trabalhar em repositórios que você não tem localmente |
| **Remote Control** | Sua máquina, controlada a partir de um navegador | Use a interface web mantendo tudo local |
Interfaces
Você pode acessar Fuxi Code através do terminal, do [aplicativo desktop](/pt/desktop), [extensões IDE](/pt/vs-code), [fuxi.ai/code](https://fuxi.ai/code), [Remote Control](/pt/remote-control), [Slack](/pt/slack) e [pipelines CI/CD](/pt/github-actions). A interface determina como você vê e interage com Fuxi, mas o loop agentic subjacente é idêntico. Consulte [Use Fuxi Code em qualquer lugar](/pt/overview#use-fuxi-code-everywhere) para a lista completa.
Trabalhe com sessões
Fuxi Code salva sua conversa localmente conforme você trabalha. Cada mensagem, uso de ferramenta e resultado é escrito em um arquivo JSONL em texto simples sob `~/.fuxi/projects/`, o que permite [retroceder](#undo-changes-with-checkpoints), [retomar e bifurcar](#resume-or-fork-sessions) sessões. Antes de Fuxi fazer alterações de código, ele também tira um snapshot dos arquivos afetados para que você possa reverter se necessário. Para caminhos, retenção e como limpar esses dados, consulte [dados de aplicação em `~/.fuxi`](/pt/fuxi-directory#application-data).
**As sessões são independentes.** Cada nova sessão começa com uma janela de contexto fresca, sem o histórico de conversa de sessões anteriores. Fuxi pode persistir aprendizados entre sessões usando [auto memory](/pt/memory#auto-memory), e você pode adicionar suas próprias instruções persistentes em [FUXI.md](/pt/memory).
Trabalhe entre branches
Cada conversa de Fuxi Code é uma sessão vinculada ao seu diretório atual. O seletor `/resume` mostra sessões do worktree atual por padrão, com atalhos de teclado para ampliar a lista para outros worktrees ou projetos. Consulte [Gerenciar sessões](/pt/sessions#use-the-session-picker) para a lista completa de atalhos do seletor e como funciona a resolução de nomes.
Fuxi vê os arquivos do seu branch atual. Quando você muda de branch, Fuxi vê os arquivos do novo branch, mas seu histórico de conversa permanece o mesmo. Fuxi se lembra do que você discutiu mesmo após mudar de branch.
Como as sessões estão vinculadas a diretórios, você pode executar sessões paralelas de Fuxi Code usando [git worktrees](/pt/worktrees), que criam diretórios separados para branches individuais.
Retome ou bifurque sessões
Retomar uma sessão com `fuxi --continue` ou `fuxi --resume` reabre-a sob o mesmo ID de sessão e anexa novas mensagens à conversa existente. Bifurcar com `--fork-session` ou `/branch` copia o histórico em um novo ID de sessão, deixando o original inalterado.
Para as flags de retomada, o seletor `/resume`, nomeação e o que acontece quando a mesma sessão está aberta em dois terminais, consulte [Gerenciar sessões](/pt/sessions).
A janela de contexto
A janela de contexto de Fuxi contém seu histórico de conversa, conteúdo de arquivos, saídas de comando, [FUXI.md](/pt/memory), [auto memory](/pt/memory#auto-memory), skills carregadas e instruções do sistema. Conforme você trabalha, o contexto se enche. Fuxi compacta automaticamente, mas instruções do início da conversa podem ser perdidas. Coloque regras persistentes em FUXI.md e execute `/context` para ver o que está usando espaço.
Para um passo a passo interativo do que é carregado e quando, consulte [Explore a janela de contexto](/pt/context-window).
Quando o contexto se enche
Fuxi Code gerencia o contexto automaticamente conforme você se aproxima do limite. Ele limpa saídas de ferramentas mais antigas primeiro, depois resume a conversa se necessário. Suas solicitações e trechos de código-chave são preservados; instruções detalhadas do início da conversa podem ser perdidas. Coloque regras persistentes em FUXI.md em vez de confiar no histórico de conversa.
Para controlar o que é preservado durante a compactação, adicione uma seção "Compact Instructions" a FUXI.md ou execute `/compact` com um foco (como `/compact focus on the API changes`).
Se um único arquivo ou saída de ferramenta for tão grande que o contexto se reencheça imediatamente após cada resumo, Fuxi Code para de compactar automaticamente após algumas tentativas e mostra um erro em vez de fazer loop. Consulte [Auto-compactação para com um erro de thrashing](/pt/troubleshooting#auto-compaction-stops-with-a-thrashing-error) para etapas de recuperação.
Execute `/context` para ver o que está usando espaço. Definições de ferramentas MCP são adiadas por padrão e carregadas sob demanda via [busca de ferramentas](/pt/mcp#scale-with-mcp-tool-search), então apenas nomes de ferramentas consomem contexto até Fuxi usar uma ferramenta específica. Execute `/mcp` para verificar custos por servidor.
Gerencie contexto com skills e subagents
Além da compactação, você pode usar outros recursos para controlar o que é carregado no contexto.
[Skills](/pt/skills) carregam sob demanda. Fuxi vê descrições de skills no início da sessão, mas o conteúdo completo só carrega quando uma skill é usada. Para skills que você invoca manualmente, defina `disable-model-invocation: true` para manter descrições fora do contexto até que você precise delas. Para skills que você não escreveu, use [`skillOverrides`](/pt/skills#override-skill-visibility-from-settings) para fazer o mesmo a partir das configurações.
[Subagents](/pt/sub-agents) obtêm seu próprio contexto fresco, completamente separado de sua conversa principal. Seu trabalho não incha seu contexto. Quando terminado, eles retornam um resumo. Esse isolamento é por que subagents ajudam em sessões longas.
Consulte [custos de contexto](/pt/features-overview#understand-context-costs) para o que cada recurso custa e [reduzir uso de tokens](/pt/costs#reduce-token-usage) para dicas sobre como gerenciar contexto.
Fique seguro com checkpoints e permissões
Fuxi tem dois mecanismos de segurança: checkpoints permitem que você desfaça alterações de arquivo e permissões controlam o que Fuxi pode fazer sem perguntar.
Desfaça alterações com checkpoints
**Cada edição de arquivo é reversível.** Antes de Fuxi editar qualquer arquivo, ele tira um snapshot do conteúdo atual. Se algo der errado, pressione `Esc` duas vezes para retroceder a um estado anterior, ou peça a Fuxi para desfazer.
Checkpoints são separados do git e permanecem disponíveis quando você retoma uma conversa. Eles cobrem apenas alterações de arquivo. Ações que afetam sistemas remotos (bancos de dados, APIs, implantações) não podem ser checkpointed, é por isso que Fuxi pergunta antes de executar comandos com efeitos colaterais externos.
Controle o que Fuxi pode fazer
Pressione `Shift+Tab` para percorrer os modos de permissão:
* **Manual**: Fuxi pergunta antes de edições de arquivo e comandos shell
* **Accept edits**: Fuxi edita arquivos e executa comandos comuns do sistema de arquivos como `mkdir` e `mv` sem perguntar, ainda pergunta por outros comandos
* **Plan**: Fuxi explora e propõe um plano sem editar seus arquivos de origem
* **Auto**: Fuxi avalia todas as ações com verificações de segurança em segundo plano
Você também pode permitir comandos específicos em `.fuxi/settings.json` para que Fuxi não pergunte cada vez. Isso é útil para comandos confiáveis como `npm test` ou `git status`. As configurações podem ser escopo de políticas em toda a organização até preferências pessoais. Consulte [Permissões](/pt/permissions) para detalhes.
***
Trabalhe efetivamente com Fuxi Code
Essas dicas ajudam você a obter melhores resultados de Fuxi Code.
Peça ajuda a Fuxi Code
Fuxi Code pode ensinar você como usá-lo. Faça perguntas como "como configuro hooks?" ou "qual é a melhor maneira de estruturar meu FUXI.md?" e Fuxi explicará.
Comandos integrados também o guiam através da configuração:
* `/init` o guia através da criação de um FUXI.md para seu projeto
* `/doctor` executa uma verificação de configuração que diagnostica problemas de instalação e configuração e pode corrigi-los
É uma conversa
Fuxi Code é conversacional. Você não precisa de prompts perfeitos. Comece com o que você quer, depois refine:
```text theme={null}
Corrigir o bug de login
```
\[Fuxi investiga, tenta algo]
```text theme={null}
Isso não é bem certo. O problema está no tratamento de sessão.
```
\[Fuxi ajusta a abordagem]
Quando a primeira tentativa não está certa, você não começa do zero. Você itera.
Interrompa e oriente
Você pode redirecionar Fuxi em qualquer ponto sem esperar que o turno termine ou começar do zero:
* **Pressione `Esc`** para parar Fuxi imediatamente. A chamada de ferramenta em execução é cancelada e Fuxi aguarda sua próxima instrução.
* **Digite uma correção e pressione `Enter`** para enviá-la sem parar a ferramenta em execução. Fuxi a lê assim que a ação atual é concluída e se ajusta antes de decidir seu próximo passo.
Seja específico desde o início
Quanto mais preciso seu prompt inicial, menos correções você precisará. Referencie arquivos específicos, mencione restrições e aponte para padrões de exemplo.
```text theme={null}
O fluxo de checkout está quebrado para usuários com cartões expirados.
Verifique src/payments/ para o problema, especialmente atualização de token.
Escreva um teste falhando primeiro, depois corrija.
```
Prompts vagos funcionam, mas você gastará mais tempo orientando. Prompts específicos como o acima geralmente têm sucesso na primeira tentativa.
Dê a Fuxi algo para verificar
Fuxi funciona melhor quando pode verificar seu próprio trabalho. Inclua casos de teste, cole screenshots da UI esperada ou defina a saída que você quer.
```text theme={null}
Implementar validateEmail. Casos de teste: 'user@example.com' → true,
'invalid' → false, 'user@.com' → false. Execute os testes depois.
```
Para trabalho visual, cole um screenshot do design e peça a Fuxi para comparar sua implementação com ele.
Explore antes de implementar
Para problemas complexos, separe pesquisa de codificação. Use plan mode (`Shift+Tab` duas vezes) para analisar a base de código primeiro:
```text theme={null}
Leia src/auth/ e entenda como lidamos com sessões.
Depois crie um plano para adicionar suporte OAuth.
```
Revise o plano, refine-o através de conversa, depois deixe Fuxi implementar. Essa abordagem de duas fases produz melhores resultados do que pular direto para código.
Delegue, não dite
Pense em delegar a um colega capaz. Dê contexto e direção, depois confie em Fuxi para descobrir os detalhes:
```text theme={null}
O fluxo de checkout está quebrado para usuários com cartões expirados.
O código relevante está em src/payments/. Você pode investigar e corrigir?
```
Você não precisa especificar quais arquivos ler ou quais comandos executar. Fuxi descobre isso.
O que vem a seguir
Adicione Skills, conexões MCP e comandos personalizados
Guias passo a passo para tarefas típicas