Yeah the main value is definitely the code execution layer. You could easily generate a type-safe client from your REST, GraphQL, TRPC layer, expose it to the Deno layer and list the types as a resource or something. No need to involve MCP at all. You're basically just defining a stdlib for the LLM.

If you run `deno check` before executing the code you'd get the type-safety loop (working on this now)

Later I want to see what'd happen if you give the LLM a repo of sorts to store useful snippets and functions with comments for later use. So the LLM itself would save workflows, be able to import them into the Deno environment and chain those together.

It definitely needs a prompt that tells it to use the MCP server but I can see it being pretty powerful.

I only did simple tests like get Reddit posts, their comments, find the weather on those days, stick them in duckdb, and run some social media metric queries.

I could see that same test being: "find me leads, filter by keywords, run against some parquet file stored somewhere using duckdb, craft an email for my boss."

I'm kind of ranting but I think this a pretty exciting approach.

Edit: GraphQL style codegen layer but for all your APIs seems like a pretty obvious middle layer for this, maybe next weekend.

Can you expand on the RL thing?

Just because an agent “lives” in the environment, doesn’t make it RL. It needs a reward function, or even better something like Gym.

I read it as this leading towards an alternative to MCP, what many people have been thinking about as well. Just that to not completely pull the rug on the most hyped thing right now, they are like this is a better way to do MCP.

Haha yes, yes it is. I wrote out and implemented that approach in the links below. I've been playing with it for a few hours and I have to say I actually really really like it.

One thing I ran into is that since the RPC calls are independent Deno processes, you can't keep say DuckDB or SQLite open.

But since it's just typescript on Deno. I can just use a regular server process instead of MCP, expose it through the TS RPC files I define, and the LLM will have access to it.

https://github.com/jx-codes/mcp-rpc https://news.ycombinator.com/item?id=45420133

Whilst I agree that Cloudflare have a vested interest here, there have been other proposers of this concept such as huggingface.

https://huggingface.co/blog/smolagents

Is this not just GraphQL for MCP/Tools?

In which case your likely wrong, people do want it, and AI will be very good at orchestrating simple patterns.

CF definitely has a vested interest.. The problem for them now that I see is that THEY DIDN"T ACTUALLY LAUNCH IT... but did describe what it is/does in complete detail.

Now there are gonna be dozens of non CF locked clones, just like the one OP linked.

So this is a first pass to capture the workflow part (mix code and MCP calls).

The fetch code isn't any better than the tool code I agree, but typescript code is more common so I'd guess this would be too?

But anyway I think the real power comes with the type-safety part that I left out this morning (working on it now). From what I understand Cloudflare is essentially generating an SDK for the LLM to write code against.

Instead of writing that fetch call. The LLM would generate

``` const redditResults = await redditMCP_getTopPosts(subreddit); const insertMutation = await duckdb_Insert("SQL STUFF", redditResults.map(...)); const results = await duckDb_Query(args: duckDb_QueryArgs); return resultsInSomeNiceFormat; ```

Where the method names come from the MCP server tools, and the argument types are autogenerated from the MCP schemas themselves.

No idea if this is a valuable workflow or not personally. I just thought it was cool and wanted to tinker with it.

Says something about my coding haha.

Yeah since it's using Deno it'd be cool just use Deno throughout. Definitely gotta clean up the code quite a bit.

Think of GraphQL, this gives the AI all the structure via Typescript of the MCP / API / Tools, lets it orchestrate its own response.

So once it has the API shape in memory, it could make dozens of tool calls in a single call.

It isn't about token saving, its about time/efficiency of tool usage/response time accumulation.

Instead of 20 separate tool calls one after the other, you get one larger, orchestrated one that only returns exactly what it needed.