OpenAI Assistants API Hard-Stops Tomorrow as Haystack Agno Langfuse Harden Agent Plumbing

The last 48 hours were not about a new flagship model. They were about the plumbing that decides whether your agents survive contact with production. OpenAI’s Assistants API — the beta that taught a generation of teams to think in Assistants, Threads, and Runs — reaches a hard shutdown tomorrow, August 26. Official docs are unambiguous: those endpoints stop. The replacement is the Responses API plus Conversations, and there is no automated thread migrator.

At the same time, the open-source agent stack started treating context as a first-class resource instead of an accident. Haystack 3.1.0 added experimental compaction hooks that shorten conversations before the next model call. Agno 3.0.0 pulled run history out of a growing session blob and into a real table — the kind of unglamorous schema change that keeps long-lived agent platforms from melting their store. Langfuse 4.17.0 tightened the eval and annotation loop so you can score those same agents instead of eyeballing traces.

If you ship software that talks to models, today is a migration day, not a research day. Grep for `openai.beta`, pin a compaction strategy, and do not serve Agno 3.0 against an unmigrated database.

Top Stories

OpenAI Assistants API shuts down August 26 Practical dev impact: After tomorrow, every `openai.beta.threads` / `openai.beta.assistants` call fails — move state to Conversations and execution to Responses today. Official docs map Assistants → Prompts, Threads → Conversations, Runs → Responses, and Run steps → Items. Feature parity is the stated reason: Responses already carry file search, code interpreter, MCP, deep research, and computer use. OpenAI will not convert existing Threads into Conversations; you recreate history yourself. Azure timelines track the same cutoff. Grep the beta namespace, recreate instruction-plus-tool bundles as dashboard prompts, and cut new chats over before the endpoints return errors.

Haystack 3.1.0 adds experimental agent context compaction Practical dev impact: Long Haystack agents can now drop old turns automatically instead of dying when the window fills. `CompactionHook` runs on `before_llm` and fires `SlidingWindowCompactor` at a configured fraction of the context window, keeping system messages, the latest user task, and as much recent conversation as the target allows. Compaction is lossy — removed messages are replaced by an omission note, not a summary — and the APIs emit `ExperimentalWarning`. The same release adds `ToolResultPruningCompactor`, `AgentTool` for nested agents, `exit_reason` routing, and `OpenAIResponsesChatGenerator`, so Haystack 3.x is now explicitly a Responses-era agent runtime.

Agno 3.0.0 requires a database migration before traffic Practical dev impact: Do not `pip install -U agno` into production until `MigrationManager(db).up()` has copied runs and you have verified `get_runs()`. v3 moves each run into `agno_runs`, adds tool-result offloading above 16k characters, media offload to disk/S3/GCS, CodeMode, durable background queues, and per-user isolation across metrics, knowledge, and vector stores. The migration is idempotent and keeps the legacy blob as backup; cleanup is destructive and needs `force=True`. Breaking API surface is large: `reasoning=True` is gone, Workflow is keyword-only, HITL kwargs collapse into `HumanReview`, and several tool modules were deleted or renamed.

Langfuse 4.17.0 rebuilds the evaluation and annotation loop Practical dev impact: You can now stand up production evaluators and human queues from the traces you already collect, then score a Responses or Haystack cutover against the old Assistants path. v4.17.0 adds a new evaluation UX, annotation queues created from the trace and events tables, evaluator-model filters, and Anthropic Messages as a provider for Langfuse Assistant (OSS), plus Bedrock prefix caching across turns. If you are rewriting agent runtimes this week, this is the measurement layer — not another orchestration framework.

Practical Impact Analysis

The Assistants sunset is the only story that can page you at 09:00 tomorrow. If any production path still constructs a thread or polls a run, that path is a hard outage, not a deprecation warning. The Responses model is also a design change: you own the tool loop, prompts live in the dashboard, and leftover assistant IDs become dead data after the cutoff. Plan a dual-write window only if you still have hours; otherwise cut new sessions to Conversations and leave old threads read-only until they vanish.

