How Creasura steers ChatGPT through a complex task

ChatGPT did not load every tool up front and pick from a long menu. Each call was triggered by a concrete signal from the step before it: a file type, an empty result, an error. Five signals drove the whole task.

1. Signal 1 · Open-ended goal

   No file names, so look first

   Sam named no files, so the first job was to find out what already exists.

   Behind the scenes · trigger → decision → next tool

   Trigger

   The request mentions “my workbook” and “my contacts” but gives no file IDs or links.

   Decision

   Discover what templates and personal sources exist before planning or writing anything.

   Next tool

   Drive metadata search → file reader

   Why not the obvious move

   Building a fresh tracker from scratch would ignore Workbook A and Sam’s own resume.

   Result

   Found Workbook A, the Self-assessment sheet, Workbook B (.xlsx), the resume and a published engineering write-up.

2. Signal 2 · Empty result

   The address book is empty

   The contacts tool returned nothing, so ChatGPT looked where contacts actually were.

   Behind the scenes · trigger → decision → next tool

   Trigger

   The contacts tool returned 0 records.

   Decision

   An empty structured source is not an answer. Connection notices in email are ground truth for who Sam knows.

   Next tool

   Gmail search for connection notices → read the threads → web search for current roles

   Why not the obvious move

   Stopping at zero gives an empty list; a web search alone cannot prove Sam knows anyone.

   Result

   A contacts export of 30 people, each with a source thread and a checked current role.

3. Signal 3 · Google Sheets file type

   A live sheet needs cell edits

   The self-assessment is a native Google Sheet with a live score formula, so it was edited cell by cell.

   Behind the scenes · trigger → decision → next tool

   Trigger

   Drive reports application/vnd.google-apps.spreadsheet, with a SUM formula in V3.

   Decision

   Use range updates that keep formulas, formatting and sharing intact.

   Next tool

   Google Sheets range update

   Why not the obvious move

   Re-uploading the sheet as a new file would break the formula and change the file ID.

   Result

   Cells updated in place; the score formula recalculated by itself.

4. Signal 4 · Excel file type

   An .xlsx file needs a different tool

   Workbook B is an Excel file, which the Sheets tool cannot edit, so ChatGPT switched to Python.

   Behind the scenes · trigger → decision → next tool

   Trigger

   Drive reports application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.

   Decision

   Download the binary, edit it with a spreadsheet library, upload the result.

   Next tool

   Drive download → Python sandbox (openpyxl) → Drive upload

   Why not the obvious move

   Calling the Sheets tool on an .xlsx file ID fails with an unsupported-type error.

   Result

   Three empty tables filled, fonts and borders kept, file uploaded.

5. Signal 5 · HTTP error

   A blocked page needs a browser

   A plain fetch of a target company’s careers page was refused, so ChatGPT tried a real browser once.

   Behind the scenes · trigger → decision → next tool

   Trigger

   The static fetch returned an access error.

   Decision

   After one failure, escalate to a browser that renders the page.

   Next tool

   Headless browser → page text

   Why not the obvious move

   Retrying the same fetch wastes tokens; guessing the page from memory is not grounded.

   Result

   The open roles were read from the rendered page and cited.

The pattern is the same each time: the result of one call decides the next. Nothing is chosen because it might be useful later.

Next: Chapter 2 · How it knew what content to update ›

Every edit came from a simple diff. On one side, the template: blank or outdated cells in Sam’s files. On the other, verified personal sources: the resume, the published write-up, the contacts export and Sam’s own answers. Where they meet, you get an exact update.

• Every edit points to evidence. The evidence column is part of the record, not a footnote.
• No evidence, no edit. The mentor cell stays UNKNOWN. ChatGPT asks Sam instead of inventing a name.
• Never type over a formula. The score changed because its inputs changed, and the new value was read back.

This is what keeps a long task from drifting. A model that writes only what it can point to has very little room to make things up.

Next: Chapter 3 · How the Creasura kernel steers ChatGPT ›

