12 days to 30 November 2026: move OpenAI prompts, Evals and Agent Builder to code

Three OpenAI surfaces stop on 30 Nov 2026. Move prompts into code, rebuild evals in Promptfoo and export Agent Builder workflows to the Agents SDK.

Read time
18 min
Word count
2.6K
Sections
9
FAQs
8
Share
Two engineers review a migration diagram beside text reading OpenAI Migration Deadline: move prompts, evals and agents
On this page · 9 sections
  1. What stops on 30 November 2026
  2. The order to work in
  3. Step 1: rebuild your evals in Promptfoo
  4. Step 2: move prompts from /v1/prompts into code
  5. Step 3: move Agent Builder workflows to the Agents SDK
  6. A 12-day checklist
  7. India-specific considerations
  8. How eCorpIT can help
  9. References

Summary. On 30 November 2026, 12 days from today, OpenAI shuts down three developer-platform surfaces at once: the /v1/prompts endpoint with its reusable prompt objects, the Evals dashboard, API and graders for eval workflows, and Agent Builder. All three were announced on 3 June 2026, and the deprecations page still shows the same date on 18 November 2026. OpenAI names the replacements in that table: prompt content moves into application code, evals move to Promptfoo, and Agent Builder workflows move to the Agents SDK or ChatGPT Workspace Agents, while ChatKit stays. Existing evals have been read-only since 31 October 2026, so what is left is copying them out. Promptfoo, which OpenAI now describes as part of OpenAI, is free in its open-source Community tier, so the cost is engineering time, not licences. One cost trap is real: inline prompts carelessly and you lose prompt caching, which on gpt-6.2-astra is the gap between $0.40 and $8.00 (or $10.00 at the cache-write rate) per million input tokens. Our verdict: treat this as three small code changes, each with its own test, and finish by 27 November to leave a weekend of slack.

About this article. This is a hands-on runbook for engineers and tech leads who call the OpenAI API from their own applications in the US, UK, EU and India. We checked every date, endpoint, command, package name and price on 18 November 2026 against OpenAI's deprecations page, changelog, migration guides, Agents SDK, prompt caching and pricing documentation, and against Promptfoo's documentation, pricing page and licence. Our analysis of what OpenAI announced and what its pages leave out covers the background; this piece is the code. Vendors change dates and prices, so recheck before you ship; no vendor paid for inclusion. Researched with AI assistance and checked against the primary sources listed in the references.

What stops on 30 November 2026

OpenAI's feature and endpoint deprecations table lists three rows with a shutdown date of 30 November 2026 and a notice date of 3 June 2026. The table below reproduces them as read on 18 November 2026, with the related fine-tuning row.

Surface Status on 18 Nov 2026 OpenAI's recommended replacement
/v1/prompts and reusable prompt objects Deprecated Prompt content moved into application code
Evals dashboard, API and graders for eval workflows Read-only Promptfoo
Agent Builder Deprecated Agents SDK or ChatGPT Workspace Agents; ChatKit remains
Self-serve fine-tuning job creation Restricted access from 6 Jan 2027 Fine-tuning timeline

The fourth row is not part of the 30 November shutdown, but it matters if you use graders in both evals and fine-tuning: the graders guide says OpenAI is deprecating graders in both workflows, and the fine-tuning side runs to its own date. Our fine-tuning alternatives guide covers that second deadline.

The June announcement was a single changelog entry pointing to the deprecations page, and no later changelog entry up to 17 November changes these dates. The Evals guide adds the date that has already passed: evals became read-only for existing users on 31 October 2026.

The order to work in

The three migrations are independent, but the order matters because evals are the safety net for the other two.

  1. Copy every eval out first. It is read-only now and gone on 30 November, and you need it to test the prompt and agent changes.
  1. Move prompts into code behind a test that the new eval suite runs.
  1. Export and redeploy Agent Builder workflows, including any ChatKit front end that points at a hosted workflow.

A practical plan for the 12 days: inventory on 18 and 19 November, evals rebuilt by 21 November, prompts moved by 24 November, agents moved by 27 November, and three days left for anything that breaks.

Step 1: rebuild your evals in Promptfoo

What Promptfoo is, and what it costs

Promptfoo is an open-source CLI and library for evaluating and red-teaming AI applications and agents. OpenAI's own getting-started page says Promptfoo is part of OpenAI. TechCrunch reported the acquisition on 9 March 2026, noting that OpenAI did not disclose the price and planned to keep building the open-source project.

