O que é Sharkly?

Você já consegue entregar uma tarefa real a um único agente de codificação com IA. Você descreve a mudança, ele edita os arquivos, roda os testes e devolve um diff. O fluxo parece impecável até o momento em que você quer um segundo agente trabalhando enquanto o primeiro pensa. Aí você tem dois terminais, dois branches para acompanhar e nenhum registro compartilhado de quem está fazendo o quê. Adicione um terceiro agente e um colega que quer ajudar, e tudo se transforma em prompts privados e sessões de terminal que ninguém mais consegue ver. Os agentes estão bem. O que falta é o sistema ao redor deles.

Esse sistema é o que o Sharkly oferece. Ele permite atribuir trabalho a agentes de codificação com IA da mesma forma que você atribui trabalho a colegas de equipe: uma tarefa com um responsável, contexto, um lugar para onde os resultados voltam e uma etapa de revisão antes que qualquer coisa seja mesclada. Os agentes continuam fazendo a codificação. O Sharkly adiciona a camada compartilhada de tarefas, computadores, contexto, controle e revisão em torno das ferramentas que sua equipe já usa.

TL;DR

O Sharkly é uma plataforma tudo-em-um de comando e gestão de Agents. Ela transforma agentes de codificação com IA como Claude Code, Codex e Gemini em membros de equipe atribuíveis e rastreáveis dentro de um sistema de tarefas real: atribua uma Task, rode vários Agents em paralelo nos seus próprios computadores e mantenha contexto, progresso, bloqueios, resultados e revisão humana visíveis da solicitação até a entrega. Ele não substitui essas ferramentas de codificação. É a camada de coordenação em volta delas.

O que é o Sharkly?

O Sharkly é uma plataforma para coordenar pessoas e vários agentes de codificação com IA em um único sistema de trabalho compartilhado. Você atribui uma Task, um Agent pesquisa e executa em um workspace isolado, e o resultado volta para essa Task para que uma pessoa revise e aceite. As ferramentas de codificação continuam rodando o código; o Sharkly gerencia a atribuição, o contexto, as execuções paralelas e a revisão em todas elas.

A forma mais clara de situar o Sharkly é pelo que ele não faz. Do próprio FAQ do produto:

O Sharkly não substitui o Claude Code, o Codex ou outras ferramentas de execução. Ele adiciona a camada compartilhada de tarefas, computadores, contexto, controle e revisão em torno das ferramentas que sua equipe já usa.

Portanto, a divisão de trabalho é explícita. Claude Code, Codex e ferramentas semelhantes fazem a execução. O Sharkly gerencia a atribuição em nível de equipe, os computadores conectados, o contexto das tarefas, o progresso, os bloqueios, os resultados e a revisão humana em todas elas. Se você já sabe o que é orquestração de agentes de IA, o Sharkly é uma forma concreta de chegar lá sem montar a estrutura você mesmo.

Essa fronteira importa porque o pressuposto errado mais comum sobre uma ferramenta dessa categoria é que ela compete com o seu agente. Não compete. Você mantém sua configuração do Claude Code, seu config do Codex, suas assinaturas e chaves de API. O Sharkly fica acima delas e torna suas execuções atribuíveis e rastreáveis.

Traga sua própria assinatura

Aqui não há revenda de tokens. O uso dos modelos continua pelas assinaturas ou chaves de API configuradas nas ferramentas de codificação que você conecta. Sua cota de modelo depende das ferramentas de codificação com IA, dos planos e das contas de API que sua equipe conecta, não do Sharkly. Esse enquadramento mantém a camada honesta: o Sharkly conquista seu lugar pela coordenação, não por se colocar entre você e o modelo.

O problema que o Sharkly resolve: os agentes escalam, a coordenação não

Um agente precisa de um bom prompt. Vários agentes precisam de um gestor. É nessa transição que as equipes se complicam, e ela acontece rápido assim que os agentes se mostram úteis.

Rode um único agente e um terminal basta. Você o observa, revisa o diff, faz o merge e segue em frente. Rode três e três modos de falha aparecem quase de imediato:

