How to Use Jev AI to Find Negative Keywords in Google Ads

What Is Jev AI From TypeSafe

TypeSafe calls Jev a System One model, built for fast, structured decisions that software can use directly. It doesn't write text, write code or hold a conversation. TypeSafe says plainly that it isn't a replacement for the model behind Claude Code, Cursor or Muse Spark.

You send Jev a piece of state, such as a search term and its numbers, plus questions you name. There are three question types:

• Noul, a yes-or-no answer with a probability from 0 to 1.
• Choice, one option from a list you define, with probabilities and a confidence score.
• Score, a position on a rubric you write, with a confidence score.

TypeSafe says most queries finish in about 100 milliseconds and quotes 70 to 500 milliseconds end to end. Input costs $0.042 per million tokens and output is free. OpenAI announced a similar Decisions API on 29 September, in limited preview.

Why the Search Terms Report Suits Jev

A Google Ads search terms report can run to hundreds of rows, and PaidSync returns up to 500 per call, highest cost first. Every row asks the same question: would someone typing this buy from us? That's a yes-or-no call, which is what Jev is built for.

A chat assistant reads those rows one at a time and gets slower and pricier as the list grows. Jev scores each one in a fraction of a second, and at an estimated 400 input tokens a term (our estimate for the prompt in the script below), 500 terms come to roughly 200,000 tokens, under one cent. The probability it returns tells you which calls to trust and which to check by hand.

One agency, Dijitalpi, reports that Jev classified thousands of search terms across 15 brands in eight seconds for about US$0.20, with a specialist reviewing before any change. It didn't publish the counts, and we haven't checked them.

How the Recipe Works in 4 Steps

The Google Ads Search Term Script

Plain JavaScript with the official MCP SDK. Set PAIDSYNC_API_KEY (from the PaidSync dashboard) and TYPESAFE_API_KEY (from TypeSafe) as environment variables, and change BUSINESS to one sentence about what you sell.

// triage.mjs. Run: node triage.mjs (Node 20+, after npm install @modelcontextprotocol/sdk)
// Keys come from environment variables and travel in headers, never in the URL.
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const BUSINESS = "We sell project management software to construction companies.";

// 1. PaidSync pulls the search terms (up to 500 rows per call, highest cost first)
const transport = new StreamableHTTPClientTransport(new URL("https://mcp.paidsync.ai/mcp"), {
  requestInit: { headers: { "x-api-key": process.env.PAIDSYNC_API_KEY } },
});
const paidsync = new Client({ name: "jev-search-terms", version: "1.0.0" });
await paidsync.connect(transport);
const res = await paidsync.callTool({
  name: "get_search_terms_report",
  // several accounts? first call set_active_account with { account_id: "123-456-7890" }
  arguments: { date_range: "last_30_days" },
});
const report = res.structuredContent;
if (!report?.success) throw new Error(report?.message ?? "No report returned");
const terms = report.data.searchTerms.filter(
  (t) => Number(t.cost) > 0 && Number(t.conversions) === 0,
);

// 2. Jev answers two typed questions about each term
async function ask(t) {
  const r = await fetch("https://api.typesafe.ai/v1/systemone", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.TYPESAFE_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "jev-latest",
      state: { business: BUSINESS, search_term: t.searchTerm, clicks: t.clicks, cost: t.cost },
      questions: {
        unrelated: {
          type: "noul",
          instructions: "Is this search term unrelated to what the business sells?",
          criteria: {
            true: "A person searching this would not buy from this business",
            false: "A person searching this could become a customer",
          },
        },
        intent: {
          type: "choice",
          instructions: "What is the searcher most likely looking for?",
          criteria: {
            buy: "To buy or compare products like this",
            learn: "Information about the topic",
            job: "A job or salary information",
            free: "Something free or DIY",
            other: "Something unrelated",
          },
        },
      },
    }),
  });
  if (!r.ok) throw new Error(`Jev returned ${r.status}`);
  const { answers } = await r.json();
  return {
    term: t.searchTerm,
    cost: Number(t.cost),
    unrelated: answers.unrelated.noul,
    intent: answers.intent.choice,
  };
}

const scored = [];
for (let i = 0; i < terms.length; i += 10) {
  scored.push(...(await Promise.all(terms.slice(i, i + 10).map(ask))));
  await new Promise((done) => setTimeout(done, 250)); // stays under Jev's default rate limit
}

// 3. Route by confidence. Tune both thresholds on your own account.
console.log("Proposed negatives:");
console.table(scored.filter((s) => s.unrelated >= 0.85));
console.log("Needs a person:");
console.table(scored.filter((s) => s.unrelated >= 0.4 && s.unrelated < 0.85));
await paidsync.close();

The pause between batches keeps you under Jev's default rate limit, which TypeSafe lists as 40 a second, so 500 terms take well under a minute. Start with a strict threshold, read what lands in each list for a week or two, then loosen it.

Keep a Person on the Write Step

The script never changes your account, and that's by design. A PaidSync API key can read and preview Google Ads but can't apply Google Ads changes, so adding negatives always goes through a signed-in session where you see the change first. On the other platforms a key can apply changes, under the same checks as a sign-in. Google Ads creates and most other creates run as a dry-run preview first, destructive changes such as pauses and deletes need an explicit confirm, and every applied change is logged with a 7-day before-and-after result.

Other Jobs for Jev With Your Ad Data

• Tag every ad in an account by hook or offer, then compare performance by tag.
• Flag ad copy that might break platform policy before you create the ads.
• Sort alerts by how serious they are, so only the urgent ones reach you.

Each one follows the same shape. PaidSync reads, Jev scores, a person or a chat assistant decides, and PaidSync writes. For the approval step, see how to connect your ads to Claude, and for more ways to cut waste, see negative keyword automation with AI.

Frequently Asked Questions

Related Guides