The Community tier is free, includes all evaluation features and all model providers, allows 10,000 red-team probes a month, and runs locally or self-hosted. Enterprise and on-premise tiers are quote-only. The code is published under the MIT licence terms. The evals you run still call models, so they still incur API charges.

Install it

Promptfoo needs Node.js 22.22.0 or newer. The pip wrapper also needs Python 3.10 or newer, and it still needs Node.


            # Node route
npx promptfoo@latest init --example getting-started

# Python route (Node.js 22.22.0+ must also be installed)
pip install promptfoo
promptfoo init --example getting-started
          

Map each OpenAI eval to a config file

OpenAI's cookbook describes the move as manual recreation: you rebuild prompts, provider, test cases and assertions in a promptfooconfig.yaml file, and the process does not depend on any export feature from OpenAI Evals. The building blocks line up closely, as the graders guide and Promptfoo's assertions reference show.

OpenAI Evals concept Promptfoo equivalent Notes
Eval with data source promptfooconfig.yaml with tests Lives in your repo next to the code
Prompt template with variables prompts entry with variables in double braces Can load from a file
Model under test providers entry, for example openai:responses:gpt-6.2-astra Endpoint can be pinned
string_check grader (eq, ne, like, ilike) equals, contains, icontains assertions, negated with not- Deterministic, no model call
text_similarity grader (bleu, gleu, meteor, rouge and others) bleu, gleu, meteor, rouge-n, rouge-l assertions Scores may not match exactly; fuzzy_match and cosine need a substitute such as levenshtein or similar
score_model grader llm-rubric with a threshold Needs a judge model and validation
python grader python assertion Port the function
Run in the dashboard promptfoo eval, then promptfoo view New run history starts from zero

Promptfoo's OpenAI provider accepts openai:responses:model-name or openai:chat:model-name to pin the endpoint, and its documentation recommends dated snapshots where a model has them, to hold the version constant across runs.

A minimal config for a support-reply eval that used a string check and a model grader in OpenAI Evals:


            # promptfooconfig.yaml
description: Support reply eval, migrated from OpenAI Evals
prompts:
  - file://prompts/support_reply.txt
providers:
  - id: openai:responses:gpt-6.2-astra
    config:
      max_output_tokens: 800
tests:
  - description: Billing question names the customer
    vars:
      customer_name: Acme
      issue: billing question
    assert:
      - type: icontains
        value: Acme
      - type: llm-rubric
        value: Answers the billing question without inventing policy details
        threshold: 0.8
  - description: Refund request stays polite
    vars:
      customer_name: Globex
      issue: refund for a duplicate charge
    assert:
      - type: icontains-any
        value: [refund, credit]
          

Variables can also come from files, which helps when you copy large test sets out of the dashboard: a tests entry can point vars at a file or directory with the file:// prefix. The llm-rubric threshold works on a score between 0.0 and 1.0, and the test passes only if the judge's score is at or above it.

Run it, and compare before 30 November

The cookbook gives the commands for a first run, a results viewer and a config check.


            promptfoo validate config -c promptfooconfig.yaml
promptfoo eval -c promptfooconfig.yaml --no-cache
promptfoo view
          

Each Promptfoo run is new and separate from any completed OpenAI Evals run; the cookbook describes no way to import past results. It also warns that similarity scores may not match across systems, and that any recreated grader, LLM-as-a-judge graders above all, should be validated before you use it for regression decisions. So, while the dashboard is still readable:

  • Record the last run's pass rate and per-test results for every eval that gates a release.
  • Run the Promptfoo version against the same inputs and record both numbers side by side in the pull request.
  • Where they differ by more than a few points, read the failing cases by hand before you trust either score.

Put it in CI

Promptfoo's CI guide shows the eval running with npx, writing JSON, HTML or JUnit XML, and failing the build on test failures. A minimal GitHub Actions step:


            - name: Run LLM evals
  env:
    OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
  run: |
    npx promptfoo@latest eval -c promptfooconfig.yaml \
      -o results.json -o results.junit.xml \
      --fail-on-error \
      --tag git.sha="$GITHUB_SHA"
          

The --tag flag attaches pipeline context to the saved eval without editing the config. For the gates we recommend on top of a pass rate, see our guide to agent evals in CI/CD.

Step 2: move prompts from /v1/prompts into code

Find every call