• Colisões. Dois agentes editando o mesmo repositório sobrescrevem um ao outro. Trabalho não commitado desaparece e o estado do git fica emaranhado.
• Cegueira. Com agentes em seis abas de terminal, você não consegue dizer qual tarefa terminou, qual travou e qual está silenciosamente seguindo o caminho errado.
• Contexto perdido. O objetivo, o diff, a discussão e a revisão de cada execução ficam em sessões privadas separadas. Um colega não consegue continuar de onde você parou, porque não há nada compartilhado para retomar.

Nenhum desses é um problema de qualidade dos agentes. Cada agente pode estar fazendo um trabalho cuidadoso. A falha é de coordenação, e é exatamente a falha que um sistema de tarefas resolve para equipes humanas. O Sharkly aplica a mesma ideia aos Agents: dê a cada execução um responsável, um registro compartilhado e um portão de revisão, para que a execução faça parte do plano da equipe em vez de desaparecer em terminais privados.

Para uma versão dessa dor específica de um runtime, nosso guia sobre rodar vários agentes do Claude Code em paralelo percorre o mesmo obstáculo pelo lado do terminal.

Os conceitos principais, definidos

O vocabulário do Sharkly é pequeno e cada palavra significa uma coisa só. Aprenda estes cinco termos e o resto do produto fica claro.

• Uma Task é a unidade principal de trabalho no Sharkly. Ela guarda o objetivo, o responsável, o contexto, a execução, os resultados e a revisão. Tudo volta para cá.
• Um Agent define como o trabalho deve ser conduzido: suas instruções, suas Skills, sua ferramenta de codificação. Você atribui Tasks a Agents como atribui tickets a pessoas.
• Um Computer fornece o host e os recursos locais onde a sessão de um Agent roda. Conecte suas próprias máquinas, locais pelo Sharkly Desktop ou remotas pela Sharkly CLI, para que o código execute onde você tem controle.
• Um Runtime realiza a sessão de agente propriamente dita. Claude Code, Codex, Gemini e outros runtimes de linha de comando se conectam aqui.
• Um Crew é um grupo reutilizável de People e Agents coordenado por um Agent líder.

A separação é o ponto. O Agent define como o trabalho deve ser conduzido; o Computer fornece o host e os recursos locais; o Runtime realiza a sessão propriamente dita; a Task continua sendo o registro compartilhado da equipe. Cada parte tem uma função, e é isso que mantém legível uma sala cheia de Agents em paralelo.

Quando usar um único Agent e quando usar um Crew

A maioria das pessoas erra essa decisão. Você não precisa de um Crew na maior parte do trabalho. Para trabalhos pequenos e bem definidos, atribua a Task diretamente a um Agent e mantenha o número de peças móveis em zero. Use um Crew quando o Agent líder precisa interpretar um objetivo amplo, envolver outros Agents e trazer os resultados deles de volta para uma única Task. Comece pela ferramenta simples; suba para o Crew quando um único Agent realmente não conseguir abarcar o objetivo inteiro. Sua primeira Task de verdade deve ir para um Agent só, que é exatamente o que nosso tutorial da primeira tarefa aborda.

O fluxo de trabalho: da solicitação à entrega em quatro etapas

O Sharkly enquadra o trabalho de produto em quatro etapas. Essa é a espinha dorsal de toda a plataforma, e ela se encaixa bem na forma como uma equipe já entrega.

Etapa 1: descrever e pesquisar

Uma pessoa descreve a necessidade em linguagem natural. Um Agent pesquisa o produto, o código, as tarefas anteriores e as regras da equipe, depois completa o escopo e os critérios de aceitação e cria Tasks executáveis. O humano declara a intenção; o Agent a transforma em trabalho que pode de fato ser assumido.

É aqui que a camada começa a compensar. Em vez de você traduzir uma solicitação vaga em um prompt preciso toda vez, o Agent faz o recorte e o registra como uma Task que os outros podem ver. Uma tarefa no Sharkly se parece com SH-312: um ticket de verdade, não uma mensagem de chat que some quando a tela rola.

Etapa 2: desenvolvimento paralelo automático

Os Agents assumem as Tasks prontas e trabalham em git worktrees isolados. Frontend, backend, correção de bugs e cobertura de testes avançam ao mesmo tempo, cada um no seu próprio workspace nas suas próprias máquinas. O worktree é o que torna o paralelismo seguro: um diretório de trabalho vinculado que compartilha o histórico de um repositório, mas mantém seu próprio branch e seus próprios arquivos. Cinco Agents, cinco worktrees, cinco branches, zero colisões.

