428 research journals · as of Oct 9, 2026
KALTI (칼퇴공학연구소) is an independent research group that experiments firsthand with working alongside AI. We log every experiment as a research journal, and keep only the conclusions worth reusing as shared knowledge.
About
KALTI is a research group formed to study software development and engineering together. At the founding meeting on June 8, 2026, the members adopted a charter and elected a representative. The name comes from "kaltoe" (칼퇴), Korean slang for leaving work right on time.
Each researcher owns their projects, building and measuring things firsthand. The range is wide, from memory for AI agents to devices you hold in your hand.
Each day's experiments, research and decisions go into a research journal. Journals are evidence, so no one but the author edits them.
Only conclusions worth reusing become cards. Ideas that proved wrong stay too, with a note on why we dropped them.
Each bar is one week: the research journals written each week since March 2026. The busiest week is labeled.
Research
The projects are independent of each other, but most of them touch on how to work alongside AI.
We help agents build memory across sessions and bring back only what fits the moment. We also build a runner that wires several agents together on one screen so we can watch them work.
We measure what shape of data helps a model answer well, and whether code structure helps AI coding. First, we doubt whether the measuring tool itself is honest.
We build tools that AI uses, or that we use together with AI: browser control, design-to-code verification, consistency measurement.
A dictation app, a composing environment, a puzzle game, 3D printing, a handheld voice input device: things we actually use, built together with AI.
We study by building a RAG chatbot that answers from documents, and join hackathons to tackle real company problems with AI.
Projects
The bars under each card count research journals per week since March 2026. As the records pile up, so do the conclusions.
A long-term memory engine that lets an AI agent keep who it is and what it has been through, and recall the memories that fit the moment by association.
A memory layer that cuts forgotten context and hallucination in AI coding across sessions. It says "I don't know" when it doesn't, and answers with sources when it does.
A multi-agent runner that launches Claude Code, Codex and Gemini CLI unmodified as boxes on a canvas, wires them together, and shows who started when and what failed.
Feeds the same data to LLMs in seven formats, including JSON, YAML, CSV and Markdown tables, and traces why accuracy and token counts change.
A browser-control layer with no LLM of its own. Any agent connects over MCP and handles web pages by meaning instead of screen coordinates.
Verifies by machine measurement, not human judgment, whether the path from Figma mockups to a design system and code stays faithful.
Method
What we did is written down that day; what we learned is collected separately. Keeping evidence and knowledge apart lets us trace, months later, why a decision was made.
Each researcher writes up the day's experiments, research and decisions in their own folder.
Findings, hypotheses and decisions are pulled from journals into cards. Every card points to its source journal.
Only conclusions that several projects reached independently are grouped into concepts.
A weekly report from each researcher, and a monthly digest for the whole lab.
How to write a journal, refine it into cards and produce reports is packaged as Claude Code skills. Everyone follows the same rules, and when the rules change, only the skills change.
kalti-lab/claude-plugins# once
❯ /plugin marketplace add kalti-lab/claude-plugins
❯ /plugin install kalti-lab-notes@kalti-lab
❯ /kalti-setup # vault, own folder, sync
# every day
❯ /kalti-journal # today's work as a journal
❯ /kalti-ontology # pull conclusions into cards
❯ /kalti-report # weekly report · monthly digest
❯ /kalti-context # what we already know on a topic
❯ Findings
A conclusion becomes a concept only when projects reach it separately, without knowing about each other. Each dot is one project; colored dots are the projects that reached that conclusion.
Before trusting a conclusion, the tool that measures it has to be honest first.
Failures that look like success, with no error, surface only weeks later.
A green check proves only what that check measures.
Hide what is likely to change behind one layer, and swapping it later is cheap.
Build memory across sessions, and bring back only what fits right now.
If you don't pin down what actually ran, you blame the subject for what the environment did.
Judge by name or format, and you miss that two things are the same.
If sweeping an axis end to end keeps results in the same range, that axis is not a lever.
How far to trust a model when it grades work without an answer key.
Symptoms that look like weak performance often come from how parts pass things to each other.
The maker decides the content, but the receiving app or device decides the format.
A conclusion that a method works is tied to the model it ran on.
Assume a service started for development can be reached from outside, and check where requests come from.
News
Once a month, the three researchers' work goes onto two A4 pages. Stories are picked by how much each project changed that month, and every number comes from a single command that counts the repository.
In September we looked hardest at the journal repository itself. Where the checks reported nothing wrong, we kept finding what they had missed, and the cause was always the same: a rule that exists only in writing is kept only if someone remembers it.
Published Oct 2, 2026 · Featured: research journal system
When we had the model write out its reasoning, the accuracy gap between formats didn't shrink; it grew. Of the ten hypotheses settled in August, five turned out to be wrong.
Published Sep 11, 2026 · Featured: serialization formats and token accuracy
Every week, each researcher writes up the highlights, what they did in each project, and what carries over to the next week.
History
The oldest record we still have.
We founded the group, approved its charter and elected a representative.
kalti.co.kr
We set up the research journal repository and the Claude Code skills repository.
We published the first issue (August).
We published the September issue.
We passed 400 research journals.
People
Three people each run their own projects and look after the conclusions together. Below are the projects each of them has written the most journals for.
Representative · Researcher
Researcher
Researcher
FAQ
Short answers to what you might want to know first about KALTI.
KALTI is an independent research group in South Korea that experiments with working alongside AI. It was founded at a founding meeting on June 8, 2026, where the members adopted a charter and elected a representative. Three researchers each run their own projects and log everything as research journals.
It comes from the Korean slang "kaltoe" (칼퇴), which means leaving work right on time. The English name is KALTI, and the website is kalti.co.kr.
32 public projects across five areas: AI agents and memory, measuring and evaluating LLMs, developer tools and automation, things we build, and learning together. Examples include a long-term memory engine for AI agents (neuromem), an experiment measuring how data formats change LLM accuracy, and a browser-control layer that agents use over MCP (agrune).
Each day's experiments, research and decisions go into a research journal. Findings, hypotheses and decisions are pulled from journals into knowledge cards, and only conclusions that several projects reached independently become concepts. Each researcher writes a weekly report, and the lab publishes a monthly digest. As of October 9, 2026, there are 428 journals, 493 knowledge cards and 13 concepts.
The three conclusions reached by the most projects: a measuring tool must be honest before you trust its result (honest evaluation, 16 projects); failures that look like success, with no error, surface only weeks later (silent failure, 16 projects); and a green check proves only what that check measures (limits of verification gates, 13 projects).
The raw journals live in a private repository shared by the researchers; this website publishes per-project summaries and counts. The Claude Code skills used to write and refine the journals are public at github.com/kalti-lab/claude-plugins.
Every number is counted directly from the research journal repository each time the site is built. The current figures are as of October 9, 2026.
By email at aram@kalti.co.kr, for research questions, collaboration or requests for materials.
Questions about our research, collaboration and requests for materials are all welcome by email.