Prompt objects show up in Responses API calls as a prompt parameter with an id, an optional version and a variables map; OpenAI's examples use ids starting with pmpt_, and the raw HTTP form uses a prompt_id field. Search for all of them.


            grep -rnE "pmpt_[A-Za-z0-9]+|prompt=\{|prompt: \{|\"prompt_id\"" \
  --include=*.py --include=*.ts --include=*.js --include=*.go --include=*.java .
          

For each hit, open the prompt in the dashboard and copy its current published version, including the system text, any developer messages and the variable names. Do this before 30 November; after that there is nothing to open.

Replace the object with a typed function

OpenAI's migration guide gives the shape of the change: keep the prompt text in your codebase, turn prompt variables into function arguments, and pass the built messages as input to the Responses API. In Python:


            from openai import OpenAI

client = OpenAI()

SUPPORT_SYSTEM = (
    "You are a helpful support assistant. Be concise, accurate, and friendly. "
    "Do not invent policy details."
)

def build_support_prompt(customer_name: str, issue: str) -> list[dict]:
    return [
        {"role": "system", "content": SUPPORT_SYSTEM},
        {
            "role": "user",
            "content": f"Customer name: {customer_name}. Issue: {issue}. "
                       "Write a response to the customer.",
        },
    ]

response = client.responses.create(
    model="gpt-6.2-astra",
    input=build_support_prompt("Acme", "billing question"),
)
print(response.output_text)
          

This replaces a call that sent a prompt with id, version and variables, and no model. Two consequences follow. You now name the model in code, so the model choice that used to live with the prompt version moves into your release process. And versioning moves to your repository: OpenAI's guide says to use git commits, pull request review and tests or evals for it, and to keep prompts in a small module of named builder functions rather than scattered inline.

To keep the eval and the application on the same text, store the prompt in one file that both read. Promptfoo can load a prompt from a file with the file:// prefix, which is what the config above does.

Keep the cache: static text first

OpenAI's guide ends with the point that matters for cost: put static content first and dynamic content later, because cache hits depend on exact prefix matches. The prompt caching guide adds that caching is on by default for supported models, that the minimum cacheable prompt is 1,024 tokens for GPT-5.6 and later, and that cached input is discounted by up to 95%. It also says cache writes on these models cost 1.25 times the uncached input rate for the default 30-minute lifetime, and that a token is billed at one rate only: uncached, cached or cache write.

The arithmetic on gpt-6.2-astra at standard rates, where input is $8.00, cached input $0.40 and a 30-minute cache write $10.00 per million tokens, is in the table below.

Scenario, 100,000 requests a day with a 4,000-token system prompt Input tokens per day Daily cost of that prefix
Customer name at the top, billed as plain input 400 million uncached 400 x $8.00 = $3,200
Customer name at the top, each new prefix written to cache 400 million cache writes 400 x $10.00 = $4,000
Static system text first, variables in the last user message 400 million cached 400 x $0.40 = $160

The table uses the standard prices on OpenAI's pricing page on 18 November 2026 and assumes every repeat request in the third row hits the cache. At this volume the cache stays warm, so writes in that row add only a couple of dollars a day (48 half-hour refreshes x 4,000 tokens x $10.00 per million is about $1.92). Real hit rates are lower, but the direction is clear: a mechanical port that puts a variable in the first line of a long prompt can cost 20 to 25 times more for the same text. Our note on OpenAI's prompt caching dashboard and cache-write cost covers how to watch hit rates and reads per write after the change.

Add a test that fails if the static part of the built input changes between two calls with different arguments. It is the cheapest guard you can write for this.


            def test_static_prefix_is_stable():
    a = build_support_prompt("Acme", "billing question")
    b = build_support_prompt("Globex", "refund")
    assert a[0] == b[0]  # system message identical, so the prefix can be cached
          

Step 3: move Agent Builder workflows to the Agents SDK

Export what you have

Agent Builder gives you code, not a converter. The migration guide's steps are: open the workflow, select Code in the top navigation, select Agents SDK, choose TypeScript or Python and copy the complete export. The same guide says the process does not convert the workflow graph and does not guarantee that every behaviour carries across unchanged. Export every published workflow now, commit the export to a repository, and note its workflow ID and version next to it.

Choose a destination

The guide offers two paths, summarised below from its options and limitations sections.

Path Best for What you must redo
Agents SDK in your application Engineering teams that deploy their own services Runtime configuration, tools, authentication, permissions and deployment
ChatGPT Workspace Agents Teams building agents in natural language and sharing them Apps, authentication, publishing and permissions, inside a Business, Enterprise or Edu workspace

