Since the core idea of the app I'm creating is that it can be modified by users (with the help of the app's own AI agents), the weekend implementation was: (generated by AI) 😆
When working with AI coding agents, one of the biggest risks is context blindness. An agent modifies a function without knowing what breaks downstream across routers, templates, and state stores.In Kith OS, we solved this by implementing a native, local-first Code Graph and Blast Radius Engine.Instead of relying on heavy background language servers or external SaaS indexers, the engine uses Python's standard AST and our existing knowledge graph ontology to parse the entire codebase into an in-memory directed graph. In under 50 milliseconds, it maps nearly 11,000 relationships connecting Python functions, FastAPI routes, pytest cases, and frontend Alpine.js actions.We packaged this engine as a native agent tool. Before the AI agent writes or refactors any code, it queries the target symbol. It instantly receives a deterministic report listing every direct caller, exposed HTTP endpoint, UI touchpoint, and affected test file.We also introduced architectural hub analysis. By calculating graph centrality across incoming callers, outgoing dependencies, and test coverage, the system automatically highlights its most critical foundational primitives.By turning architectural governance into a fast, local graph query, AI agents no longer guess the impact of their changes. They operate with complete structural awareness.

Finally (I think) I managed to arrive at a simple and efficient graph system with nodes and edges, 100% contained in .md files (front matter) + an automatic system for approving terms outside the closed vocabulary (quarantine), among other things. 😁

My experiments creating my own AI "harness" app...😅
---The Mystery Revealed: How did LLM get everything right?LLM followed the instruction with surgical precision:
It read the preview of call 1 and called:
readpipe(pipeid="pipe://2026090615541800101listvaultdirectory.json", extract_field="files", compact=true)The "Friendly Fire" of resolvepipeargs:
Our pipe interceptor on the server saw the pipe:// prefix in the pipe_id argument and thought:
"Whoa! A pipe! Let me replace it with the actual data before running the tool!"
And it replaced "pipe_id" with the Python dictionary containing all 14 raw files!The Comedy of Error [EXPIRED_PIPE]:
The readpipe tool received a dictionary in the pipeid parameter, tried to read the dictionary as if it were a URI, didn't find it, and spat out the error:[EXPIREDPIPE] Artifact for '{'directory': 'knowledge', 'totalfolders': 4, 'total_files': 14, 'files': [... 14 files ...]}' is no longer available...The Cleverness of the LLM:
The LLM Gemma 4B read the error message, saw that all 14 files and 4 folders were printed within the error text, extracted all the names from there, and delivered the perfect final answer! 😂---PS.: It might seem silly to divide a simple process into 2 steps, but since this is a test, the amount of information limiting the single step is set to an unrealistic (very low) limit. In fact, this process is designed so that the LLM, instead of loading information into context that will later be filtered, loads the information into RAM and applies the filter (tool call) directly to what is loaded in RAM (which is very fast), without polluting its context with irrelevant information, saving many tokens. That is, it can perform several deterministic filters 100% in RAM and after X steps receive only the relevant information (all with a fallback of files on disk, in case the session is resumed later with clean RAM).

The world of AIs is sometimes a bit silly. In my "little program," I decided to store all conversations with AI agents in markdown format with certain specific formatting, but since there's a file sanitization process, some "html" terms are suppressed, like <think> , so I challenge the AI to write exactly <think> and it finds the challenge easy and actually generates the token, but the file is sanitized, when I ask it to reread what it wrote it starts to glitch and tries again...🤣🤣🤣

I found out that it is possible to use the crypto wallet signature algorithm to create a deterministically secret, i.e. you can encrypt local files that can be opened only with your wallet signature.... or something... 😆 💡

I didn't expect building a disk file manager to be so complicated... but the learning experience is great, even if I deleted all the "user's" files in the process. 🤣😬
---fix(files): decouple move modal, fix conflict replacement, and enforce root directory immunity* Extract Move and Move Conflict modals from context-menu into dedicated moveModal component (static/move-modal.js + templates/components/move_modal.html)* Enforce strict root immunity (assertnotprotecteddirectory) in files.py to block deletion or renaming of knowledge, .user, .app, .agents, and workspace root* Fix query string parameter formatting in explorer-api.js (deleteFile and deleteFolder)* Fix target path construction during move conflict replacement to strictly delete the conflicting item instead of the destination folder* Slim down context-menu.js to a lightweight dropdown popover orchestrator* Document root directory immunity and decoupled modal architecture in frontend-state-ui.md, filesystem.md, and gotchas-and-pitfalls.md

Another step forward: a search system based on real-time database indexing that supports advanced filters—including semantic ones—and allows for user-defined vocabulary. And, like every other tool in the app, it is fully available for use by AI agents.
In fact, even resizing or hiding a panel is an action an AI agent can perform, though that is mostly for cosmetic presentation purposes 😁 or perhaps for accessibility needs 🤔

Started as an MCP server.
Evolved into a LangGraph app.Now I can barely get back to building the AI agents because I keep falling in love with perfecting the OS foundation...Before an agent can think, the system must breathe: deterministic UUIDs, ontology validation, universal tool engines.A pleasantly challenging and endless loop of solidifying the bedrock. :-)

While developing my project, I realized something: in a world with integrated AI, software needs to be AI-friendly. I decided to isolate the entire text/language layer so that if a user says "I speak Portuguese," a limited local AI can likely deliver the entire interface in the chosen language in under a minute. Or even handle preferences like "I don't like the term 'SAVE'—I prefer 'RECORD'—and I want the 'X' icon for button 'Y'"; your interface quickly adapts to exactly how you want it. The same applies to the UI theme: "I want a green theme"... and—voilà!—it's done.

First quick quality check and, yes, the code was rubbish...heheheh. Less crap now 😅 I'm a conscious vibe-coder 🤣---refactor(core): optimize filesystem I/O, security boundaries, and plugin execution* Refactor security.py to pure Python with SafePathError and Security-First boundary checks before disk touch* Register global SafePathError exception handler in main.py returning HTTP 403* Refactor filesystem.py to use os.scandir kernel enumeration and prune runtime noise (.venv, .git)* Add fast-path string check in find_backlinks before executing regex parsers* Support compound file extensions (.tar.gz, .d.ts) and 2-second mtime stat throttling in file_types.py* Make ToolsRegistry.execute_tool thread-safe with parameter binding and async def run() support* Add signature-based keyword argument filtering against LLM parameter hallucinations* Optimize config.py path resolution and convert ALLOWED_TAGS to immutable frozenset* Update backend API, tools, and gotchas documentation