KinetAios

KinetAios

English | 简体中文

🌐 Website → https://phinn.github.io/KinetAios/

Sessão real: conversas paralelas entre projetos, selo de engine por sessão (Direct / Claude Code / Codex), abas de arquivos, Git e regras, contabilidade de custo de tokens por turno.

Um painel de agente de IA local-first para Windows 11 e macOS — ambas plataformas de primeira classe (o nome da pasta "Win" é histórico; o repositório é phinn/KinetAios). Diferenças de plataforma (cmd.exe vs /bin/sh, hotkey, bandeja) são roteadas em tempo de execução; os recursos estão alinhados em ambos os lados. Execute múltiplas sessões de agente simultaneamente com respostas em streaming, ferramentas de shell/arquivos/busca/MCP, histórico SQLite com memória de longo prazo, uma hotkey global e um modelo por sessão. Sem conta, sem servidor de retransmissão — sua própria chave de API LLM é a única credencial.

A versão de 30 segundos:

• 🔀 Quatro engines, uma janela — Direct (ReAct próprio) + Claude Code + Codex + DeepSeek Harness; alterne por sessão, transfira contexto via Pipeline
• 🧠 Memória de longo prazo em SQLite local — fatos extraídos automaticamente compartilhados entre todos os engines, sobrevive a reinicializações
• 🔒 Local-first, sem conta — sua chave de API é a única credencial; nada passa por um retransmissor
• 🛠 Mais de 30 ferramentas integradas + cliente/servidor MCP + plugins — shell, arquivos, web, capturas de tela, uso de computador prontos para uso
• ⌨️ Painel rápido com hotkey global — Spotlight para agentes de IA, invocável de qualquer lugar
• 📊 Benchmark em uma tarefa real de negócios com 400 mil linhas — engine próprio 9.2 vs Claude Code 7.0 (relatório completo)
• 🖥 Windows 11 e macOS — ambos de primeira classe

⭐ Se o KinetAios economiza seu tempo, uma Estrela é o agradecimento mais alto para um projeto open-source solo.

---

Por que KinetAios?

A maioria dos clientes de IA prende você a um provedor, perde contexto ao trocar de engine e roteia suas conversas por um retransmissor. O KinetAios executa quatro engines em uma janela, mantém memória de longo prazo entre todos eles e nunca pede uma conta.

	KinetAios	Claude Desktop	Cherry Studio	Cursor	Codex Desktop
Quatro engines (Direct V1/V2/V3 + Claude Code + Codex + DeepSeek Harness)	✅	—	—	—	—
SQLite local + memória de longo prazo automática	✅	—	—	—	—
Memória entre engines (um perfil de usuário compartilhado por todos os engines)	✅	—	—	—	—
Múltiplas sessões paralelas	✅	—	✅	—	✅
Hotkey global + painel rápido	✅	—	—	—	—
Varredura automática de MCP / Skills / Agents	✅	✅	—	—	—
Regras de projeto (AGENTS / CLAUDE / KINET)	✅	—	—	✅	✅
Servidor MCP integrado (controle remoto de agente)	✅	—	—	—	—
Sistema de plugins (ferramentas / painéis / comandos de barra)	✅	—	—	—	—
Multimodal (entrada de imagem + voz + capturas de tela)	✅	✅	—	—	—
Ramificação de sessão + orquestração de Pipeline entre engines	✅	—	—	—	—
Local-first, sem conta	✅	✅	✅	—	—

Instalação

Pegue o release mais recente:

• Windows — KinetAios-Setup-<version>.exe (instalador NSIS)
• macOS — veja releases

Builds não assinados → o SmartScreen do Windows / Gatekeeper do macOS avisarão; permita manualmente.

Primeira execução: clique em ⚙ no canto superior direito → cole sua API Key (+ URL base / modelo, padrão GLM/Zhipu) → clique em Testar Conexão, depois envie sua primeira tarefa.

🐋 Uma chave para todos os modelos? Escolha o preset OrcaRouter — um gateway compatível com OpenAI com mais de 200 modelos, roteamento adaptativo, markup zero. Cadastre-se com este link para apoiar o projeto (crédito de indicação de 5%).

Preset OrcaRouter integrado:

