> ## 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.
# Glossário
> Definições da terminologia do Fuxi Code. Aprenda o que significam agentic loop, compaction, FUXI.md, hooks, subagents, MCP e outros conceitos principais.
Este glossário define a terminologia do Fuxi Code. Cada entrada vincula à página onde o conceito é abordado em profundidade. Para conceitos em nível de modelo como tokens, temperature e RAG, consulte o [glossário da plataforma](https://platform.fuxi.com/docs/pt/about-fuxi/glossary).
A
Agent teams
Múltiplas sessões independentes do Fuxi Code coordenadas por um líder de equipe, com uma lista de tarefas compartilhada e mensagens ponto a ponto. Diferentemente de [subagents](#subagent), que executam dentro de uma única sessão e relatam apenas ao pai, os membros da equipe têm cada um sua própria janela de contexto e você pode interagir com qualquer um deles diretamente. Agent teams são experimentais e devem ser habilitados definindo `FUXI_CODE_EXPERIMENTAL_AGENT_TEAMS=1`.
Saiba mais: [Run agent teams](/pt/agent-teams)
Agentic coding
Um fluxo de trabalho onde a IA pode ler arquivos, executar comandos e fazer alterações autonomamente enquanto você observa, redireciona ou se afasta, em contraste com assistentes baseados em chat que apenas respondem com texto que você deve aplicar você mesmo. Fuxi Code é agentic porque possui [tools](#tool) que permitem agir, não apenas aconselhar.
Saiba mais: [How Fuxi Code works](/pt/how-fuxi-code-works)
Agentic harness
As tools, gerenciamento de contexto e ambiente de execução que transformam um modelo de linguagem em um agente de codificação capaz. Fuxi Code é o harness; Fuxi é o modelo dentro dele. O harness fornece acesso a arquivos, execução de shell, gating de permissões, carregamento de memória e o loop que encadeia ações juntas.
Saiba mais: [How Fuxi Code works](/pt/how-fuxi-code-works)
Agentic loop
O ciclo que Fuxi percorre para cada tarefa: reunir contexto, tomar ação, verificar resultados e repetir até terminar. Cada uso de tool retorna informações que informam o próximo passo. Você pode interromper o loop em qualquer ponto para redirecionar. A maioria dos pontos de extensão, incluindo [hooks](#hook), [skills](#skill) e [MCP](#mcp-model-context-protocol), se conectam a fases específicas deste loop.
Saiba mais: [How Fuxi Code works](/pt/how-fuxi-code-works#the-agentic-loop)
Artifact
Uma página web ao vivo e interativa que Fuxi Code publica de sua sessão para uma URL privada em fuxi.ai, para que você possa ver a saída visualmente ou compartilhá-la dentro de sua organização em vez de ler texto de terminal. A página é atualizada no local quando a sessão republica. Os artefatos que você cria a partir do Fuxi Code aparecem na mesma galeria que os artefatos criados em conversas do fuxi.ai, mas seu compartilhamento se limita à sua organização e não podem ser tornados públicos.
Saiba mais: [Share session output as artifacts](/pt/artifacts)
Auto memory
Notas que Fuxi escreve para si mesmo com base em suas correções e preferências, armazenadas por repositório git em `~/.fuxi/projects/`. Todos os worktrees do mesmo repositório compartilham um diretório de auto memory. As primeiras 200 linhas ou 25 KB do índice `MEMORY.md` carregam no início de cada sessão. Auto memory é a contrapartida escrita por Fuxi para [FUXI.md](#fuxi-md), que você escreve.
Saiba mais: [Auto memory](/pt/memory#auto-memory)
Auto mode
Um [permission mode](#permission-mode) onde um modelo classificador separado revisa ações em segundo plano, para que a maioria seja executada sem prompts de aprovação; regras de solicitação explícita ainda solicitam. O classificador bloqueia escalação de escopo, infraestrutura não confiável e [prompt injection](#prompt-injection). Ele nunca vê resultados de tool, então instruções injetadas não podem influenciar suas decisões.
Saiba mais: [Eliminate prompts with auto mode](/pt/permission-modes#eliminate-prompts-with-auto-mode)
B
Bare mode
Uma flag de inicialização, `--bare`, que pula a descoberta automática de hooks, skills, plugins, servidores MCP, auto memory e FUXI.md. Apenas flags que você passa explicitamente têm efeito. Recomendado para CI e chamadas com script onde você precisa de comportamento idêntico entre máquinas independentemente da configuração local.
Saiba mais: [Start faster with bare mode](/pt/headless#start-faster-with-bare-mode)
Bundled skills
Playbooks baseados em prompt incluídos com Fuxi Code, como `/batch`, `/code-review`, `/debug` e `/loop`. Diferentemente de comandos built-in, que executam lógica fixa, bundled skills dão a Fuxi um prompt detalhado e deixam que ele orquestre o trabalho, então podem gerar agentes, ler arquivos e se adaptar à sua base de código.
Saiba mais: [Bundled skills](/pt/skills#bundled-skills)
C
Channel
Um [MCP server](#mcp-model-context-protocol) que envia eventos para sua sessão em execução para que Fuxi possa reagir a coisas que acontecem enquanto você está longe do terminal. Channels podem ser bidirecionais: Fuxi lê um evento de entrada e responde de volta através do mesmo channel. Telegram, Discord e iMessage estão incluídos na visualização de pesquisa.
Saiba mais: [Channels](/pt/channels)
Checkpoint
Um ponto de restauração criado a cada prompt que você envia. Fuxi Code captura snapshots de arquivos antes de cada edição para que um checkpoint possa revertê-los. Pressione `Esc` duas vezes ou execute `/rewind` para restaurar código, conversa ou ambos para um ponto anterior, ou para resumir parte da conversa a partir de uma mensagem selecionada. Checkpoints são salvos com a conversa, portanto uma sessão retomada ainda pode `/rewind` para eles. Eles são separados do git e não rastreiam alterações feitas através da ferramenta Bash.
Saiba mais: [Checkpointing](/pt/checkpointing)
`.fuxi` directory
O diretório onde Fuxi Code lê configuração com escopo de projeto: settings, hooks, skills, subagents, rules e auto memory. Um projeto tem `.fuxi/` em sua raiz; seus padrões em nível de usuário estão em `~/.fuxi/`.
Saiba mais: [The `.fuxi` directory](/pt/fuxi-directory)
FUXI.md
Um arquivo markdown de instruções persistentes que você escreve para Fuxi, carregado no início de cada sessão como uma mensagem de usuário após o prompt do sistema. Coloque convenções de projeto, notas de arquitetura e regras "sempre faça X" aqui. FUXI.md na raiz do projeto sobrevive a [compaction](#compaction) e é relido fresco do disco depois.
Você pode colocar FUXI.md no escopo do projeto em `./FUXI.md` ou `./.fuxi/FUXI.md`, no escopo do usuário em `~/.fuxi/FUXI.md`, ou como [managed policy](#managed-settings) para sua organização. Todos os arquivos descobertos são concatenados no contexto em vez de se sobreporem, ordenados do escopo mais amplo para o mais específico.
Saiba mais: [FUXI.md files](/pt/memory#fuxi-md-files)
Command
Uma instrução reutilizável que você invoca digitando `/name` no prompt. Comandos built-in como `/clear`, `/model` e `/compact` controlam a sessão. Você pode definir seus próprios comandos como arquivos em `.fuxi/commands/`, ou instalá-los de um [plugin](#plugin). [Skills](#skill) são a forma recomendada de empacotar comandos multi-etapa.
Saiba mais: [Commands](/pt/commands) · [Skills](/pt/skills)
Compaction
Sumarização automática de sua conversa quando a [context window](#context-window) se aproxima de seu limite. Saídas de tool mais antigas são limpas primeiro, depois a conversa é sumarizada. FUXI.md na raiz do projeto e auto memory sobrevivem a compaction e recarregam do disco; instruções dadas apenas em conversa podem ser perdidas. Execute `/compact` para disparar manualmente, opcionalmente com um foco como `/compact focus on the API changes`.
Saiba mais: [What survives compaction](/pt/context-window#what-survives-compaction) · [When context fills up](/pt/how-fuxi-code-works#when-context-fills-up)
Context window
A memória de trabalho para uma sessão, contendo histórico de conversa, conteúdos de arquivo, saídas de comando, FUXI.md, auto memory, skills carregadas e instruções do sistema. Conforme você trabalha, o contexto se enche até que [compaction](#compaction) o resuma. Execute `/context` para ver o que está usando espaço. Para o conceito de modelo subjacente, consulte o [glossário da plataforma](https://platform.fuxi.com/docs/pt/about-fuxi/glossary#context-window).
Saiba mais: [Explore the context window](/pt/context-window)
D
Dispatch
Um roteador de tarefas iniciado por telefone que gera uma sessão do Fuxi Code no aplicativo Desktop quando você envia uma tarefa de codificação do aplicativo móvel Fuxi. Seu prompt é roteado para a ferramenta certa automaticamente. Disponível em planos Pro e Max.
Saiba mais: [Sessions from Dispatch](/pt/desktop#sessions-from-dispatch)
E
Effort level
Uma configuração que controla quanto do orçamento de pensamento de raciocínio adaptativo Fuxi usa em cada turno. Esforço mais alto significa mais tokens de pensamento e raciocínio mais profundo; esforço mais baixo é mais rápido e barato. Effort é suportado em Fable 5, em Opus 4.6 e posterior, e em Sonnet 4.6 e posterior.
Saiba mais: [Adjust effort level](/pt/model-config#adjust-effort-level)
Extended thinking
Raciocínio passo a passo visível que o modelo realiza antes de responder. Você pode ajustá-lo com o [effort level](#effort-level), ou limitar tokens de pensamento com `MAX_THINKING_TOKENS` em modelos com um orçamento de pensamento fixo. Thinking aparece em texto itálico cinza no terminal.
Saiba mais: [Use extended thinking](/pt/model-config#extended-thinking)
H
Hook
Um manipulador definido pelo usuário que executa automaticamente em um ponto específico do ciclo de vida do Fuxi Code, como antes de uma tool ser executada, após uma edição de arquivo ou no início da sessão. Manipuladores podem ser um comando shell, endpoint HTTP, tool MCP, prompt LLM ou subagent. Hooks são determinísticos: eles disparam em pontos de ciclo de vida fixos em vez de à discrição do modelo.
Uma configuração de hook tem três níveis:
* **Hook event**: o ponto do ciclo de vida
* **Matcher**: filtra quais eventos o disparam
* **Hook handler**: o que executa
Saiba mais: [Get started with hooks](/pt/hooks-guide) · [Hooks reference](/pt/hooks)
M
Managed settings
Configurações impostas em toda a organização por TI ou DevOps, entregues pelos servidores da Anthropic através do console de administração ou implantadas em dispositivos em um caminho em nível de SO fora de `~/.fuxi`. Os usuários não podem substituir managed settings de escopos com menor precedência. A entrega gerenciada pelo servidor se aplica em [configurações elegíveis](/pt/server-managed-settings#platform-availability); consulte [Considerações de segurança](/pt/server-managed-settings#security-considerations). Use isso para políticas de segurança, requisitos de conformidade ou ferramentas padronizadas em uma frota.
Saiba mais: [Server-managed settings](/pt/server-managed-settings) · [Settings files](/pt/settings#settings-files)
MCP (Model Context Protocol)
Um padrão aberto para conectar tools de IA a fontes de dados externas e serviços. Servidores MCP dão a Fuxi novas tools para Slack, Jira, bancos de dados, navegadores e centenas de outras integrações. Você conecta servidores via `/mcp` ou adicionando-os a `.mcp.json`. Para o protocolo em si, consulte o [glossário da plataforma](https://platform.fuxi.com/docs/pt/about-fuxi/glossary#mcp-model-context-protocol).
Saiba mais: [Model Context Protocol](/pt/mcp)
Um mecanismo de economia de contexto que adia schemas de tool MCP até serem necessários. Apenas nomes de tool carregam na inicialização; Fuxi busca o schema completo sob demanda quando decide usar uma tool específica. Isso evita que servidores MCP ociosos consumam muito contexto.
Saiba mais: [Scale with MCP Tool Search](/pt/mcp#scale-with-mcp-tool-search)
N
Non-interactive mode
Um modo que executa um único prompt e sai sem uma sessão conversacional, invocado com `-p` ou `--print`. Usado para CI, scripts e piping. A execução ainda é salva como uma sessão retomável, a menos que você passe `--no-session-persistence`. O [Agent SDK](/pt/agent-sdk/overview) é o equivalente em Python e TypeScript. Anteriormente chamado de headless mode.
Saiba mais: [Run Fuxi Code programmatically](/pt/headless)
O
Output style
Uma configuração que modifica o prompt do sistema de Fuxi para alterar comportamento de resposta, tom ou formato. Output styles desligam as partes específicas de engenharia de software do prompt do sistema padrão, diferentemente de [FUXI.md](#fuxi-md) que é entregue como uma mensagem de usuário seguindo o prompt do sistema. Estilos built-in incluem Default, Proactive, Explanatory e Learning.
Saiba mais: [Output styles](/pt/output-styles)
P
Permission mode
O comportamento de aprovação de linha de base para a sessão. Cicle com `Shift+Tab` na CLI ou use o seletor de modo em VS Code, Desktop e fuxi.ai. Os modos disponíveis são `default`, `acceptEdits`, `plan`, `auto`, `dontAsk` e `bypassPermissions`.
O modo `default` é rotulado como Manual na CLI e nas extensões VS Code e JetBrains, e Fuxi Code aceita `manual` como um alias para o valor.
Saiba mais: [Escolha um permission mode](/pt/permission-modes)
Permission rule
Uma entrada de settings que permite, pergunta sobre ou nega uma invocação de tool com base no nome da tool e padrão de argumento. Regras são avaliadas deny→ask→allow, primeira correspondência vence. Permission rules são controles de granulação fina em camadas sobre o [permission mode](#permission-mode) mais amplo.
Saiba mais: [Configure permissions](/pt/permissions)
Plan mode
Um [permission mode](#permission-mode) onde Fuxi pesquisa e propõe alterações sem editar seus arquivos de origem. Pode ler, pesquisar e executar comandos de exploração, depois apresenta um plano para aprovação antes de tocar em qualquer coisa. Entre em plan mode com `/plan` ou pressionando `Shift+Tab`.
Saiba mais: [Analise antes de editar com plan mode](/pt/permission-modes#analyze-before-you-edit-with-plan-mode)
Plugin
Um pacote de skills, hooks, subagents e servidores MCP empacotados como uma unidade instalável única. Plugin skills são nomeados como `plugin-name:skill-name` para que múltiplos plugins coexistam. Distribua plugins entre equipes via um [marketplace](/pt/plugin-marketplaces).
Saiba mais: [Plugins](/pt/plugins)
Project trust
Um diálogo aceitando um diretório antes que Fuxi Code carregue sua configuração. A aceitação é salva por diretório de projeto, exceto seu diretório home, onde a confiança é mantida apenas para a sessão atual e o prompt reaparece a cada inicialização. Trust gates auto-instalação de plugins de marketplace e execução de hooks definidos pelo projeto. Confiar em um diretório significa que seus arquivos `.fuxi/settings.json`, `.mcp.json` e outros arquivos de config têm efeito.
Saiba mais: [The `.fuxi` directory](/pt/fuxi-directory)
Prompt injection
Instruções hostis incorporadas em um arquivo, página web ou resultado de tool que tentam redirecionar Fuxi para ações que você nunca pediu. As defesas do Fuxi Code incluem o sistema de permissões, detecção de injeção de comando e verificação de confiança. [Auto mode](#auto-mode) adiciona uma sonda do lado do servidor que escaneia resultados de tool para conteúdo suspeito e um classificador que nunca vê resultados de tool, então texto injetado não pode influenciar suas decisões de aprovação.
Saiba mais: [Proteja-se contra prompt injection](/pt/security#protect-against-prompt-injection)
R
Remote Control
Uma forma de continuar uma sessão local do Fuxi Code do seu telefone ou navegador via fuxi.ai. Seu código fica em sua máquina; apenas a UI é remota. Diferente de Fuxi Code na web, que executa em um sandbox na nuvem.
Saiba mais: [Remote Control](/pt/remote-control)
Rules
Arquivos de instrução modular em `.fuxi/rules/` que carregam junto com FUXI.md. Uma rule pode ser com escopo de caminho com frontmatter YAML `paths:` para que carregue apenas quando Fuxi lê um arquivo correspondente, mantendo o contexto enxuto até que seja relevante.
Saiba mais: [Organize rules with `.fuxi/rules/`](/pt/memory#organize-rules-with-fuxi/rules/)
S
Sandboxing
Isolamento de filesystem e rede em nível de SO para a tool Bash. Comandos executam dentro de um limite que você define antecipadamente, para que Fuxi possa trabalhar livremente dentro dele sem prompts de aprovação por comando. Sandboxing é uma camada separada de [permission rules](#permission-rule).
Saiba mais: [Sandboxing](/pt/sandboxing)
Session
Uma conversa vinculada ao seu diretório atual, com sua própria [context window](#context-window) independente. Sessões podem ser retomadas com `fuxi -c`, bifurcadas com `--fork-session` para preservar histórico sob um novo ID de sessão, ou executadas em paralelo entre terminais. Executar `/clear` inicia uma nova sessão; a anterior fica armazenada e está disponível via `/resume`. A transcrição de cada sessão é armazenada em `~/.fuxi/projects/`.
Saiba mais: [Work with sessions](/pt/how-fuxi-code-works#work-with-sessions)
Settings layers
A hierarquia que Fuxi Code lê configuração, em ordem de precedência de mais alta para mais baixa: [managed policy](#managed-settings), argumentos de linha de comando, settings locais em `.fuxi/settings.local.json`, settings de projeto em `.fuxi/settings.json`, depois settings de usuário em `~/.fuxi/settings.json`. Arrays se mesclam entre camadas; escalares em uma camada mais alta substituem as mais baixas.
Saiba mais: [Settings files](/pt/settings#settings-files)
Skill
Um arquivo `SKILL.md` contendo instruções, conhecimento ou um fluxo de trabalho que Fuxi adiciona ao seu toolkit. Fuxi carrega uma skill automaticamente quando relevante, ou você a invoca diretamente com `/skill-name`. Skills seguem o padrão aberto Agent Skills; Fuxi Code o estende com controle de invocação e execução de subagent.
Skills são o sucessor recomendado para comandos customizados. Um arquivo em `.fuxi/commands/deploy.md` e um em `.fuxi/skills/deploy/SKILL.md` ambos criam `/deploy` e funcionam da mesma forma; arquivos de comando existentes continuam funcionando.
Saiba mais: [Extend Fuxi with skills](/pt/skills)
Subagent
Um assistente de IA especializado que executa em sua própria context window com um prompt do sistema customizado, acesso a tool específico e permissões independentes. Funciona em uma tarefa delegada e retorna um resumo para a conversa principal. Use subagents para manter grandes explorações fora do seu contexto primário ou para executar pesquisa paralela. Diferente de [agent teams](#agent-teams), onde cada agente é uma sessão independente completa com a qual você pode falar diretamente.
Subagents built-in incluem Explore, Plan e propósito geral.
Saiba mais: [Create custom subagents](/pt/sub-agents)
Surface
Qualquer lugar onde você acessa Fuxi Code: a CLI, VS Code, JetBrains, Desktop ou fuxi.ai. Todas as surfaces compartilham o mesmo engine, então seu FUXI.md, settings e skills funcionam da mesma forma entre elas. Slack e a extensão Chrome são integrações que se conectam a uma surface em vez de surfaces em si.
Saiba mais: [Platforms and integrations](/pt/platforms)
T
Teleport
Um comando, `/teleport`, que puxa uma sessão Fuxi Code na nuvem para seu terminal local. Fuxi busca o branch, carrega o histórico de conversa e retoma do último estado da sessão web. A direção reversa é `--cloud`, que envia uma tarefa local para executar na web.
Saiba mais: [Da web para o terminal](/pt/fuxi-code-on-the-web#from-web-to-terminal)
Uma ação que Fuxi pode tomar: ler um arquivo, editar código, executar um comando shell, pesquisar a web, gerar um subagent. Tools são o que tornam Fuxi Code agentic. Sem elas, Fuxi pode apenas responder com texto. Cada uso de tool retorna um resultado que informa a próxima decisão de Fuxi no [agentic loop](#agentic-loop).
Saiba mais: [Tools available to Fuxi](/pt/tools-reference)
Turn
Uma resposta completa de Fuxi dentro de uma [session](#session). Um turn começa quando você envia uma mensagem e termina quando Fuxi termina de responder, com qualquer número de chamadas de [tool](#tool) no meio. [Stop hooks](#hook) são acionados no final de cada turn. Uma session consiste em muitos turns, e o [agentic loop](#agentic-loop) descreve o que acontece dentro de um.
Saiba mais: [How Fuxi Code works](/pt/how-fuxi-code-works#the-agentic-loop)
V
Verification loop
Como uma sessão sabe que o trabalho está realmente feito em vez de apenas plausível. Você dá a Fuxi uma verificação que ele pode executar, como um conjunto de testes, uma compilação ou uma comparação de screenshot, e Fuxi itera até que a verificação passe em vez de parar após uma tentativa. Um verification loop é o pré-requisito para [`/goal`](/pt/goal), execuções desassistidas e [dynamic workflows](/pt/workflows): sem um, a única coisa decidindo que o agente terminou é o próprio agente.
Saiba mais: [Give Fuxi a way to verify its work](/pt/best-practices#give-fuxi-a-way-to-verify-its-work)
W
Worktree isolation
Um modo de isolamento que executa Fuxi em um git worktree separado em `.fuxi/worktrees/`, habilitado com a flag `-w` ou `isolation: worktree` na config de subagent. Alterações ficam em um branch separado em um diretório separado, para que agentes paralelos não sobrescrevam os arquivos uns dos outros.
Saiba mais: [Run parallel sessions with git worktrees](/pt/worktrees)
***
Termos descontinuados e renomeados
Estes termos aparecem em docs mais antigas, posts de blog e conteúdo da comunidade. Use o nome atual ao pesquisar neste site.
| Old term | Now called | Notes |
| --------------- | --------------------------------------------- | ------------------------------------ |
| Headless mode | [Non-interactive mode](#non-interactive-mode) | Same `-p` flag, same behavior |
| Custom commands | [Skills](#skill) | `.fuxi/commands/` files still work |
| Slash commands | Commands | "Slash" dropped from product copy |