Essentially you give the agent a way to run code that calls MCP servers, then it can use them like any other API.

Nowadays small bash/bun scripts and an MCP gateway proxy gets me the same exact thing.

So yeah at some level you do have to build out your own custom functionality.

Where it comes in handy has mostly been in distribution honestly. There's something very "open apis web era" about MCP servers where because every company rushed to publish them, you can write a lot of creative integrations a bit more easily.

I don't choose to think random thoughts they appear.

Which is different than thoughts I consciously choose to think and engage with.

From my subjective perspective it is an input into my field of awareness.

Temperature changes, visual stimulus, auditory stimulus, body cues, random thoughts firing, etc.. Those are all going on all the time.

If people are letting the LLM decide how the code will be written then I think they're using them wrong and yes 100% they won't understand the code as well as if they had written it by hand.

LLMs are just good pattern matchers and can spit out text faster than humans, so that's what I use them for mostly.

Anything that requires actual brainpower and thinking is still my domain. I just type a lot less than I used to.

Installation is a one-liner curl script (see README)

Instead of configuring your AI with dozens of individual tools, drop a ts file in a directory, and give the LLM one capability: execute TypeScript with lootbox.

  // my-functions/example.ts
  export async function analyzeText(args: { text: string }) {
    return {
      length: args.text.length,
      words: args.text.split(' ').length,
      uppercase: args.text.toUpperCase()
    };
  }

  # Run server with your functions + MCP servers
  lootbox-runtime --rpc-dir ./my-functions --mcp-config mcp.json

  # AI writes code that uses both:
  lootbox -e '
    const file = await tools.mcp_github.read_file({repo: "x/y", path: "README.md"});
    const analysis = await tools.myapp.analyzeText({text: file});
    console.log(analysis);
  '

AI gets full type definitions for everything. Writes code that chains operations together instead of doing sequential tool calls.

LLM scripts are executed in a Deno Sandbox with only net access. RPC files get full access.

Based on Cloudflare's Code Mode research but completely local.

Check the README for some sample rpc files, a workflow, and a much deeper dive on how it all works.

Typically Claude Code will use

  lootbox --help
  lootbox --namespaces
  lootbox --types kv,sqlite // returns the types from the typed client

Lootbox can also run files so you can tell Claude to save the script as a file and later just run it with

  lootbox path/to/script.ts

https://github.com/jx-codes/lootbox

Original Take: https://github.com/jx-codes/codemode-mcp

Comments URL: https://news.ycombinator.com/item?id=45467807

Points: 2

# Comments: 0

OR

"No clue. Let me do some digging first."

Have literally never had this come up in my ten years working in tech. Big picture advice? Don't overthink small things like this.

You'll just make yourself feel and act more unconfident not less.

If Bun had a sandbox I'd use it.

Deno isn't my cup of tea (although I appreciate it more after building with it the past two days). My impression is that it is lightweight, you can deploy it easily to edge workers and it's built on rust so you can actually use it to build your own runtime with only the parts you want. (I was working on this for a game when I ran into the CF blog article).

Node/npm is the grandpa, can't go wrong but it doesn't run typescript by default and you'll lose cool points.

pnpm is cool don't really know what makes it different these days except it has a nice cache by default so you get faster installs, and you can do monorepos semi-easily. It's my default if I can't use Bun.

Bun is newer and my current favorite. You can compile to single executable, have access to most of the npm ecosystem (some packages still have minor issues), you have a built in sqlite db so it's great for prototyping, and some other niceties.

There's a lot more to it but that's the important differences I run into in my day to day.

I always gravitate to Bun when I can, it feels light and fresh.

Also I'm definitely going to try out your project this weekend, I've been looking for something like this to put together a free college info aggregation site from the college's public sites themselves, like financial aid dates, on campus programs, etc..

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

For those of you interested, I wrote out and built an more RPC typescript centric approach to avoid using other MCP servers at all. Would appreciate some thoughts!

https://news.ycombinator.com/item?id=45420133

Sounds very cool.

I actually didn't end up implementing the memory. Instead I went down the 'get rid of the MCP' route. https://github.com/jx-codes/mcp-rpc

Basically instead of mcp servers you write typescript files that are parsed to generate a typed client, these are executed in one deno sandbox, and the LLM code gets that typed client and its scripts are run in a sandbox with only net allowed.

Been having some fun testing it out today.

If you have time to take a look I would be curious to hear what you think.

https://github.com/jx-codes/mcp-rpc

Instead of making MCP tool calls, LLMs write TypeScript against auto-generated RPC clients. // Follow the readme instructions and run the RPC server

  mcp-rpc-runtime -r ./test-rpc -p 8080

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

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.

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.

HN Discussion: https://news.ycombinator.com/item?id=45399204 https://news.ycombinator.com/item?id=45386248

Deno provides a great sandbox environment for Typescript code execution because of its permissions system which made it easy to spin up code that only has access to fetch and network calls.

Stick an MCP proxy on top of that and you've got "CodeMode" (code intermixed with MCP tool calls) for more advanced workflow orchestration.

https://github.com/jx-codes/codemode-mcp

There's a lot of things that can be improved here. Like a virtual file system for the agent to actually build up its solution instead of being forced to one shot the solution but the bones are there.

Comments URL: https://news.ycombinator.com/item?id=45405584

Points: 87

# Comments: 29

The way I see it these tools allow me to use my actual brainpower mostly on those problems. Because all the rote work can now be workably augmented away, I can choose which problems to actually focus on "by hand" as it were. I'd never give those problems to an LLM to solve. I might however ask it to search the web for papers or articles or what have you that have solved similar problems and go from there.

If someone is giving that up then I'd question why they're doing that.. No one is forcing them to.

It's the problem solving itself that is fun, the "layer" that it's in doesn't really make a difference to me.

I care deeply about the code quality that goes into the projects I work on because I end up having to maintain it, review it, or fix it when it goes south, and honestly it just feels wrong to me to see bad code.

But literally typing out the characters that make up the code? I could care less. I've done that already. I can do it in my sleep, there's no challenge.

At this stage in my career I'm looking for ways to take the experience I have and upskill my teams using it.

I'd be crazy not to try and leverage LLMs as much as possible. That includes spending the time to write good CLAUDE.md files, set up custom agents that work with our codebase and patterns, it also includes taking the time to explain the why behind those choices to the team so they understand them, calling out bad PRs that "work" but are AI slop and teaching them how to get better results out of these things.

Idk man the profession is pretty big and creating software is still just as fun as when I was doing it character by character in notepad. I just don't care to type more than I need to when I can focus on problem solving and building.