provider: orcarouter          # Settings → Presets → OrcaRouter (multi-model routing)
protocol: openai              # OpenAI-compatible
base_url: https://api.orcarouter.ai/v1
api_key: sk-orca-...          # create in the OrcaRouter console
model: orcarouter/auto        # adaptive routing, or pin a vendor/model e.g. anthropic/claude-opus-4.8

A partir do código-fonte

Requer Node.js 18+ e uma conexão de rede (o módulo nativo better-sqlite3 precisa ser compilado).

git clone https://github.com/phinn/KinetAios.git
cd KinetAios
npm install      # includes postinstall: rebuild better-sqlite3 for Electron
npm run build
npm start

---

Destaques

Quatro engines, alternáveis por sessão

• Direct V1 (Kaios) — loop ReAct integrado com provedor de protocolo duplo (compatível com OpenAI e Anthropic, ambas direções de streaming SSE), concorrência em nível de ferramenta, sub-agentes, compactação de contexto e novas tentativas.
• Direct V2 — ReAct de próxima geração em arquitetura Plan-Execute-Verify-Judge, chamadas de ferramentas em streaming, listas de tarefas passo a passo renderizadas ao vivo no chat como cartões de checklist, além de um loop de execução unificado compartilhado por plano e replanejamento (nova tentativa / verificação / checkpoint / compactação se comportam de forma idêntica em ambos os caminhos).
• Direct V3 — mais recente: um roteador de intenção escolhe fast / standard / deep por consulta; o caminho deep constrói chamadas de ferramentas em um DAG de dependências e o executa em paralelo — aceleração real em tarefas de múltiplas etapas.
• Claude Code — inicia claude -p --output-format stream-json, analisa NDJSON, retoma com --resume.
• Codex — inicia codex exec --json, analisa JSONL, retoma.
• DeepSeek Harness (3.0+) — inicia o CLI dsh via SSE compatível com OpenAI com provedores OpenAI / Pi-AI integrados, novas tentativas e cobrança de tokens. Alternável por sessão como qualquer outro engine.

Mais de 30 ferramentas integradas

shell (confirmação antes de executar; guarda de foco — se um comando roubar o primeiro plano, ele é devolvido automaticamente), read_file, write_file, edit_file (substituição exata), grep, glob, web_fetch (guarda SSRF + fallback Jina Reader), web_search (Bing → fallback DuckDuckGo), recall_memory, git_diff (somente leitura, sem confirmação), remember_fact / recall_fact (âncoras de sessão), memory_replace / memory_append (blocos de memória central), dispatch_agent (sub-agente somente leitura com contexto próprio), spawn_team / team_broadcast / team_send / team_close (equipes multi-agente), video_gen (MiniMax H3 texto-para-vídeo), todo_write (lista de tarefas compartilhada, renderizada ao vivo como cartões de checklist), e mais.

Uso de Computador (nativo, zero dependências externas)

• screenshot (com hide_self — a própria janela do agente fica transparente durante a captura, zero roubo de foco), screenshot_window (capture qualquer janela por título — até as ocluídas/em segundo plano, sem troca de área de trabalho).
• mouse_click / mouse_scroll / mouse_drag, keyboard_type / keyboard_key — coordenadas são convertidas do espaço de pixels da última captura para o espaço de ação da plataforma (ciente de DPI / origem da janela, com expiração por obsolescência).
• Suportado por Electron desktopCapturer + PowerShell (Windows) / cliclick (macOS) / xdotool (Linux). No macOS, open puro é reescrito mecanicamente para open -gj — o agente nunca rouba seu primeiro plano.

Integração MCP (cliente + servidor)

• Cliente: o engine Direct conecta-se automaticamente a servidores MCP configurados no seu sistema (varre ~/.claude.json, ~/.codex/config.toml, Claude Desktop). Transporte stdio, reconexão automática após quedas inesperadas. O botão 🔌 mostra servidores/ferramentas conectados.
• Servidor: um Servidor MCP integrado (HTTP+SSE) expõe uma ferramenta run_agent — máquinas remotas podem invocar seu agente local completo. Autenticação por token (comparação de tempo constante), timeout de 5 minutos, detecção de conexões zumbis.

Memória de longo prazo + grafo de memória

• A cada turno, "fatos duráveis sobre o usuário" são extraídos em segundo plano → SQLite → injetados no próximo turno. Compartilhados entre engines e sessões.
• Visualização de grafo de memória: grafo direcionado por força de proveniência de memória, detecção de conflitos, linha do tempo. Janela independente em tela cheia.
• Importação/exportação de memórias como JSON (backup ou migração).

