[ANN] Kaimon.jl — opening the gate between AI agents and Julia

Package Announcements
, , ,
1

The AI coding landscape is moving fast. Agents that can genuinely reason, write, and iterate on
code are here, and they’re getting dramatically better every few months. The question for us
as Julia users is: how do we connect all of that to the ecosystem we’ve built?

Kaimon (開門, “opening the gate”) is my answer to that question.

It’s an MCP server that gives AI agents — Claude Code, Cursor, VS Code Copilot, Gemini CLI —
live, stateful access to Julia sessions. Not file editing and shell commands, but a real
running REPL: persistent state, loaded packages, Revise-aware, the full thing.

When an agent has a fast, reliable way to execute code and immediately introspect the results,
something shifts. It stops being cautious and speculative — hedging with “this should work” —
and starts iterating the way a good programmer does: run it, see what happened, adjust. Type
errors, wrong shapes, unexpected outputs — all surfaced instantly, in the same session, without
round-tripping through files and shell invocations. The agent gets tight feedback loops. Token
usage drops because it’s not reasoning in the dark. Things that would take many back-and-forth
exchanges collapse into a handful of direct tool calls.

I’m also excited about the Gate. Any Julia process can connect to Kaimon and register its own
tools:

Gate.serve(tools=[Gate.GateTool(my_domain_function)])

Kaimon reflects on your function signatures and docstrings to generate the schema
automatically. Your simulation engine, your data pipeline, your custom DSL — all of it becomes
agent-callable with essentially no glue code. The agent can call your domain functions right
alongside introspecting types, running tests, stepping through the debugger, and searching your
codebase semantically. It operates on your system as it actually is.

I think the possibilities here are genuinely huge. Julia’s combination of expressiveness,
performance, and deep scientific/numerical ecosystem is exactly what you want available to an
agent that can actually use it. We’re at an early moment in figuring out what that looks like,
and I wanted to have the right infrastructure in place.

Kaimon ships with a terminal dashboard for monitoring sessions and tool activity, a setup
wizard, and MCP config generation for all the major clients. It requires Julia 1.12+.

Repo: GitHub - kahliburke/Kaimon.jl
Docs: https://kahliburke.github.io/Kaimon.jl/dev/

This is an initial release. I’d love to hear how people are using AI agents with Julia, what’s
working, what’s missing.

31 Likes
[ANN] MCPRepl.jl -- share your REPL with your AI Agent
2

There’s also

now, which seems to work well (though maybe Kaimon goes beyond that?).

1 Like
3

CC @aplavin

1 Like
4

I think it does.

5

Oops! I realized that documentation assets were causing the repo to be large when cloning it, that’s been fixed now!

6

Kaimon has a large number of tools that in theory are redundant with the julia_eval tool, I’m curious why it is helpful to have these special purpose tools.

7

Which ones? I’m mainly trying to provide the platform and a set of convenient tools. There might be some overlap still, and more optimization to go. I think many of the specialized tools are useful in practice, especially the semantic indexing/search. Also the ability to expose your own custom MCP tools for whatever your use cases are in a convenient and rapid manner.

9

Have you tried my package?

11

Ok, well I’d encourage you to try it!

As for the method of connecting to qdrant, this reflects the qdrant documentation (GitHub - qdrant/qdrant: Qdrant - High-performance, massive-scale Vector Database and Vector Search Engine for the next generation of AI. Also available in the cloud https://cloud.qdrant.io/) where the recommended installation method is via a docker container which by default runs the REST API on port 6333.

The amount of traffic over this API is relatively little and I see no real benefit to a different protocol like gRPC. That being said, I’m happy to review pull requests if you had a specific use case where this would be beneficial.

Overall, I appreciate feedback from members of the community who would like to install and utilize this platform. Let me know if it is working for you, any points of friction, bug reports, suggestion for improvements, etc.

13

Yes, I’m aware of this and that you started from MCPRepl.jl for your implementation, which at the time was the project I had been the primary author of (having forked from the original author).

I assume that the NeuroREPL.jl code (which I don’t think is available publicly) is heavily influenced or derived from MCPRepl.jl.

Kaimon.jl is my next evolution of the lessons I learned in my work on MCPRepl.jl. Try it out and see if you like it, that’s all I can say.

PS by ‘friction’ I meant friction in user experience if they wanted to try using Kaimon.

15

Good for you.

16

While, if you use LLM to write this post, maybe ask them to format it properly.

17

Sorry, not sure which post you’re referring to. I’m here writing this as a human. But more importantly, can I help you with your use of Kaimon.jl?

1 Like
18

Asking as an end user who hasn’t yet tried any AI coding agent other than Copilot in VSCode, is Kaimon something that may eventually be integrated into Julia’s VSCode extension, so that I can benefit from Kaimon’s capabilities out of the box? In other words, when such integration is done, will VSCode’s Copilot agent use the various protocols / interfaces provided by Kaimon to write and improve my code, without the need for me to study these protocol / interfaces myself?

1 Like
19

It works quite well within the VSCode environment, with Copilot for example as well as other agent plugins. It sits in between the agentic AI and the Julia session you might run using the Julia VSCode plugin (to start a REPL or run code line by line), or a Julia REPL you start in the terminal inside or outside VSCode.

It might exist separately for some time as I don’t have any connection with the Julia VSCode plugin team. But it’s designed to be pretty easy to set up and then it should just allow the AI agents to more efficiently connect to your Julia sessions.

Can I assist you in the setup in some way? Feel free to connect at kahli@kahliburke.com.

21

Hi! I have a couple of questions as I am currently using the julia-mcp (GitHub - aplavin/julia-mcp: MCP server for persistent Julia sessions — fast iteration without startup/compilation overhead) and Codex CLI. How does Kaimon compare to julia-mcp? Is Codex CLI supported (I do not see it in the documentation list, but in theory it seems that it should work)? How does using this MCP affect token usage (by the description it seems that a lot of REPL outputs will be passed to the agent, which can increase token usage)? Are some outputs silenced to avoid wasting tokens on install logs and similar things?

22

I haven’t used Julia-mcp so can’t offer you the comparison, but you should try Kaimon and see how it works for you. I gather that they are fairly different tools in several ways.

Codex is supported and can be auto configured. Really any MCP compliant agent should be usable, you just might have to set up its configuration if Kaimon doesn’t have a convenience feature for it.

The alternative to MCP is that the agent uses shell commands for everything which is more verbose, slower, uses more tokens. That’s an advantage of having the direct link to Julia. Some inputs/outputs are stripped and there are some features in place to prevent large outputs from overwhelming the agent and chewing through your context window.

I’m sure some of these thing can still be optimized further, but it works fairly well right now in my opinion.

23

I still don’t quite understand what is the difference between Kaimon.jl and julia-mcp. Is Kaimon an MCP or not? What is it most useful feature? I use julia-mcp in Antigravity a lot and it works quite well.

24

It is an MCP server. So in terms of the method by which it integrates into your AI agents and provides access to the Julia REPL, it’s similar. I haven’t used Julia-mcp so I can’t comment too much about all the details but I believe Kaimon.jl offers a different approach and more functionality which might be interesting to you. It goes beyond the basic path of providing a link to the Julia session. I see it as a platform to build on and have plans for more complex use cases such as multti agent flows and agent ↔ agent communication.

It’s built on top of Tachikoma and provides a TUI which gives you visibility into how your agents are using the session.

It provides a very simple method for your packages and apps to create and expose custom MCP tools simply by creating a Julia function and documenting it.

Try it and let me know what you think. :slight_smile:

2 Likes