OpenAI DevDay 2026: Dots, the Agents API, and Why JSON Repair Matters More Than Ever

OpenAI held DevDay on September 29, 2026. Three announcements stood out: Dots (always-on agents with persistent MCP connections and parallel subagents), the Agents API (a managed runtime for building production agent systems), and Plugin Extensions (a way to extend existing ChatGPT plugins with new capabilities).

These are not incremental improvements. They represent a structural shift in how LLM output reaches production systems — more agentic pipelines, more parallel subagent calls, more inter-agent JSON passing, and a dramatically higher surface area for malformed structured output to cause silent failures.

This post, written by The JSON Medic, breaks down each announcement through the lens of JSON reliability: what it introduces, where it breaks, and what repair infrastructure you need to add before deploying at scale.

---

Dots: Always-On Agents With Persistent MCP Connections

Dots is OpenAI's answer to the question "what happens when an agent needs to maintain context across many sessions?" Each Dot is a persistent agent instance with:

• A named identity and persistent memory store
• One or more MCP connections that stay live between invocations
• The ability to spawn parallel subagents for concurrent task execution
• A message-passing interface for inter-agent communication

From a JSON reliability standpoint, Dots introduces three new failure surfaces.

MCP Tool Call JSON

Every tool call a Dot makes goes over MCP as a JSON-RPC 2.0 message. The method name, parameters, and result are all JSON-encoded. A malformed tool call — a missing params key, a parameter of the wrong type, a result with an unexpected field — silently fails or throws an unhandled exception in the MCP server.

MCP's JSON-RPC 2.0 spec is strict. The id field must be a string or integer (not null, not an object). The method field must be a non-empty string. The params field, when present, must be a structured value (object or array, not a primitive). Any deviation from these rules causes the server to return a parse error or invalid request error.

For reference, our MCP JSON-RPC error guide covers the five most common MCP JSON errors in detail. With Dots creating persistent MCP connections that stay open across many invocations, a single schema drift in the tool call format can corrupt an entire session.

Inter-Agent JSON Passing

When a Dot spawns parallel subagents, the parent agent passes context to each subagent as a JSON payload. The subagent returns its result as JSON. Both directions are failure points.

The parent's context payload may include truncated history, malformed task descriptions (especially if a previous step produced partial output), or schema-incompatible data from a prior tool call result. The subagent's return value may be well-formed at the structural level but semantically invalid — the classic problem that BenchLM's September 2026 data quantified: GPT-5.6 Terra achieved 87/87 structurally valid JSON outputs but 10 of those contained wrong values.

At scale with parallel subagents, this is a multiplicative problem. Five subagents running concurrently each have an independent probability of returning bad JSON. Without a validation layer at the aggregation point, the parent agent may compose a response from partially-invalid data.

Persistent Memory Store Corruption

Dots agents write to and read from a persistent memory store. That store is typically JSON-encoded. If an agent writes a malformed entry — truncated during a network interruption, incorrectly escaped, or structurally invalid from a model error — subsequent reads from that memory key will fail silently or return garbage.

This is a new failure mode that stateless LLM API calls don't have. A single bad write to persistent memory can affect every future session for that Dot.

---

The Agents API: Managed Runtime for Production Agents

The Agents API provides a managed execution environment for OpenAI agent workflows — orchestration, retry logic, parallel execution, and observability. It's positioned as the production-ready alternative to building your own agent infrastructure.

The API introduces two JSON-specific reliability concerns.

Typed Tool Definitions

The Agents API uses JSON Schema to define tool signatures. Every tool definition is a JSON Schema object specifying the function name, description, and parameter types. The model is expected to generate tool calls that conform to this schema.

In practice, schema compliance rates for complex tool definitions are not 100%. The structured output libraries survey we published earlier in 2026 found that schema compliance on nested objects with required fields ranged from 94% to 99.7% across Instructor, BAML, and XGrammar — never perfect, always requiring some form of validation or retry logic.

The Agents API adds retry infrastructure, but the retry policy is at the task level, not the JSON schema level. A tool call that produces structurally valid JSON but with wrong values (a string where an integer is required, an empty array where the schema requires at least one element) will not trigger an automatic retry. It passes structural validation and fails silently downstream.

Teams using OpenAI's built-in JSON mode for non-function-calling structured output see the same gap: the response_format: { type: "json_object" } flag guarantees syntactically valid JSON but does not validate values against your schema — value-accuracy errors pass through undetected.

Streaming Agent Output

The Agents API supports streaming output for long-running agent tasks. Streamed JSON is particularly vulnerable to truncation — if the stream ends mid-object (due to a timeout, a network error, or a model context limit), the resulting JSON is always invalid.

The repair pattern for streamed JSON is different from the batch repair pattern. You cannot simply call JSON.parse on a complete string because the string never becomes complete. The standard approach is to buffer the stream, detect the truncation point, and complete the closing brackets programmatically — exactly what the json-repair library does for truncated streaming outputs.

---

Plugin Extensions: New Capability, Same JSON Surface

Plugin Extensions let developers add new capabilities to existing ChatGPT plugins without rebuilding the plugin from scratch. The extension API uses the same JSON Schema-based tool definition format as the original plugin API.

The JSON reliability concern here is compatibility. A Plugin Extension may define new parameters that existing integrations don't know about, or it may modify the expected response schema in ways that older consumers haven't accounted for. Schema evolution is one of the least-handled cases in production JSON pipelines — most systems are built to reject unknown fields or fail on missing fields, not to gracefully handle schema drift.

For teams extending existing plugins, the immediate action is to validate your extension's JSON Schema against both the new definition and the existing consumer expectations before shipping.

---

The Common Thread: More JSON, More Failure Surface

All three DevDay announcements share a common property: they create more LLM-generated JSON flowing through production systems.