Skills / Commands / Agents / Plugins

• Varre skills + commands + agents do Claude Code e skills do Codex. Invocáveis pelo menu / ou pelo botão ⚡.
• Painel de Skills (Configurações → Skills): agrega skills de todas as fontes de terceiros mais contribuições de plugins, com busca, visualização e edição direta da fonte (skills de plugins somente leitura). Edições têm efeito imediato.
• Plugin SDK v3: plugins contribuem com ferramentas, comandos de barra, hooks e painéis em tela cheia. Injetados sob demanda (correspondência de palavras-chave economiza ~60% de tokens). 21 plugins integrados: suíte de escritório, brainstorm (Excalidraw), prática de matemática, aprendizado de C++, baixa altitude (drones), uma suíte embarcada e IoT (arduino-dev / platformio-dev / serial-comm / modbus-dev / mqtt-dev / ble-dev / ota-dev / sensor-lookup / logic-analyzer / hw-diag), nestjs-dev, deepseek-harness, claude-code, codex, marketing-kit (pesquisa de marketing: concorrentes / SEO / funil / mineração de avaliações de apps + um painel de marketing), e mais.

Barra lateral (da esquerda para a direita)

• ＋ nova sessão.
• 📂 Workbench — cartões de projeto agrupados por cwd, cada um mostrando atividade recente + custo. Um botão "Contexto" edita KINET-CONTEXT.md.
• Status de sessão ao vivo — sessões em execução mostram a etapa atual do engine (ferramenta executando / nova tentativa / compactando) logo abaixo do título na barra lateral, sem precisar abrir o canal.
• 📊 Dashboard — janela independente com uso de tokens ao vivo, estatísticas de custo, distribuição de engines.
• 🌐 Arquivos — navegação de arquivos + pré-visualização <webview> (HTML/SVG/PNG/JPG/PDF) + editor. Multi-abas. A barra de endereço aceita file:// / http(s):// / localhost:<port>.
• 🏘️ Town — visualização isométrica estilo jogo de nós remotos (outras instâncias do KinetAios) na sua rede.
• 🧠 Memória — painel de memória: canal atual / todos, edição/exclusão inline, proveniência.
• 🔌 Plugins — gerenciamento de plugins: ativar/desativar, busca e filtro, cartões de categoria.
• ⚙️ Configurações — veja abaixo.

Abas da janela principal (Chat / Arquivos / Git / Regras)

• Chat — saída em streaming, etapas de ferramentas recolhíveis, contagens de tokens ao vivo, inspetor de contexto, capturas de tela, entrada de voz.
• Arquivos — igual a 🌐, seguindo o cwd da sessão atual.
• Git — git status (esquerda) + git log (direita). Clique em um arquivo alterado → diff lado a lado; clique em um commit → git show unificado.
• Regras — edite KinetAios.md no cwd (regras de nível de projeto, injetadas no prompt do sistema).

Pipeline (orquestração entre engines)

Encadeie múltiplas etapas, cada uma com seu próprio engine + prompt. A saída da etapa anterior é prefixada ao prompt da próxima etapa. Polling de timeout de 2 minutos por etapa, aborta em falha.

Ramificação de sessão e transferência

• Ramifique de qualquer turno — copia profundamente turnos/etapas em uma nova sessão.
• Exporte/importe sessões — serializa o estado completo da sessão (turnos + histórico + engine + modelo + cwd) para transferência entre máquinas. A exportação redige automaticamente segredos (chaves de API, senhas → [REDACTED]).
• Referências entre sessões — vincule sessões relacionadas, visualizadas como um DAG.

Gerenciamento de contexto (engine Direct)

• Inspetor de contexto — veja/edite o array directHistory de cada sessão (editor JSON).
• Compactação automática — quando o histórico excede o orçamento de tokens, turnos iniciais são resumidos pelo LLM. Eventos de compactação são visualizados (tokens antes vs depois).
• Calibração por protocolo — proporções token/caractere são rastreadas separadamente por protocolo de API (OpenAI vs Anthropic) para que sessões concorrentes não interfiram.

Multimodal (engine Direct)

