2>A IA agora escreve código genético — e funciona de verdade
Quando vi a notícia do BBC News sobre os 16 vírus projetados inteiramente por IA generativa, minha primeira reação não foi espanto — foi reconhecimento. Quem trabalha com modelos generativos em texto ou código já tinha visto esse filme. A questão era apenas quando o mesmo princípio seria aplicado a sequências biológicas em escala funcional. Aconteceu agora, e os desdobramentos técnicos são profundos.
Pesquisadores de Stanford e do Arc Institute usaram um modelo generativo para projetar genomas completos de bacteriófagos (vírus que infectam bactérias). Os vírus funcionam, se replicam em laboratório e são inéditos. É a primeira vez que isso acontece. Na minha leitura, isso muda a forma como pensamos sobre IA generativa — não é mais só uma ferramenta de produtividade para devs, é uma ferramenta de design em qualquer domínio sequencial.
O que realmente aconteceu (e o que o headline esconde)
O modelo usado se chama Evo, uma família de modelos baseada em arquitetura tipo decoder-only (similar ao que usamos em LLMs como Llama ou Qwen), treinada em milhões de genomas de bacteriófagos. O grupo do professor Brian Hie, da Stanford, gerou sequências genômicas inteiras — milhões de pares de bases — e testou experimentalmente.
Dos 16 vírus desenhados, funcionaram. Isso é taxa de sucesso absurda considerando que projetar um genoma viável “do zero” é problema combinatório gigantesco. A natureza leva bilhões de anos de seleção natural para chegar a soluções funcionais. O modelo conseguiu em horas.
O ponto técnico importante: os vírus não infectam humanos. Infectam bactérias. Isso é crucial porque coloca a pesquisa em categoria de menor risco, mas não elimina o debate sobre biossegurança.
Como a IA “escreve” DNA — a analogia que todo dev entende
Se você já treinou ou usou um LLM, você já entende 80% do que aconteceu aqui. A diferença é o alfabeto:
- Texto → LLMs: tokens = pedaços de palavras, vocabulário ~50k.
- DNA → Evo: tokens = nucleotídeos (A, T, C, G), vocabulário = 4.
- Código → modelos de código: tokens = pedaços de sintaxe, vocabulário ~50k.
O princípio é o mesmo: prever o próximo token dado o contexto. Quando isso funciona em escala, o modelo aprende a “gramática” e a “semântica” do domínio. Em texto, isso vira uma resposta coerente. Em DNA, isso vira um genoma que a maquinaria celular consegue ler, transcrever e replicar.
Um ponto que pouca gente comenta: o Evo provavelmente usou uma janela de contexto enorme (centenas de milhares de tokens) para capturar relações de longo alcance no genoma. Em código, lidamos com a mesma limitação — é por isso que context windows grandes importam tanto. A biologia validou empiricamente o que a engenharia de software já intuía.
Na Prática: como funcionaria um gerador de sequências simplificado
Para mostrar que a barreira técnica não é tão grande quanto parece, aqui vai um exemplo didático em Python. Não é o Evo (que tem bilhões de parâmetros), mas captura a essência do processo: treinar um modelo em sequências reais e gerar novas.
import numpy as np
import torch
import torch.nn as nn
# Toy dataset: fragmentos de DNA bacteriano (apenas didático)
# Em produção, isso seria carregado de bancos como NCBI GenBank
sequencias = [
"ATGCGATCGTAGCTAGCTAGCATCGATCG",
"GCTAGCTAGCATCGATCGATGCATGCATG",
"TTGCATGCATCGATCGATCGATGCATGCA",
]
# Vocabulário: 4 nucleotídeos
vocab = {"A": 0, "T": 1, "G": 2, "C": 3}
inv_vocab = {v: k for k, v in vocab.items()}
# Encoder one-hot
def encode(seq, max_len=32):
arr = np.zeros((max_len, len(vocab)), dtype=np.float32)
for i, nt in enumerate(seq[:max_len]):
arr[i, vocab[nt]] = 1.0
return arr
# Modelo gerador simplificado (MLP básico)
class DNAGenerator(nn.Module):
def __init__(self, seq_len=32, hidden=128):
super().__init__()
self.seq_len = seq_len
self.net = nn.Sequential(
nn.Linear(seq_len * len(vocab), hidden),
nn.ReLU(),
nn.Linear(hidden, seq_len * len(vocab)),
)
def forward(self, x):
out = self.net(x)
return out.view(-1, self.seq_len, len(vocab))
# Treino fictício: 100 epochs
model = DNAGenerator()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()
X = torch.tensor(np.array([encode(s) for s in sequencias]))
y = torch.tensor([[vocab[nt] for nt in s[:32]] for s in sequencias])
for epoch in range(100):
logits = model(X)
loss = loss_fn(logits.view(-1, 4), y.view(-1))
opt.zero_grad(); loss.backward(); opt.step()
# Geração: amostragem a partir da distribuição aprendida
def gerar_sequencia(model, temperatura=1.0):
seed = torch.randn(1, 32, 4)
logits = model(seed)
probs = torch.softmax(logits / temperatura, dim=-1)
idx = torch.multinomial(probs.view(-1, 4), 1).view(32)
return "".join(inv_vocab[i.item()] for i in idx)
print(gerar_sequencia(model))
# Saída esperada: string de 32 nucleotídeos como "GCTAGCATCGATGCATCG..."
Obviamente isso é um brinquedo — não gera nada biologicamente funcional. O Evo tem bilhões de parâmetros, foi treinado em terabytes de dados genômicos e usa arquitetura Transformer com rotary embeddings e outras otimizações. Mas o esqueleto conceitual é o mesmo que usamos para gerar texto ou código. É o poder de escala + dados + arquitetura certa.
O paralelo com o trabalho do dia a dia do dev
Aplicando o que esse experimento mostra para o nosso mundo:
- Modelos de código vão continuar melhorando. Se a IA consegue gerar sequências biológicas funcionais, vai continuar melhorando em gerar código que compila, testa e roda. A fronteira não é arquitetural — é de dados e escala.
- Fine-tuning em domínios específicos vence generalismo. O Evo não foi um LLM genérico reaproveitado. Foi treinado do zero em dados de bacteriologia. Mesma lição que aprendemos com Code Llama, StarCoder e DeepSeek-Coder.
- Janela de contexto é feature, não detalhe. Relação de longo alcance no DNA é o que permite o genoma se dobrar corretamente. Relação de longo alcance no código é o que permite um agente entender um sistema inteiro.
Erros comuns e o que evitar nesse debate
Quando o tema vira hype, surgem confusões. Anota o que eu evitaria se fosse debater isso em time técnico:
- “IA criou vida”. Não. IA gerou sequências que foram montadas em laboratório com técnicas de biologia molecular existentes. A síntese química do DNA continua sendo feita por humanos e equipamentos.
- “Agora qualquer um faz isso”. O Evo roda em clusters de GPU pesados. Sintetizar o DNA custa milhares de dólares por construção. Não é trivial replicar.
- “Os modelos de código vão virar armas biológicas”. Esse é o argumento do dual-use risk, levado a sério por agências como NIH e FBI. Mas a barreira entre “escrever um genoma em texto” e “sintetizar um patógeno funcional” ainda é enorme. Negar o risco é irresponsável, mas inflar a probabilidade também é.
- “Devs não precisam se preocupar com biossegurança”. Se você trabalha com bioinformática, ferramentas de IA aplicadas a proteínas (AlphaFold, ESMFold), drug discovery ou mesmo análise de variantes, esse debate impacta diretamente sua governança técnica. Preste atenção.
- Confundir modelo generativo com automação total. O Brian Hie disse à BBC que isso foi “território novo”. O processo ainda exige validação experimental. Não é “aperte um botão e sai um vírus”. Ainda exige meses de bancada.
Por que isso importa além da biologia
Três pontos de longo prazo que eu acho que vão pautar os próximos anos:
- Bioeconomia + IA: terapêuticas projetadas in silico, enzimas industriais customizadas, vacinas sintéticas. O custo de P&D em biotech começa a cair de forma similar ao que vimos em software.
- Regulação: o framework de avaliação de risco biológico de IA vai virar referência para regular modelos generativos em outros domínios perigosos (química, materiais, armas autônomas). Quem está construindo produtos de IA generativa deveria estudar isso.
- Novas arquiteturas: state-space models (Mamba), Hyena, e outras alternativas ao Transformer puro podem dominar o espaço de sequências longas em biologia. Vale ficar de olho — o que vence em genômica provavelmente vence em código também.
Perguntas que devs reais vão fazer (FAQ)
O modelo Evo é open source?
Sim. Os pesos foram publicados no Hugging Face pela equipe do Arc Institute/Stanford, sob termos de uso responsável. Dá para baixar e inspecionar, mas não dá para usar comercialmente sem licença.
Quanto de dado foi usado para treinar?
O Evo foi treinado em mais de 2 milhões de genomas de bacteriófagos e elementos genéticos móveis, totalizando centenas de bilhões de tokens nucleotídicos. É da mesma ordem de grandeza do que se usa para treinar LLMs grandes.
Dá para usar IA generativa para projetar proteínas terapêuticas?
Já está sendo feito. AlphaFold, RoseTTAFold, ESMFold e modelos como ProteinMPNN e Chroma estão em uso ativo em biotechs. A diferença para o caso dos vírus é que proteínas são “mais fáceis” funcionalmente do que genomas inteiros replicáveis.
Isso tem relação com os modelos de linguagem que eu uso no dia a dia?
Direta. Os princípios arquiteturais — atenção, embedding, sampling, fine-tuning — são os mesmos. A diferença é o alfabeto e os dados. Quem entende Transformers entende o conceito por trás do Evo.
Qual o risco real de uso malicioso?
Hoje, baixo a médio. Os vírus criados infectam bactérias, não humanos. Mas a técnica escala. Governos e comitês de biossegurança (NSABB nos EUA, equivalente em outros países) já estão revisando protocolos. O ponto não é banir a pesquisa — é criar guardrails técnicos e institucionais antes que a tecnologia amadureça.
Segundo o BBC News, o próprio Brian Hie classificou o feito como “um ponto de virada muito significativo”. Eu concordo. Toda vez que uma IA generativa cruza a fronteira entre “imitar” e “criar algo funcional em um novo substrato”, a indústria de software precisa parar e recalibrar o que considera possível. Já vi isso com geração de imagens, com geração de código, e agora com geração de genomas. A próxima fronteira provavelmente será materiais, química ou robótica — todas sequenciais, todas passiveis do mesmo tratamento.
Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.