Como as execuções acontecem em computadores que você conecta, uma mudança ruim fica contida no seu branch e na sua máquina. Nada toca seu branch principal por acidente. Se você quer os detalhes técnicos disso a fundo, veja nosso guia sobre git worktrees para agentes de codificação com IA.

Etapa 3: testes e aceitação humana

O Agent roda typecheck, testes e o build, e então anexa o resumo da mudança, os resultados da verificação e os limites conhecidos à Task. Uma pessoa aceita, solicita alterações ou decide a etapa de merge e release. Execução, bloqueios, resultados e discussão de acompanhamento voltam para a linha do tempo da Task, então a revisão acontece com contexto completo em vez de um diff cru.

É essa etapa que torna seguro, e não temerário, rodar muitos Agents. Velocidade sem ponto de verificação é como você entrega cinco bugs no tempo que antes levava para entregar um. Um portão de aprovação mantém a produtividade e coloca uma pessoa de volta no circuito no único momento que importa. Deixe as decisões finais de aceitação e release com as pessoas.

Etapa 4: projetos e sprints

A equipe acompanha conclusão, responsabilidade, dependências, mudanças de escopo e bloqueios no plano compartilhado. O trabalho dos Agents vive nos mesmos Projects e Sprints que o trabalho humano, então um gestor lê um único board em vez de juntar seis terminais e uma thread de chat. As mudanças e o progresso continuam voltando para as Tasks.

O contrato entre humanos e agentes

Reduza o Sharkly a uma única ideia e é esta. Agentes pesquisam, executam, testam e reportam. Pessoas definem a direção, concedem autoridade e aceitam o resultado. A automação para onde o julgamento da equipe é necessário e devolve uma entrega com contexto completo e evidências inspecionáveis.

Essa frase é todo o modelo de segurança. É também a resposta honesta ao medo de que plataformas de agentes entreguem seu código a uma máquina e deem um passo atrás. Elas não fazem isso, ou não deveriam. A versão que vale a pena mantém pessoas nas duas pontas que exigem julgamento — a direção no início e a aceitação no fim — e deixa os Agents com o meio mecânico. O Sharkly é construído em torno desse formato, e não da fantasia da autonomia total.

De onde vem a vantagem para a equipe

Uma afirmação silenciosa percorre todo o produto, e vale enunciá-la com clareza: a alavancagem de uma equipe não vem de abrir mais chats de IA. Vem de compartilhar papéis, regras, contexto e fluxos de trabalho.

A habilidade cuidadosa de um desenvolvedor com prompts, capturada como um perfil de Agent mais Skills reutilizáveis, se torna algo que a equipe inteira pode atribuir. Transforme uma boa configuração em uma capacidade de desenvolvimento que a equipe reutiliza. Essa é a diferença entre dez pessoas redescobrindo cada uma como fazer um agente se comportar e uma configuração compartilhada pela qual todo mundo encaminha o trabalho. Os agentes não apenas respondem perguntas. Eles refinam o trabalho a partir do estado atual, o fazem avançar e devolvem cada resultado para a equipe.

Você não precisa reconstruir seu processo

Adotar o Sharkly não é um projeto de migração. Mantenha as ferramentas que sua equipe já usa enquanto torna as execuções atribuíveis e rastreáveis. Conecte um computador, configure Agents e comece a encaminhar trabalho sem reconstruir o processo que sua equipe já entende.

Se você vive no Jira, mantenha os projetos, tarefas, status e fluxos de trabalho que sua equipe já lê. Conecte o Sharkly para que o sistema existente permaneça no lugar enquanto a execução dos Agents faz o trabalho avançar dentro dele. O objetivo é adicionar execução visível e revisável à sua configuração atual, não substituí-la por uma nova que todos tenham de reaprender.

Como o Sharkly se compara a uma estrutura feita em casa

Muitas equipes orquestram agentes com scripts próprios: uma pasta de wrappers de shell, alguns painéis do tmux, uma convenção de nomes para branches. Isso funciona, e para um desenvolvedor solo com volume baixo pode ser a escolha certa. O momento em que deixa de funcionar é previsível.