• Entrada de imagem: 📎 escolha/cole imagens → partes de conteúdo de visão → formato OpenAI image_url ou base64 Anthropic.
• Transcrição de voz: 🎤 grave → Whisper → preenche a caixa de entrada.
• Chat de voz em tempo real: 🎤 → Volcengine Doubao WebSocket voz bidirecional — TTS natural, transcrição ao vivo, execução paralela de ferramentas do agente. Veja a wiki de chat de voz.
• Capturas de tela: 📸 sobreposição → arraste uma região → imagem recortada injetada no prompt.

Busca global

Ctrl/Cmd+K sobrepõe uma busca em todas as sessões — correspondendo texto de prompt, texto de resposta e saída de ferramentas.

Configurações (⚙️)

• Layout de duas colunas: navegação por abas verticais à esquerda (Modelos / Aparência / Mecanismos / Avançado / Segurança / Mensagens / Plugins / Habilidades / Meta / Multimáquina), rolagem independente à direita; janelas estreitas usam abas horizontais; uma caixa de pesquisa filtra todos os painéis.
• Provedores: protocolos OpenAI / Anthropic, URL base, modelo, chave. Predefinições GLM / DeepSeek / OrcaRouter / OpenAI / Anthropic. Botão de verificação de saldo Zhipu. Armazenamento criptografado via safeStorage.
• Segurança: portão de privacidade (detecta dados sensíveis saindo da máquina).
• Comportamento: modo de aprovação de shell, nível de sandbox, modo de planejamento, alternâncias do mecanismo CLI, comportamento ao fechar a janela (sair / minimizar / bandeja).
• Preços: preços de entrada/saída por modelo para cálculo de custo.
• Interface: idioma (English / 简体中文 / 繁體中文 / 日本語), tema (escuro / claro, pré-visualização ao vivo).
• Memória de longo prazo: exportar/importar JSON.

Diversos

• Modelo por sessão (menu suspenso editável, protocolo duplo compatível com OpenAI + Anthropic).
• Anexos de arquivos: 📎 selecionar/soltar vários arquivos de texto (arquivos grandes leem apenas o cabeçalho), referências @path a arquivos no diretório de trabalho.
• KinetAios.md / AGENTS.md / CLAUDE.md — arquivos de regras no diretório de trabalho são injetados automaticamente no prompt do sistema.
• Bandeja + atalho global Ctrl/Cmd+Alt+Space → painel rápido.
• Modo compacto: metadados por turno (duração / tokens / custo) ocultos por padrão, exibidos ao passar o mouse sobre a mensagem; caminhos reais de arquivos na saída da ferramenta são clicáveis para abrir.
• Verificação de atualizações contra GitHub Releases, exibida na página Sobre.
• Marca configurável (brand.json), armazenamento criptografado de chaves de API (safeStorage: macOS Keychain / Windows DPAPI).

---

Benchmarks: quatro mecanismos, uma tarefa empresarial real

A mesma análise cruzada de CRM de dispositivos médicos com 400 mil linhas (várias planilhas × nível hospitalar × janela de tempo, produzindo um relatório interativo em ECharts) — quatro mecanismos, prompt idêntico, zero intervenção humana:

Mecanismo	Pontuação /10	Tokens	Diferença principal
Direto (interno)	9.2	1.31M	SAX-streaming nativo de xlsx — o arquivo nunca entra no contexto
Claude Code	7.0	~2M	Ótimo gerenciamento de contexto, mas sem ferramentas de plugin — cada etapa desvia por Bash+python
Codex	5.5	~2.4M	Design focado em sandbox, inadequado para tarefas interativas de dados
PEVJ V2 (interno)	3.5	3.8M+	Arquitetura de quatro camadas sem proteções na verificação = amplificador de tokens

A descoberta mais valiosa: 7,5% das chamadas de API consumiram 63% do orçamento. A causa raiz não era o modelo — era o design da ferramenta. O agente leu o mesmo arquivo grande 16 vezes sequencialmente, reenviando o histórico completo a cada passagem. Trocar para um leitor de streaming zerou esse custo.

Relatório completo: metodologia + pontuações por dimensão + rastreamentos passo a passo — inclui todos os detalhes sórdidos do 3.5 do nosso próprio mecanismo.

---

Pilha tecnológica

• Electron + TypeScript — o processo principal executa o runtime do agente; o renderizador é uma interface web nativa.
• better-sqlite3 — SQLite + FTS5 (histórico / pesquisa de texto completo recall_memory + recall semântico por embeddings).
• Sem framework de frontend — o renderizador é TS vanilla + HTML/CSS, empacotado com esbuild.

