cleaned up a few typos formatting and tightened up confusing sections

Author: billchen-openai

examples/responses_api/reasoning_items.ipynb

@@ -305,13 +305,15 @@
    "source": [
     "## Encrypted Reasoning Items\n",
     "\n",
-    "For organizations that can't use the Responses API statefully due to compliance or data retention requirements (such as [Zero Data Retention](https://openai.com/enterprise-privacy/)), we've introduced [encrypted reasoning items](https://platform.openai.com/docs/guides/reasoning?api-mode=responses#encrypted-reasoning-items). This lets you get all the benefits of reasoning items while keeping your workflow stateless.\n",
+    "Some organizations—such as those with [Zero Data Retention (ZDR)](https://openai.com/enterprise-privacy/) requirements—cannot use the Responses API in a stateful way due to compliance or data retention policies. To support these cases, OpenAI offers [encrypted reasoning items](https://platform.openai.com/docs/guides/reasoning?api-mode=responses#encrypted-reasoning-items), allowing you to keep your workflow stateless while still benefiting from reasoning items.\n",
     "\n",
-    "To use this, simply add `[\"reasoning.encrypted_content\"]` to the `include` field. You'll receive an encrypted version of the reasoning tokens, which you can pass back to the API just as you would with regular reasoning items.\n",
+    "To use encrypted reasoning items:\n",
+    "- Add `[\"reasoning.encrypted_content\"]` to the `include` field in your API call.\n",
+    "- The API will return an encrypted version of the reasoning tokens, which you can pass back in future requests just like regular reasoning items.\n",
     "\n",
-    "For Zero Data Retention (ZDR) organizations, OpenAI enforces `store=false` at the API level. When a request arrives, the API checks for any `encrypted_content` in the payload. If present, it's decrypted in-memory using keys only OpenAI can access. This decrypted reasoning (chain-of-thought) is never written to disk and is used only for generating the next response. Any new reasoning tokens are immediately encrypted and returned to you. All transient data—including decrypted inputs and model outputs—is securely discarded after the response, with no intermediate state persisted, ensuring full ZDR compliance.\n",
+    "For ZDR organizations, OpenAI enforces `store=false` automatically. When a request includes `encrypted_content`, it is decrypted in-memory (never written to disk), used for generating the next response, and then securely discarded. Any new reasoning tokens are immediately encrypted and returned to you, ensuring no intermediate state is ever persisted.\n",
     "\n",
-    "Here’s a quick update to the earlier code snippet to show how this works:"
+    "Here’s a quick code update to show how this works:"
    ]
   },
   {

examples/responses_api/responses_example.ipynb

@@ -4,18 +4,19 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## What is the Responses API\n",
+    "## What is the Responses API?\n",
     "\n",
-    "The Responses API is a new API that focuses on greater simplicity and greater expressivity when using our APIs. It is designed for multiple tools, multiple turns, and multiple modalities — as opposed to current APIs, which either have these features bolted onto an API designed primarily for text in and out (chat completions) or need a lot bootstrapping to perform simple actions (assistants api).\n",
+    "The Responses API is a new way to interact with OpenAI models, designed to be simpler and more flexible than previous APIs. It makes it easy to build advanced AI applications that use multiple tools, handle multi-turn conversations, and work with different types of data (not just text).\n",
     "\n",
-    "Here I will show you a couple of new features that the Responses API has to offer and tie it all together at the end.\n",
-    "`responses` solves for a number of user painpoints with our current set of APIs. During our time with the completions API, we found that folks wanted:\n",
+    "Unlike older APIs—such as Chat Completions, which were built mainly for text, or the Assistants API, which can require a lot of setup—the Responses API is built from the ground up for:\n",
     "\n",
-    "- the ability to easily perform multi-turn model interactions in a single API call\n",
-    "- to have access to our hosted tools (file_search, web_search, code_interpreter)\n",
-    "- granular control over the context sent to the model\n",
+    "- Seamless multi-turn interactions (carry on a conversation across several steps in a single API call)\n",
+    "- Easy access to powerful hosted tools (like file search, web search, and code interpreter)\n",
+    "- Fine-grained control over the context you send to the model\n",
     "\n",
-    "As models start to develop longer running reasoning and thinking capabilities, users will want an async-friendly and stateful primitive. Response solves for this. \n"
+    "As AI models become more capable of complex, long-running reasoning, developers need an API that is both asynchronous and stateful. The Responses API is designed to meet these needs.\n",
+    "\n",
+    "In this guide, you'll see some of the new features the Responses API offers, along with practical examples to help you get started."
    ]
   },
   {
@@ -181,7 +182,7 @@
     "\n",
     "Another benefit of the Responses API is that it adds support for hosted tools like `file_search` and `web_search`. Instead of manually calling the tools, simply pass in the tools and the API will decide which tool to use and use it.\n",
     "\n",
-    "Here is an example of using the `web_search` tool to incorporate web search results into the response. You may already be familiar with how ChatGPT can search the web. You can now build similar experiences too! The web search tool uses the OpenAI Index, the one that powers the web search in ChatGPT, having being optimized for chat applications.\n"
+    "Here is an example of using the `web_search` tool to incorporate web search results into the response."
    ]
   },
   {