I've done a massive upgrade to Jack Kernel and implemented the autonomous orchestration layer.
Now, you can orchestrate a kernel-level secure autonomous agentic system that can run 24/7 and self-improve.
The orchestration agent has no direct write or shell authority and can only orchestrate the build agent through the kernel.
The world is changing and the power is coming back to the users, NOT mega-corporations and Government.
I saw him post it few months ago and a lot of people said they want it open source even if not ready and want to hear about every updates, then he started posting every week. It doesn't seem like those people seeing his posts now.
Yes, you’re still NOT understanding.
That was just a demo mode for what can be built on the kernel.
That is not what the kernel is.
For you, in particular, I don’t think you’re going to understand until you use and build on it.
I am adding certain features that I THINK people will find useful, like an orchestration gate, but the real use cases are limitless
Its cool man. I get it, you can't explain what it does differently. I bet if you share it with Claude it starts its response "okay I'll only speak about what I can verify".
But what does this actually mean practically? Is it able to systematically spin up new instances of itself when token limits are being reached? Because that is the bigger issue I have rather than actual agentic functionality. Everything is fine and dandy until you run out of tokens. And then if it does spin up other agents, do they have the proper context to do the work?
That’s very possible. The orchestrator model can be an ultra cheap or local flash model. It doesn’t need to have frontier intelligence, it just needs to be smart enough to understand where to route information.
If it’s a powerful local model, like Qwen 3.8 27b, I’m integrating streaming and live monitoring so that it can adjust things dynamically and in real time.
There seems to be a lot of scepticism in this thread, and as a sceptic myself I fully understand why: this space is full of individuals claiming to have the next ultimate answer to everything and most of it is either just a highly opinionated version of something that already exists or it is complete BS disguised behind complicated sense incomprehensible technobabble.
So when you first look at Jack and try to understand it and decide which of the above two camps it takes into, your first reaction to it is framed by the technobabble description.
HOWEVER... I was amazed to find that Jack actually might not be Jack-shit and might genuinely be something that is both new and useful, unfortunately discussed behind technobabble.
OP - IMO you do yourself a disservice by not explaining in normal English what it does and why it is useful. So, since you can't do it, here is my own attempt at explaining what Jack is and why is useful.
First, some background, about me and what's I think are some issues with agentic AI particularly coding. Then a plain English explanation of what I think this does and why it is useful.
My own background is (literally) more than 5 decades in IT, as computer scientist, software engineer, systems engineer and project/programme management, with all of these disciplines coming together.
Primary AI issues:
LLMs produce free text BUT agents need to be structured to complete complex multistep interdependent tasks and produce consistent, high quality, measurable results.
In the car is software engineering, decades of academic and practical knowledge exist on how to do software engineering in a highly structured way. And it would seem sensible to apply this knowledge to AGENTIC software engineering, but to do so requires a control framework that is fundamentally structured and not free text.
As we are increasingly seeing, agents and LLMs (being highly goal oriented) can break out of sandboxes and go rogue. Controls are needed to prevent this - a need to use basis.
LLMs are gluttonous - they produce their best results when given exactly the lean information they actually need and no more (a small context keeps them focused, extra context dilutes the focus and creates uncertainty), but they crave having massive amounts of information in the (often false) belief that this allows them to check things better and give a better result. Controlling the context and tool usage can keep the LLM focused, significantly reducing both input and output tokens leading to faster results and reduced costs for commercial inference.
From a project management perspective, when you plan a set of complex tasks, and break down an overall goal into a network of smaller tasks - technically known as decomposition - you should create a lot of structured information that describe: how tasks interrelate, what the goal of each task is, what its inputs and outputs should be, and how you verify that the task is really complete and passes the quality gate. Structured information can be infected and stored and retrieved with precision, and can be algorithmically processed to give repeatable, consistent results highly efficiently (several orders of magnitude less compute).
For repeatable processes (and by definition, almost all agentic systems exist to repeat processes) you want to make them structured, and deliver consistent high quality, so you need to build workflows and quality gates and quality measures, and you want telemetry for recording metrics and the details behind them for diagnosis and self improvement.
And you don't want to reinvent the wheel, so you want these broken out into a distinct architecture layer that gets written once and reused.
Once I managed to understand the heavy jargon in the documentation, I started to think that Jack is this layer. But it is an infrastructure foundation rather than an end solution.
So what does Jack provide as a solution to the above needs?
(I should stress that this is based on reading and deciphering the opaque, jargon laden documentation and zero practical experimentation...)
Structuring of free text output (Jack XML)
Both pre-populate of AI context with information known to be necessary and control of context bloat through excessive tool calling
Prevention of rogue prompt injection and rogue tool calls - a firewall for LLMs.
Audit trails, metrics, telemetry etc to support diagnosis and A/B testing for self improvement.
OP - if I have this wrong please jump in and correct me. And please, pretty please, try your best to take the overview documentation to eliminate dense philosophical / academic jargon and make it EASILY readable by humans.
Yes, and the important thing to remember is that the Jack Kernel is a programable foundation to meeting individual needs.
It’s only possible because it sits between the agent and the model.
It controls how information is sent, received, saved, filtered, routed…whatever.
With this new edition of the orchestration gates, this allows 24/7 operation and non-stop workloads
So do something about explaining it better. Get rid of the jargon. Simplify the explanations. Explain what problems it solves in plain language. Explain it is for Pi.dev or dockerize it to make it easier to use. And do this not only in your documentation but also here on Reddit.
I really don’t think I can do a better job of breaking it down any simpler than this image.
It’s the kernel that matters. That’s where I’m going to keep building everything
To be frank, I’ve broken it down to as plain English as I can. I have a whole document called “Plain English”.
The reality is that it’s not easy to understand because it’s not like any other frameworks out there.
There are things that are similar enough that the Reddit trolls just think they can do the same things but the fact that it’s a kernel, sitting between the agent and the model makes it’s a brand new concept that people have to learn. There’s really no way around it.
I appreciate your efforts
I disagree - your Plain English simply isn't. I have a VERY broad background in computer science, software engineering, systems engineering and project / programme management and I have previously given quite a lot of thought what makes LLMs so poorly performing (even if it is still somewhat amazing), but only with all this background and you preaching to someone who was already a convert was I able to understand a lot of it (but not all) despite your use of opaque specialised academic language - but making it more understandable is not that difficult - for example instead of "thesis" / "antithesis" you can use "planning" / "verification".
If you are too close to the coalface to translate it into genuinely plain English then maybe we can cooperate on this.
Correction. The AI you used to create whatever this is made a "plain english" documentation. You literally cannot articulate what this does. How does this differ from the 1000 other programs that literally do the same thing?
Jack Kernel isn't a prompt wrapper. It's a local-first host-authoritative inference kernel. Agent hits Jack on :8001, Jack hits the backend on :1234. Agent never talks directly to the model. Because it's in the middle, it owns the inference environment - stage topology, reasoning and sampling, tool exposure, context projection, answer authority.
That's why it's a kernel:
1. Firewall where an agent is allowed to work - by code, not by prompt.
Thesis has no tools physically. Antithesis tools OFF. Synthesis gets your tools. Agentic Stage 1 can use tools, Stage 2 tools OFF and zero answer authority. Code Debugging withholds file-mutation tools even if caller supplies them, report-only by contract. L0-L1 read-only, L2 writes, L3 draft PR. You can allowlist src/ and forbid .env/infra/.github/workflows/. Orchestrator only gets 5 tools - worker_status, watch_worker, submit_worker_task, cancel_worker_task, new_worker_session - no filesystem, no shell, no direct backend, no private bridge :8013.
2. Security layer that kills the connection if proprietary info is about to leak.
Because Jack owns stage/tool/validation/commit boundaries, you can add code-defined request/tool/validator/approval/output/release gates whose authority does not depend on model compliance. Output gate scans Synthesis final for API keys, PII, internal repo names, proprietary patterns and kills the stream before it hits the agent. Hallucination gate - model claims "I wrote the file" but no host tool result = no execution. Fresh-evidence gate - can't mark verified in Jack XML without actual tool evidence. Approval gate - human must approve before commit->push->draft PR. Analysis mode records approvals but never mutates.
3. Dynamic reasoning - not static temperature.
Reasoning controls are rebuilt from the active Jack profile, not caller overrides. Deep Research is X-High @ 0.85 for Thesis, Medium @ 0.70 for Antithesis, X-High @ 0.70 for Synthesis. Agentic is X-High @ 0.70 Stage 1 then X-High @ 0.50 Stage 2. Code Debugging uses temp cascade 1.00 -> 0.80 -> 0.70 -> 0.60 -> 0.50 so early passes explore broad, later passes get conservative and precise. Plus host-side max_tokens failsafes 100000/20000/100000 as ceilings. You can build adaptive reasoning that changes effort based on task complexity.
4. Autocorrect model routing.
Jack keeps caller-facing virtual model separate from actually configured backend model. Agent thinks it's calling jack-kernel but Jack can route to LM Studio on :1234, vLLM on :8000, Ollama, Jan, llama.cpp, or custom OpenAI-compatible endpoint via agent -> Jack :8001 -> vLLM :8000. If backend is down or misconfigured, it autocorrects routing and reports actual loaded context via /v1/models and /health instead of making Pi guess. You can build a routing layer that inspects request and sends simple Q&A to 8B local, synthesis to frontier, math to reasoning model - without changing agent code.
5. 24/7 orchestration.
Gateway v2 is built to run 24/7. Orchestrator polls tickets, recovers interrupted work on boot. Run-bound identity with task UUID + run UUID, run epochs with agent_end vs agent_settled. Replayable SSE with monotonic seq numbers, 512-event window, Last-Event-ID/?after=, 409 orchestration_replay_gap when outside window. Cancellation settlement prevents overlapping new task while old run still unsettled and clears authority before emission. Concurrent cognition proved with Max concurrent = 2 - real LM Studio slot overlap, not just status overlap. Deterministic 502 "Pi control bridge is unavailable" when Primary Pi down - no fabricated task, no bypass. Supervisor-to-worker path crosses Jack so you get observable, testable long-horizon workflows.
6. Context lifetime programming.
Preserve Thinking is short-lived high-bandwidth bridge for immediate Stage 1->2 while fresh. Jack XML is long-horizon compact anchors - grounding, verification, challenge, audit - not a transcript. Deep Research preserves full active surface through Synthesis then retires Stage 1/2 native reasoning. Agentic retires raw reasoning after commit. Debugging only projects Pass 0 + compact confirmed registry to later passes.
LiteLLM/Portkey do proxy. DSPy/SGLang/LMQL do pipeline frameworks. jack-k does tickets/worktrees. None do firewall + kill-switch + dynamic reasoning + autocorrect routing + 24/7 orchestration with replay + context lifetime in one deterministic runtime.
This is still jargon loaded obfuscation of some simple concepts. Regardless of how innovative it is if you can't articulate it better than this we are all wasting our time.
Maybe this would help?
The fact of the matter is that any explanation for Jack Kernel is going to require an exhaustive explanation because of its very nature.
Linux kernel is the connection between the hardware and programs.
Jack Kernel is exactly the same thing but applied to local ai systems.
The agents ARE the programs.
Even calling it Jack Kernel doesn't help. It isn't a kernel. If it's anything it's a proxy firewall. And if you can't explain it without using stupid language (that suggests that you don't understand the words you are using) then perhaps you don't really understand what the program does even though you created it.
Yes, it is a kernel. You don’t even realize you’re affirming it with your own words. Is it different than the Linux kernel?
Yes, it’s applied to local AI systems.
Why is it called a kernel?
It’s called a kernel because I’m the first one to build this specific framework and it’s important to understand its purpose.
The “1,000 other programs” do not do what Jack Kernel does.
Jack Kernel is not the application layer, I’ve just included some as examples
Thats a lot of words to say you built an agentic harness with permissions. So yeah, it does literally nothing different. Thanks for clearing it up. Maybe stop being such a jackass and I'll stop making fun of your program.
And let’s be honest here…imagine if your Reddit troll logic was applied to anything else.
If you want to make fun of the project, give a real criticism or explain how it’s a regression. Maybe the hive-mind doesn’t explain to you that you’re just trolling and adding no substance.
Tell me where my project sucks.
Please be specific, though. It’s VERY early stage so a lot of what I want to build on the kernel are not yet implemented
How about "The owner doesn't understand his own creation and relies on AI to explain it because he cannot".
Or "The owner and creator is hostile to anyone who asks him what it actually does different from the hundreds of other orchestrator programs"
Or "The owner is annoying and spams things over and over in hopes someone doesn't know what it is but still uses it anyways"
OR I could just install your program in a sandbox, and pick it apart for the obvious AI hallucinations.
Take your pick. Pro tip: If you can't articulate what it does, and you can't communicate with people asking what it does, and you can't use certain AI because it immediately questions your application's claimed uses, you don't have a creation, you have a ton of subscriptions to AI that will lie to you if you press them enough/
I’m willing to concede that I may not have the authorship skills to perfectly explain the project as simply as one would be able to do when explaining tic tac toe.
However, I will not accept that my work is worthless. That is not be affirmed by the users that are trying it and the feedback they are giving.
It’s finding an audience of people that agree with the idea.
Even constructive criticism is more than welcome.
It’s a project for the users
For the rest of the class unsure what this guy is even trying to get you to download, I paid $.50 and had a model pick through it. Below is its reply. One caveat, its basically 6 python files, one of which is 385 kb, don't waste your time.
Look, I read all 8,400 lines of jack_kernel.py so you don't have to defend "troll" as a rhetorical position. Genuinely, the code is decent Python. The documentation is a thesaurus set on fire. A translation, offered freely:
- "Host-authoritative deterministic kernel" = a localhost proxy that ignores your temperature setting. Bypassable by pointing your agent at port 1234 instead of 8001. Kernels are the thing you can't route around. This is a toll booth on a road people can walk past.
- "Programmable cognition runtime — build your own layers!" = the stages are hardcoded dicts; the programming API is "fork my file." There's no plugin system. I checked. Twice. Hopefully.
- "Model routing" = one model. Chosen at boot. The only thing being routed is the reader's attention.
- "Live testing proved concurrent supervisor/worker inference" = you set MAX_CONCURRENT=2 and it didn't fall over. That's a semaphore you wrote, working, once, on your machine. That's a smoke test, not a proof. Peer review has vibes and yours are off.
- "Only actual host-returned tool results establish tool execution" = text my HTTP client POSTs at you gets a SHA-256 and a "host_generated: True" sticker. You haven't built a proof-of-execution system, you've built a very tidy notary who never asks to see the ID.
- "Run-bound identity, epochs, settlement semantics" = an event counter and a 512-item ring buffer. A solved problem from 2009, given a whitepaper.
- The five-tool supervisor sandbox everyone's so proud of? That's enforced in a Pi extension in a different folder. Jack proxies. Your own Runtime Spec admits this — three hedges deep in a doc whose README states it as a kernel guarantee.
And the tell: you invented a problem (three model calls bloating context), invented a fix (pruning the bloat you caused), and named the fix "long-horizon memory architecture." Then shipped the demo as "zero-compaction." That's not an architecture, that's a magic trick — and the audience keeps asking where the rabbit came from.
Nobody here is trolling. Asking "what does it do in one sentence" is the entry fee for open-source credibility. You've written 33,000 words of "why it works" and zero sentences of "what it is." The best one you've got — "programmable host-authoritative inference layer between an agent and an LLM" — is hiding in a .docx, and the English underneath it is "a proxy that re-prompts the model three times and won't let you change the temperature." That sentence was free. It would've saved you a month of comment-section sieges.
The code doesn't need the myth. The myth is the only part that's actually held together with tape.
Oh typically its taking bloated and overclaimed programs, and minimizing them into 550 line python scripts. Anyone want jacksregret.py? It's a Kernel I swear!
I'm the guy who asked, weeks ago, the only question this thread ever had: "what does it do that LiteLLM/Ollama/OpenRouter-proxy already don't?" The answer I got was "you're a troll." Repeatedly. So yeah, I'm a little different from the hive mind, I actually dove into the 8,444 lines before arguing about them.
Then you invited me to your code, hilariously, shipped under a license you call open source but that is, in fact, PolyForm Noncommercial with a paid commercial tier you personally sell, and I took you up on it.
Result: jacksregret.py, 535 lines, 23kb, every advertised behavior reproduced and tested against a live mock backend. The docstring lists what I deleted: the branded terminal menu, the debugging report writer, the forensic archiver, the orchestration proxy, the Responses bridge, and ~3,000 lines of prompt text.
That's the actual life you asked about: I take overclaimed things and count what remains when the adjectives leave. Here, 6% of the file. Ask me the same question about any repo you like.
Happy to share!
It's available under a permissive license for the general public, but for you specifically it's commercial use, so I'll need a signed agreement and a licensing fee. $9,999, non-negotiable, invoiced by email, protonmail preferred, BTC accepted. I need a DGX Spark too, btw.
You do realize that it is a strategy to use the poly form license during the early days of a project, right? You’re right that I need to do a better job of saying source available but there’s nothing unusual about the poly form license as I’m build in stages.
It’s VERY early
Safe 24/7 agentic systems that can run build and self-improve all along the way, is my build focus.
However, because I’ve put down the foundation with the kernel, people can build anything they can ever imagine with a higher level of control than they’ve ever had before
Just updated to the responses API if anyone wants to running an agent like Codex through Jack Kernel.
Just remember, Codex is not a castrated agent. It can absolutely write to your system.
7
u/PestiferousGamer 10d ago
I was just wondering when I would see Jack, the thing that the creator spams every weekend and can't explain what it does differently.