Inside ChatGPT, ChatGPT owns the generation loop. Instructions, including any system prompt, are advisory: the model usually follows them, but nothing forces it to. So the proposed kernel relies on checks it runs itself, at the moment a tool is called.

1. Control 1 Mode AMode B

   Stage receipts

   Each write tool needs a receipt from the stage before it. No receipt, no write.

   Behind the scenes · how it works

   Understanding, committing and planning each return a receipt ID that the next tool requires. If ChatGPT skips ahead, the kernel refuses the call before anything changes and says which tool to call instead. The guarantee is the refusal, not the model’s obedience.

   {
     "error": {
       "code": "PRECONDITION_FAILED",
       "message": "Missing plan_receipt_id. Nothing was written.",
       "retryable": true,
       "details": {
         "must_call_next": "creasura_resolve_context"
       }
     },
     "trace_id": "trace_sam_002"
   }

2. Control 2 Mode AMode B

   Next-step directives

   Every tool result ends with a short note saying which stage comes next.

   Behind the scenes · how it works

   The note sits at the end of the latest tool result, close to where the model is reading. That makes it more likely to be followed than an instruction from long ago, but it is still advice. Stage receipts are what enforce the order.

   {
     "status": "CONTEXT_RESOLVED",
     "context_snapshot_id": "ctx_sam_05",
     "_kernel_directive": {
       "current_stage": "UNDERSTAND",
       "next_stage": "COMMIT",
       "must_call_next": "creasura_commit_work",
       "instruction": "Do not reply to Sam yet. Register the commitment first."
     }
   }

3. Control 3 Mode AMode B

   Dynamic tool list

   ChatGPT only sees the tools that make sense for the current stage.

   Behind the scenes · how it works

   The Creasura MCP server changes its tool list as the work moves on and sends the standard MCP notifications/tools/list_changed notice. A model cannot call a tool it was not offered. How quickly a host refreshes its list is up to the host, so receipts still back this up.

   {
     "method": "notifications/tools/list_changed",
     "state": "WAITING_APPROVAL -> RUNNING",
     "tools_now_visible": [
       "creasura_execute_step",
       "creasura_verify_execution"
     ]
   }

4. Control 4 Mode AMode B

   Gateway tools

   ChatGPT makes one call per stage; the kernel runs the fiddly chain behind it.

   Behind the scenes · how it works

   Instead of exposing raw connectors, Creasura exposes a few lifecycle tools such as creasura_resolve_context. One call runs the whole fallback chain on the server (contacts, then email, then web) and returns a short summary, so pages of raw email never reach the chat.

   {
     "tool": "creasura_resolve_context",
     "arguments": {
       "goal_id": "goal_sam_01",
       "fallback_policy": "contacts_then_email_then_web"
     },
     "kernel_trace": [
       "contacts: 0 records",
       "email: 30 connection threads",
       "web: 30 current roles checked"
     ]
   }

5. Control 5 Mode B

   Forced tool choice

   When Creasura calls the model itself, it can require the exact next tool.

   Behind the scenes · how it works

   This works only in Mode B, where Creasura calls the OpenAI API directly. The request names the one function the model must call, with tool_choice. Creasura can also rebuild the message history from a compact checkpoint when it grows too long. Neither is possible inside the ChatGPT app.

   {
     "model": "<model>",
     "tools": [
       {
         "type": "function",
         "name": "creasura_verify_execution"
       }
     ],
     "tool_choice": {
       "type": "function",
       "name": "creasura_verify_execution"
     }
   }

Mode A is the easy start: no new app to learn. Mode B is for long or background work, where the kernel needs a firmer hand on each step.

Next: Chapter 4 · Step through the protocol ›

Here is the same task as six exchanges between ChatGPT and the kernel. Turn on “Behind the scenes” to see each call and reply.

ChatGPT did the thinking at every step. The kernel made sure the order held, the fallback happened, Sam stayed in charge, and “done” meant something that was checked.

Next: Further reading ›