Key phrase: "blocked by the network, not by telling the model." A system prompt that says "don't browse" is a request. A firewall rule is a guarantee. This distinction drives everything below.

Analogy: a contractor working in an office building. They get a visitor badge with their name and who invited them (identity), access only to the floor they are fixing (isolation), and the security desk opens specific doors for them instead of handing over the master key (credential broker). The CERT-In cases are what happens when the master key is taped under the reception desk.

// The agent never sees secrets. It asks for an action; the broker decides.
const POLICY = {
  "support-agent": {
    owner: "ops-team@example.com",
    allow: {
      "orders.read":   { hosts: ["api.shop.internal"] },
      "email.draft":   { hosts: ["mail.internal"] },
      // no "orders.refund" — needs a human
    },
  },
};

async function brokerCall(agentId, action, request) {
  const rules = POLICY[agentId];
  const rule = rules?.allow[action];

  if (!rule) {
    audit({ agentId, action, result: "DENIED" });
    return { error: "not permitted", escalate: rules?.owner };
  }
  if (!rule.hosts.includes(new URL(request.url).host)) {
    audit({ agentId, action, result: "DENIED_HOST" });
    return { error: "host not allowed" };
  }

  // Short-lived, task-scoped token, fetched now and injected here, outside the sandbox.
  const token = await vault.issue({ scope: action, ttlSeconds: 60 });
  const res = await fetch(request.url, {
    ...request,
    headers: { ...request.headers, Authorization: `Bearer ${token}` },
  });

  audit({ agentId, action, url: request.url, status: res.status });
  return res.json();
}

// The agent's code runs in a throwaway sandbox with outbound network
// limited to the broker's address — enforced by the runtime, not the prompt.
await runInSandbox(agentCode, { egress: ["broker.internal:443"] });

Quick checklist for any agent you run: scan repos and configs for secrets (CERT-In's first ask); give the agent its own identity and owner; default-deny network egress; short-lived scoped tokens; log every tool call; and decide in advance what makes a run stop.

Takeaway: the agent ecosystem's newest layer is plumbing for trust. Give each agent a verifiable identity, run it somewhere disposable with network limits enforced by infrastructure, and keep secrets out of its reach. Then clean up the old leaks, because agents will find them first.

Frase-chave: "bloqueado pela rede, e não por instrução ao modelo." Um system prompt dizendo "não navegue" é um pedido. Uma regra de firewall é uma garantia. Essa diferença guia tudo o que vem abaixo.

Analogia: um prestador de serviço trabalhando num prédio comercial. Ele recebe um crachá de visitante com o nome dele e de quem o convidou (identidade), acesso só ao andar que vai consertar (isolamento), e a portaria abre portas específicas para ele em vez de entregar a chave mestra (intermediário de credenciais). Os casos do CERT-In são o que acontece quando a chave mestra fica colada com fita embaixo do balcão da recepção.

// O agente nunca vê segredos. Ele pede uma ação; o intermediário decide.
const POLICY = {
  "support-agent": {
    owner: "ops-team@example.com",
    allow: {
      "orders.read":   { hosts: ["api.shop.internal"] },
      "email.draft":   { hosts: ["mail.internal"] },
      // sem "orders.refund" — exige um humano
    },
  },
};

async function brokerCall(agentId, action, request) {
  const rules = POLICY[agentId];
  const rule = rules?.allow[action];

  if (!rule) {
    audit({ agentId, action, result: "DENIED" });
    return { error: "não permitido", escalate: rules?.owner };
  }
  if (!rule.hosts.includes(new URL(request.url).host)) {
    audit({ agentId, action, result: "DENIED_HOST" });
    return { error: "host não permitido" };
  }

  // Token de vida curta, restrito à tarefa, buscado agora e injetado aqui, fora do sandbox.
  const token = await vault.issue({ scope: action, ttlSeconds: 60 });
  const res = await fetch(request.url, {
    ...request,
    headers: { ...request.headers, Authorization: `Bearer ${token}` },
  });

  audit({ agentId, action, url: request.url, status: res.status });
  return res.json();
}

// O código do agente roda num sandbox descartável, com saída de rede
// limitada ao endereço do intermediário — imposto pelo runtime, não pelo prompt.
await runInSandbox(agentCode, { egress: ["broker.internal:443"] });

Checklist rápido para qualquer agente que você rode: varrer repositórios e configs atrás de segredos (o primeiro pedido do CERT-In); dar ao agente identidade e responsável próprios; bloquear saída de rede por padrão; tokens curtos e restritos; registrar toda chamada de ferramenta; e decidir de antemão o que faz uma execução parar.

Resumo: a camada mais nova do ecossistema de agentes é encanamento de confiança. Dê a cada agente uma identidade verificável, rode-o em algo descartável com limites de rede impostos pela infraestrutura e mantenha os segredos fora do alcance dele. Depois, limpe os vazamentos antigos, porque os agentes vão achá-los primeiro.