The limitations section also warns that workflows with strong determinism at their core may not move faithfully to a workspace agent. If your workflow is a fixed pipeline with branches and typed outputs, take the Agents SDK route. For a wider comparison of OpenAI's agent surfaces, see our guide to choosing between Responses, Chat Completions, the Agents SDK and AgentKit.

Get the export running

The Agents SDK installs from npm or pip.


            npm install @openai/agents zod      # TypeScript
pip install openai-agents           # Python
          

A minimal agent with one function tool, following the quickstart's pattern:


            import asyncio
from agents import Agent, Runner, function_tool

@function_tool
def lookup_invoice(invoice_id: str) -> str:
    """Return the status of an invoice."""
    return f"Invoice {invoice_id}: paid"  # replace with your billing API call

support_agent = Agent(
    name="Billing support",
    instructions="Answer billing questions. Use lookup_invoice when an invoice ID is given.",
    model="gpt-6.2-astra",
    tools=[lookup_invoice],
)

async def main() -> None:
    result = await Runner.run(support_agent, "What is the status of invoice 4417?")
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())
          

Your Agent Builder export will be longer, but it uses the same parts: agents with instructions and a model, tools, and handoffs between specialist agents. The SDK overview positions it for teams whose server owns deployment, tool implementations, state storage and approval decisions, while the SDK runs the agent loop. That is the work the hosted workflow used to do for you, so budget for it:

  • State. Decide whether to keep history in your application, use an SDK session, or use a server-managed continuation ID; the quickstart lists all three.
  • Guardrails and approvals. If the workflow had a human-approval step, rebuild it with the SDK's guardrails and human review features before you go live.
  • Tracing. Turn on the SDK's integrations and observability so you can compare runs with the old workflow.
  • Tests. Add the workflow's representative inputs to the Promptfoo suite from step 1. The cookbook notes that a tool, agent or custom provider workflow needs its own setup in Promptfoo before the migrated eval can cover it.

Check your ChatKit front end

This is the item most likely to break silently. Agent Builder's own guide describes deployment as passing the workflow ID into a ChatKit integration. ChatKit survives the shutdown, but the ChatKit guide says the hosted-workflow path is only for existing Agent Builder users during the transition window, and that new apps, or teams migrating before the shutdown, should use the advanced integration with their own server-side agent. No OpenAI page we read says a hosted workflow keeps serving after 30 November.

So, for every ChatKit embed created with a workflow ID: move it to the advanced integration, run the ChatKit Python SDK on your own server and connect it to the Agents SDK agent you just built.

A 12-day checklist

  1. 18 to 19 November. List every eval, every pmpt_ reference and every Agent Builder workflow and ChatKit embed. Name an owner for each.
  1. By 21 November. Copy every eval's prompts, test data, grader settings and last results out of the read-only dashboard. Rebuild each in promptfooconfig.yaml and record old and new scores side by side.
  1. By 24 November. Replace prompt objects with typed functions, static text first. Add the prefix-stability test and point Promptfoo at the same prompt files.
  1. By 27 November. Export each workflow, run it on the Agents SDK in staging, move any ChatKit embed off its workflow ID and run the eval suite against the new agent.
  1. 28 to 30 November. Fix what failed, then remove the old IDs from configuration so nothing calls a dead endpoint on 1 December.
  1. After 30 November. Watch cache hit rates and token spend for a week, and diary 6 January 2027 if you use graders in fine-tuning.

The underlying dates come from OpenAI's deprecations page and Evals guide. For the other AI shutdowns landing in the same fortnight, see our November 2026 model retirement calendar.

India-specific considerations

Eval datasets often contain real user prompts. Moving them from OpenAI's dashboard into a Promptfoo config means deciding where that data now sits: Promptfoo's Community tier runs locally or self-hosted, so the test data can stay on your own machines or in your own cloud account, but any judge model or provider you call still receives it. If the data includes personal data under the Digital Personal Data Protection Act 2023, record the change in your processing records and strip or mask personal details from test cases where you can. This is not legal advice.

The calendar is the other constraint. With evals already read-only since 31 October, the 12 days left need a named owner rather than a ticket in a backlog.

How eCorpIT can help

eCorpIT is a Gurugram-based technology organisation, founded in 2021, assessed at CMMI Level 5 and MSME certified, with senior-led engineering teams working across AWS, Microsoft and Google platforms. Our AI and machine learning services team can rebuild your prompt objects, evals and Agent Builder workflows as tested code, with a Promptfoo suite in CI, before 30 November. Talk to us at /contact-us/.

Last updated: 18 November 2026.