A leitura honesta: se você roda um ou dois agentes sozinho e nunca passa trabalho adiante, uma estrutura DIY dá menos manutenção. Se você roda vários, ou se qualquer outra pessoa precisa ver o trabalho, a coordenação que você teria de construir por conta própria é o produto que o Sharkly já é. Comparações com outras camadas de orquestração merecem um tratamento próprio; aprofundamos os trade-offs no nosso guia de orquestração.

Para quem é o Sharkly

O produto é voltado a equipes de produto e engenharia que já usam ferramentas de codificação com IA e querem encaminhar trabalho, coordenar várias execuções e revisar progresso e resultados em um fluxo de trabalho compartilhado. Alguns encaixes concretos:

• Um desenvolvedor backend rodando vários agentes ao mesmo tempo, que precisa de worktrees isolados para que execuções paralelas não colidam.
• Um engenheiro gestor que precisa ver o trabalho dos agentes no mesmo board que todo o resto, com uma etapa de revisão antes do merge.
• Um tech lead que quer padrões de equipe para o uso de agentes, capturados como Agents e Skills compartilhados em vez de conhecimento tribal.
• Um desenvolvedor solo escalando, que quer mais produtividade sem o caos de seis terminais sem etiqueta.

Se nada disso soa como você ainda, essa também é uma resposta válida. O Sharkly passa a valer a pena quando a coordenação é o gargalo. Abaixo disso, um único agente e um terminal bastam.

Primeiros passos

O menor fluxo útil no Sharkly é deliberadamente modesto: conecte um computador, crie um Agent e atribua uma Task de baixo risco. Deixe os Agents começarem com um requisito real, não com a reescrita do seu backlog inteiro. Acompanhe uma Task passar pelas quatro etapas, aceite o resultado você mesmo e você vai entender a camada melhor do que qualquer texto explicativo consegue transmitir.

A partir daí, adicione um segundo Agent para rodar algo em paralelo e depois traga um colega para o board. Cada passo acrescenta uma coordenação que você estava fazendo na mão.

Para começar: baixe o Sharkly, conecte um computador e encaminhe sua primeira Task. A documentação cobre cada conceito com mais profundidade em docs.sharkly.ai.

Perguntas frequentes

O que é o Sharkly em uma frase? O Sharkly é uma plataforma tudo-em-um de comando e gestão de Agents que transforma agentes de codificação com IA em membros de equipe atribuíveis e rastreáveis, para que você possa atribuir Tasks, rodar vários Agents em paralelo e manter contexto, progresso, resultados e revisão humana visíveis da solicitação até a entrega.

O Sharkly substitui o Claude Code ou o Codex? Não. O Sharkly não substitui o Claude Code, o Codex ou outras ferramentas de execução. Essas ferramentas fazem a execução; o Sharkly adiciona a camada compartilhada de tarefas, computadores, contexto, controle e revisão em torno delas.

Preciso pagar pelos modelos através do Sharkly? Não. O uso dos modelos continua pelas assinaturas ou chaves de API configuradas nas ferramentas de codificação que você conecta. Sua cota de modelo depende dos planos e das contas de API que sua equipe já tem.

Onde o código do agente realmente roda? Em computadores que você conecta, locais pelo Sharkly Desktop ou remotos pela Sharkly CLI. Cada execução recebe um git worktree isolado, então Agents em paralelo não colidem e as mudanças ficam contidas até você aceitá-las.

Quando devo usar um Crew em vez de um único Agent? Para trabalhos pequenos e bem definidos, atribua a Task a um Agent. Use um Crew quando um Agent líder precisa interpretar um objetivo amplo, envolver outros Agents e trazer os resultados deles de volta para uma única Task. Comece simples; veja o guia da primeira tarefa para o caminho de Agent único.

Isso é autonomia total? Os agentes fazem merge sozinhos? Não. Agentes pesquisam, executam, testam e reportam. Pessoas definem a direção, concedem autoridade e aceitam o resultado. As decisões finais de aceitação e release continuam com uma pessoa.

Posso continuar usando o Jira? Sim. Mantenha os projetos, tarefas, status e fluxos de trabalho que sua equipe já usa e conecte o Sharkly para que a execução dos Agents faça o trabalho avançar dentro do sistema que você já lê.