Dots means persistent agents continuously emitting and consuming JSON across tool calls, memory reads, and subagent communication. The Agents API means more structured tool definitions, more parallel calls, and more streaming outputs. Plugin Extensions mean more schema evolution, more compatibility surface, and more consumers of JSON that was written for a slightly different schema.

The repair and validation toolchain you need for DevDay 2026 is not new — it's the same three-layer pipeline that has been the standard for production LLM systems since early 2026:

1. Structural repair — fix malformed JSON before parsing (truncation, trailing commas, single quotes, unescaped characters)
2. Schema validation — validate repaired JSON against the expected schema; catch type mismatches, missing required fields, and invalid enum values
3. Inspection layer — for generative outputs, check value accuracy, not just structural compliance; a structurally valid JSON object can still contain hallucinated data

What DevDay 2026 changes is the volume and the topology of this problem. Parallel subagents mean that a single user request triggers multiple JSON-generating LLM calls. Persistent memory means that bad JSON from one session can corrupt future sessions. Streaming outputs mean that truncation is a permanent feature of long-running tasks, not an edge case.

---

What to Add to Your Pipeline Before Deploying Dots

If you're planning to deploy a Dots-based agent or build on the Agents API, here are the concrete steps to add before you go to production:

1. Wrap every JSON.parse in try/catch with repair fallback.

import { repairJSON } from 'jsonrepair';

function safeParseJSON(raw) {
  try {
    return JSON.parse(raw);
  } catch {
    const repaired = repairJSON(raw);
    return JSON.parse(repaired);
  }
}

This handles structural errors from truncation, streaming interruptions, and model formatting mistakes.

2. Validate tool call parameters against your schema before execution.

import jsonschema

def execute_tool_call(tool_name: str, params: dict, schema: dict):
    try:
        jsonschema.validate(params, schema)
    except jsonschema.ValidationError as e:
        # Log the error, return a typed failure to the agent
        return {"error": "schema_validation_failed", "detail": str(e)}
    return dispatch_tool(tool_name, params)

This catches the class of errors that structural repair cannot fix: valid JSON with the wrong types or values.

3. Add a write-validation step for persistent memory.

def write_memory(key: str, value: dict, schema: dict):
    # Validate before writing — corrupt memory is worse than no write
    jsonschema.validate(value, schema)
    memory_store.set(key, json.dumps(value))

Validating before writing to a Dot's persistent memory prevents a bad model output from corrupting future sessions.

4. Use AI JSON Medic's REST API for complex repair scenarios.

For production systems where the local repair library's heuristics are insufficient — deeply nested objects, very long truncated outputs, multi-JSON-object streams — the AI JSON Medic API uses Claude to perform semantically-aware repair, not just structural reconstruction.

---

Why This Validates the JSON Repair Category

One of the less-noticed implications of DevDay 2026 is that OpenAI has implicitly validated the JSON repair category as an infrastructure concern, not a developer bug.

By providing managed retry logic in the Agents API, by designing MCP connections that stay live across sessions, and by supporting parallel subagents with inter-agent JSON passing, OpenAI has acknowledged that LLM-generated JSON fails in production — not as an exception, but as a regular operational condition that requires infrastructure-level handling.

This is the same conclusion that Anthropic reached when designing MCP's JSON-RPC 2.0 transport, the same conclusion that BAML, Instructor, and Outlines reached when building their structured output libraries, and the same conclusion that the BenchLM September 2026 benchmark confirmed with hard numbers: structural compliance is not value accuracy, and neither is guaranteed without a validation layer.

The more agentic the system, the more JSON it produces, and the more important the repair and validation infrastructure becomes. DevDay 2026 is a signal that this infrastructure is no longer optional.

---

Summary

OpenAI DevDay 2026 announced Dots (persistent agents with MCP + parallel subagents), the Agents API (managed agent runtime), and Plugin Extensions. Each announcement increases the volume and topological complexity of LLM-generated JSON in production systems.

The repair and validation toolchain doesn't change: structural repair → schema validation → inspection layer. What changes is that this toolchain is now table stakes, not an optimization. Persistent memory corruption, inter-agent JSON failures, and streaming truncation are not edge cases in an agentic world — they're the default operational condition.

Add AI JSON Medic's repair API to your pipeline. Validate your schemas before and after repair. Build the inspection layer before you need it.

---

FAQ

What is OpenAI Dots?

Dots is OpenAI's always-on persistent agent framework, announced at DevDay 2026. Each Dot is a named agent instance with persistent memory, MCP connections that stay live between sessions, and the ability to spawn parallel subagents.

What is the OpenAI Agents API?

The Agents API is a managed runtime for building production agent workflows on OpenAI infrastructure. It provides orchestration, retry logic, parallel execution, and observability for multi-step agent tasks.

Why does agentic AI produce more JSON errors than single-call LLMs?

Agentic systems make many LLM calls in sequence or parallel, pass JSON between agents, and maintain persistent state. Each of these is a failure point. Parallel subagents multiply the error surface by the number of concurrent calls.

How does MCP affect JSON reliability?

MCP uses JSON-RPC 2.0 as its transport protocol. Every tool call and result is a JSON-encoded message with strict schema requirements. Persistent MCP connections mean that schema drift in one tool call can affect all subsequent calls in the same session.

What is the three-layer JSON pipeline for production agents?

Structural repair (fix malformed JSON) → schema validation (validate repaired JSON against the expected schema) → inspection layer (check value accuracy for generative outputs). Each layer catches a different failure mode.

Is structural repair enough for production agent systems?

No. Structural repair fixes syntax errors but not semantic errors — wrong types, wrong values, hallucinated data. Schema validation is required as a second layer, and an inspection layer is required for outputs where value accuracy matters.