References

  1. Deprecations, feature and endpoint deprecations table — OpenAI API docs
  1. Changelog, 3 June 2026 entry — OpenAI API docs
  1. Working with evals — OpenAI API docs
  1. Get started with Promptfoo — OpenAI API docs
  1. Pricing — Promptfoo
  1. Pricing — OpenAI API docs
  1. Prompt caching — OpenAI API docs
  1. Graders — OpenAI API docs
  1. Moving from OpenAI Evals to Promptfoo, 3 June 2026 — OpenAI Cookbook
  1. OpenAI acquires Promptfoo to secure its AI agents, 9 March 2026 — TechCrunch
  1. Promptfoo licence file — Promptfoo on GitHub
  1. Assertions and metrics — Promptfoo docs
  1. OpenAI provider — Promptfoo docs
  1. Configuration guide — Promptfoo docs
  1. LLM rubric — Promptfoo docs
  1. CI/CD integration for LLM evaluation and security — Promptfoo docs
  1. Migrate from prompt objects — OpenAI API docs
  1. Migrate from Agent Builder — OpenAI API docs
  1. Agents SDK quickstart — OpenAI API docs
  1. Agents SDK — OpenAI API docs
  1. Agent Builder — OpenAI API docs
  1. ChatKit — OpenAI API docs

Frequently asked

Quick answers.

01 What exactly does OpenAI shut down on 30 November 2026?
OpenAI shuts down the v1/prompts endpoint and reusable prompt objects, the Evals dashboard, API and graders used in eval workflows, and Agent Builder. All three were announced on 3 June 2026. ChatKit stays available, and self-serve fine-tuning job creation is restricted separately from 6 January 2027.
02 Can I still run my existing OpenAI evals before the shutdown?
Plan on no. OpenAI made Evals read-only for existing users on 31 October 2026. You can still open evals to read prompts, test data, grader settings and past results until 30 November, so copy everything you need now and rebuild each eval in a Promptfoo configuration file for future runs.
03 Does Promptfoo cost anything?
The Community tier is free, runs locally or self-hosted, includes all evaluation features and model providers, and allows 10,000 red-team probes a month. Enterprise and on-premise tiers are priced on request. Your evals still call models, so you pay normal API charges for every test case and every judge call.
04 Is there an automatic export from OpenAI Evals to Promptfoo?
No. OpenAI's own cookbook describes manual recreation: you rebuild prompts, providers, test cases and assertions in a promptfooconfig.yaml file. Each Promptfoo run is separate from past OpenAI runs, and no import of old results is described. Record your last OpenAI scores before 30 November as a baseline.
05 How do OpenAI graders map to Promptfoo assertions?
String check graders map to equals, contains and icontains assertions. Text similarity graders map to bleu, gleu, meteor and rouge assertions, with levenshtein as a stand-in for fuzzy matching. Score model graders become llm-rubric assertions with a threshold, and Python graders become python assertions. Validate model-graded ones before trusting them.
06 Will moving prompts into code increase my OpenAI bill?
It can. Prompt caching depends on an exact prefix match, so a variable near the top of a long prompt makes every request a cache miss. On gpt-6.2-astra that means paying 8 dollars, or 10 dollars if each prefix is written to cache, instead of 40 cents per million input tokens. Keep static instructions first.
07 Does Agent Builder convert my workflow into Agents SDK code automatically?
It exports code, in TypeScript or Python, from the Code option in the top navigation, but OpenAI says the export does not convert the workflow graph or guarantee identical behaviour. You must set up the runtime, tools, authentication, permissions and deployment yourself, then test the exported agent against representative inputs before switching traffic.
08 What happens to a ChatKit widget that uses an Agent Builder workflow ID?
ChatKit itself stays available, but the hosted-workflow path depends on Agent Builder, which shuts down on 30 November. OpenAI tells teams migrating now to use the advanced ChatKit integration with their own server-side agent. Move the widget to a server running your Agents SDK agent before the shutdown.

About the author

Manu Shukla

Founder & Director

Founder of eCorpIT. Hands-on engineer leading senior-only delivery for AI apps, custom software, and cloud systems for global clients.

Subscribe

One engineering note a week. No fluff, no spam.

Senior-architect playbooks on AI agents, mobile apps, cloud, security, data, and marketing — delivered every Wednesday.

Past the reading

Read enough. Let's build something.

A senior architect responds in 24 working hours with scope, indicative cost, and a timeline. NDA before any technical conversation.

Loading search…

Browse all guides