Haystack’s compaction hook and Agno’s tool-result offloading are the same idea from two angles: stop stuffing the entire agent transcript into the next prompt. Sliding-window compaction is experimental and lossy — do not expect a summarizer, and leave headroom above `compact_at` for the next tool burst. Agno’s 16k-character offload plus a dedicated runs table is the production version of that insight. The upgrade is safe only if you verify copied rows before you drop the legacy column.

Langfuse 4.17.0 is the measurement layer for both migrations. Queues created from the trace table mean you can score Responses-based agents and compacted Haystack runs without exporting CSVs. Stand up one evaluator on a golden set of Assistants transcripts and run it against the rewrite before you delete the beta clients.

Together these updates push the stack toward explicit state, bounded context, and evals as a release gate. Teams that still treat “just send the whole history” as an architecture will feel it first.

Tutorial

Migrate a single Assistants-style chat to Responses + Conversations before the August 26 cutoff. Official mapping: Assistant → Prompt (dashboard), Thread → Conversation, Run → Response. OpenAI will not port Threads for you.

1. Grep the repo for `openai.beta`, `/v1/assistants`, `/v1/threads`, and stored `asst_` / `thread_` IDs. Anything in that set dies tomorrow. 2. Recreate the old assistant’s instructions and tools as a named prompt in the dashboard, or keep instructions inline for the first cutover. 3. Create a Conversation for each new user session. Conversations store items (messages, tool calls, outputs), not just chat messages. 4. Call `responses.create` with `model`, `input`, and `conversation`. No run-polling loop. 5. Replay three golden prompts from the old assistant and compare outputs before you delete the beta client.

import os
from openai import OpenAI

client = OpenAI()

# 1) New session == Conversation (was Thread)
conversation = client.conversations.create(
    items=[{"role": "user", "content": "List the last three deploy failures."}],
    metadata={"user_id": "oncall-bot", "migrated_from": "assistants_api"},
)

# 2) One Response replaces create-run + poll (official model id from the migration guide)
response = client.responses.create(
    model="gpt-5.6",
    conversation=conversation.id,

... click "Show full code" below to expand

import os
from openai import OpenAI

client = OpenAI()

# 1) New session == Conversation (was Thread)
conversation = client.conversations.create(
    items=[{"role": "user", "content": "List the last three deploy failures."}],
    metadata={"user_id": "oncall-bot", "migrated_from": "assistants_api"},
)

# 2) One Response replaces create-run + poll (official model id from the migration guide)
response = client.responses.create(
    model="gpt-5.6",
    conversation=conversation.id,
    input=[{"role": "user", "content": "List the last three deploy failures."}],
    instructions=(
        "You are the on-call coding assistant. Be concise. "
        "Cite file paths when you mention code."
    ),
    tools=[{"type": "code_interpreter"}],
)

print(conversation.id)
print(response.output_text)

# 3) Follow-up stays on the same conversation — no previous_response_id juggling
followup = client.responses.create(
    model="gpt-5.6",
    conversation=conversation.id,
    input=[{"role": "user", "content": "Open a draft rollback plan for the worst one."}],
)
print(followup.output_text)

Wire the same conversation ID into Langfuse as a session so the 4.17 eval UX can score old Assistants transcripts against this path. If you also run Haystack, point `OpenAIResponsesChatGenerator` at the same model family and attach `CompactionHook` before the first long-horizon job.

Grok Deep Dive

Tomorrow OpenAI turns off the Assistants API (Assistants/Threads/Runs → Prompts/Conversations/Responses, no automated thread migrator). Yesterday Haystack 3.1.0 landed experimental `CompactionHook` + `SlidingWindowCompactor` and `AgentTool`, while Agno 3.0.0 broke storage (runs → `agno_runs`, required `MigrationManager(db).up()`, tool-result offload, CodeMode) and Langfuse 4.17.0 rebuilt evals and annotation queues. Walk me through a production cutover: grep plan for `openai.beta`, a dual-run eval harness in Langfuse that scores Assistants transcripts against Responses, when to choose Haystack sliding-window compaction versus Agno tool-result offloading, and the exact Agno verify-then-cleanup sequence so we do not delete the legacy blob before `get_runs()` proves the copy landed.