I have spent most of this week working in Codex with GPT-6 Astra, so this week's video is about the MCP side of qbash. Tasks you have already built, and memory folders you already keep, become callable tools in whatever editor you happen to be in. The demo drafts our weekly newsletter from three sources without leaving Codex, and the Tasks doing the fetching still run on qbash.
What's covered
- The two server types on the MCP Servers page, and what a connection exposes
- Why the Task keeps running on qbash even when Codex is the thing that invokes it
- The three memory folders behind the newsletter, and what the archive of past issues is for
- One prompt in Codex, the MCP calls it makes, and the draft that comes back
Two kinds of server
Memory tools connect an MCP client to a memory folder, so an assistant can create, search, update, and retrieve that folder's documents. MCP Servers make Tasks and selected connector tools callable alongside them. API Endpoints publish a prompt or Task as a REST URL, which this demo leaves alone.
Connections are the unit underneath both. Each one gets its own MCP URL and bearer token and points at a specific set of Tasks or a specific folder, so a client only sees what you pointed it at. The execution server here has two connections, one task each: ticker-writer, which collects recent AI news, and a changelog Task that reports what is new on the qbash main branch over the last N days.
What stays on qbash
Invoking a Task over MCP does not move the Task. It runs on the qbash runtime, with the model bindings, integrations, and run history it already had, and the run shows up in the logs like any other. Codex supplies the trigger and the inputs, then waits for a structured result.
The content Tasks were built once, against the models and integrations they needed, and every client that speaks MCP can now call them.
The memory folders
Memories are durable storage with search built in, quick to stand up and quick to query. Three folders are connected here: an archive of every newsletter we have sent, an archive of every blog article, and our public product documentation.
Past issues are what a model reads to work out how the next one should sound, which is what the newsletter archive is there for.
One prompt
I need to pull together a newsletter for this week. Look back at the main branch for 14 days, and the blog for the last 7. Give me last 24hours of ai news from ticker.
Codex restates it as a plan: gather product updates from main for the last 14 days, blog posts from the last 7 days, and ticker news from the last 24 hours, then review recent newsletters and draft this week's issue. It also picks up the copy review rules sitting in the local repo, which were never mentioned in the prompt.
Then the MCP calls start. It lists records on the memory servers and reads back previous newsletters. It fires the two execution requests and checks in on them periodically while they run. There is a wait in the middle of this, and the video cuts through it.
The run hit a usage limit partway through, because Astra gets through tokens quickly. Everything else behaved as expected.
The draft
What came back was newsletter-draft-2026-09-16.md. The product section covers Task Secrets, which stores encrypted API keys at the organization level and resolves them server-side, and GPT-6 Astra arriving in the model catalog with a 1.05M token context window, plus the note that above 272K input tokens the long-context rate applies. A "From the blog" section summarises each recent post with a link and names its author. The ticker items follow.
It reads like our newsletter. What is left is a review pass over a first draft.
Video transcript
Hey guys, Mitch from qbash here. Like many of you, I've been messing around with the new models and I'm always kind of staying on top of different surfaces to work in, different tools to use, which means this week I've been using GPT-6 Astra in Codex quite a bit. It made me think I haven't done a video about different MCP options and so I thought I'd do that, put together a quick demo about how that might work and what that looks like. So for this demo I've pulled together a couple of the tasks that I run pretty often, summarize new features, ticker writer. These are like content tasks for when I do newsletters or customer outreach and stuff like that.
I've also pulled together a couple of the different memories folders that we have and I've created a few services, you know, right? So the ticker writer is an execution server, which means there's a task attached here and via our MCP I can trigger that task. It still runs on the Aisle runtime. All of the model details are available there, but it's triggered by, in this case, Astra in Codex. And the same is true for this one.
This is like a change log task that I run, which is like, "Okay, on the main branch of qbash, what's new in the last N number of days?" Similarly, we have memories MCP server. So our memories feature is essentially like databases that you can spin up really, really quickly. They have built-in rag capabilities and I use them all the time. You can spin them up really, really fast and rag things on the fly. There are a couple that I use pretty consistently, though, and they really act as like the spine of record for a number of things that I do.
For example, an archive of all of our newsletters, an archive of all of our blog articles, and our product documentation, right? Search works, the the docs that we have in public and this powers a number of different things. So all of these are available on MCP servers and I can flick across to Codex and say, "I need to pull together a newsletter for this week. Look back at the main branch for 14 days and the blog for the last 7. Give me the last 24 hours of AI news from Ticker.
Right? And all of those MCP services uh servers have been installed. So, you can see here it's going to gather product updates from main for the last 14 days, blog posts from the last 7 days, and Ticker news from the last 24 hours. Right? It's pulled in some copy review stuff that I have locally.
And now you can see that it is executing a bunch of different MCP things. So, it's listing the records available on the memory servers. It's returning them here. These are previous newsletters that it's looking at. So, it is combining a bunch of these together.
I'll pause it here and we'll come back when we have something to look at. Okay, so we're back. Again, apologies for the drilling in the background. Hit a couple snags on the way. Primarily, we hit our usage limit.
Astra is a very hungry model. But everything worked as expected. So, you can see here that it used the newsletter and blog integrations to pull in most recent things. It sent out those two execution server requests and checked in with them periodically and then eventually landed on a first draft for us to review. So, it has pulled in a new feature that we're going to launch, GPT-6 Astra being launched from the blog.
Yep, our most recent articles on the blog. Then some some new pieces of news from our Ticker function, all there in in the style that I So, that is how you can use our different development servers to have, you know, tasks and and files being generated and stored on qbash and then use them wherever you're working.