Estrutura do projeto

KinetAios/               # repo root (the "Win" dir name is historical — it's the cross-platform repo now)
  brand.json               # branding config (product name etc., read at startup)
  package.json
  src/
    shared/types.ts         # types + applyEvent (shared by main/renderer, single source of truth)
    shared/i18n.ts          # four-language string table + t()
    main/
      main.ts               # windows / tray / hotkey / IPC / shell-confirm bridge
      TaskManager.ts        # session management + engine dispatch + memory extraction
      engines.ts            # Engine interface + Direct/ClaudeCode/Codex + cross-platform CLI spawn
      AgentLoop.ts          # ReAct loop (Direct) + history compaction + auto-shrink
      V3/                   # Direct V3: intent router + fast/deep paths (deep = DAG parallel)
      glm.ts                # providers + OpenAI/Anthropic SSE streaming + retries
      updater.ts            # GitHub Releases update check
      tools.ts              # 30+ built-in tools + computer-use glue + focus guard
      computer-use.ts       # screenshot / mouse / keyboard (native APIs)
      mcp.ts                # MCP client (scan + stdio + reconnect)
      mcp-server.ts         # MCP server (HTTP+SSE, run_agent, token auth)
      skills.ts             # skills/commands/agents/plugin scanning
      plugins.ts            # plugin loader (SDK v3: tools/slash commands/hooks/panels)
      store.ts              # better-sqlite3 + FTS5
      settings.ts           # config (encrypted API key, lang, embedding)
    preload/preload.ts      # narrow contextBridge API
    renderer/
      index.html quick.html styles.css
      app.ts                # dashboard logic (chat, sidebar, tabs, context inspector)
      quick.ts              # quick panel logic
      dashboard.ts          # cost/token dashboard window
      arena.ts              # deep-analysis dashboard
      memory-graph.ts       # memory graph SVG visualization
      town.ts               # Town view (remote-node visualization)
      files-pane.ts         # file browsing + webview preview + editor
      code-editor.ts        # code editor (syntax highlighting)
      file-drawer.ts        # file drawer UI
      nexus.ts              # Nexus view
      focus-manager.ts      # focus / focus-trap management
      highlight.ts          # chat code-block syntax highlighting
      markdown.ts           # mini markdown renderer
  plugins/                  # 20 built-in plugins (SDK v3)

Build / desenvolvimento

npm run build       # tsc (main/preload/shared) + esbuild (renderer) + copy brand.json
npm run typecheck   # typecheck both halves, no emit
npm start           # launch (requires a prior build)
npm run dev         # build + start

Empacotamento

npm run dist         # default target for the current platform

• Windows: release\KinetAios Setup <ver>.exe (NSIS). Deve ser compilado no Windows (compilação cruzada de Windows + módulos nativos a partir do macOS não é confiável).
• macOS: compile um dmg com npx electron-builder --mac (requer toolchain de Mac).
• O electron-builder recompila better-sqlite3 contra o ABI do Electron automaticamente; asar: false evita erros de carregamento de módulo nativo em asar.
• Builds não assinados → Windows SmartScreen / macOS Gatekeeper avisarão; permita manualmente. Remover o aviso requer um certificado de assinatura (+ notarização da Apple).
• O ícone padrão é o do Electron; substitua pelo seu: build/icon.ico (256×256) no Windows, build/icon.icns no macOS.

Limitações conhecidas

• O comportamento ao fechar a janela é configurável (sair / minimizar / bandeja), padrão minimizar. O atalho global só funciona enquanto o aplicativo está em execução.
• Sem compilação cruzada — compile instaladores do Windows em uma máquina Windows ou em um runner windows-latest do GitHub Actions, e dmgs em um Mac (a recompilação de módulos nativos precisa do toolchain de destino).
• Caminhos de código específicos da plataforma (shell / PATH / atalho / bandeja) devem ser verificados no sistema operacional de destino.

---

A família Kinet

KinetAios faz parte da família Kinet:

• KinetFit — companheiro inteligente de saúde
• KinetAgent — assistente de automação com IA
• KinetBrief — aplicativo de briefing / notas com IA
• KinetTask — gerenciador de tarefas local-first com IA no dispositivo (Mac App Store)

Licença

GPL-3.0