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

**URL:** <https://discourse.julialang.org/t/ann-kaimon-jl-opening-the-gate-between-ai-agents-and-julia/135880>\
**Category:** Package Announcements\
**Tags:** repl, agents, ai, mcp\
**Created:** [February 27, 2026, 9:07am UTC](https://discourse.julialang.org/t/ann-kaimon-jl-opening-the-gate-between-ai-agents-and-julia/135880 "2026-02-27T09:07:33Z")\
**Posts on this page:** 1\
**Showing post:** 1

<div class="post-metadata">

**Author:** ![kahliburke](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/kahliburke/32/208472_2.png) [@kahliburke](https://discourse.julialang.org/u/kahliburke)\
**Post date:** [February 27, 2026, 9:07am UTC](https://discourse.julialang.org/t/ann-kaimon-jl-opening-the-gate-between-ai-agents-and-julia/135880/1 "2026-02-27T09:07:33Z")

</div>

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?

> **[GitHub - kahliburke/Kaimon.jl](https://github.com/kahliburke/Kaimon.jl)**
>
> Contribute to kahliburke/Kaimon.jl development by creating an account on GitHub.

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](https://github.com/kahliburke/Kaimon.jl)  
Docs: [https://kahliburke.github.io/Kaimon.jl/dev/](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.

---

_[View the full topic](https://discourse.julialang.org/t/ann-kaimon-jl-opening-the-gate-between-ai-agents-and-julia/135880)._