Resume · Digital Garden · Email · LinkedIn · Threads

agenda.junghanacs.com — one human's daily timeline, co-lived with AI agents, served raw. What you see is today's org-agenda: Human entries, Agent stamps, Diary schedules on a single time axis. Each commit link is clickable. The data is unprocessed.

I build PKM-native harnesses for long-term human-AI collaboration: shared memory, shared timelines, and reproducible work surfaces where humans and agents can keep continuity.

Built from the ground up — forge first, then harness infrastructure, then applications. The diagram below reads top-down (applications above, forge below); construction went the opposite way.

                  ┌─ geworfen          (existence data, live)
Applications  ────┼─ openclaw           (4 bots, botlog origin)
                  ├─ homeagent-config   (Matter · sLLM · Flutter · Yocto · Android)
                  └─ legoagent-config   (Pybricks · Flutter · ESP32 toy agent)

                  ┌─ pi-shell-acp      (ACP harness runtime for pi)
Harness Infra ────┼─ andenken           (Gemini Embedding 2 · LanceDB)
                  ├─ 25 skills          (agent-config)
                  └─ CLI toolkit        (denotecli · dictcli · gitcli · lifetract · bibcli · abductcli)

                  ┌─ doomemacs-config   (agent-server · shared agenda · fence)
The Forge  ───────┼─ nixos-config        (reproducible NixOS across 4 machines)
                  ├─ openglg-config     (self-hosted server + reproducible shell)
                  └─ zotero · GLG-Mono · memex-kb · self-tracking-data

Lineage ─────────── sicm-study · durable-iot-migrate  (Logo → SICP → SICM → SDF → Clojure)

Nothing above works without the forge. NixOS keeps the environment reproducible. Emacs and Org-mode hold the shared working surface. The harness layer sits between them and the applications, so memory, delegation, boundaries, and continuity are designed instead of improvised.

pi-shell-acp is where my harness thinking becomes runtime. It connects pi to Claude Code and Codex through the official Agent Client Protocol path, while keeping pi as the harness and preserving the native backend identity of each model. No OAuth proxy, no CLI transcript scraping, no backend identity replacement.

The bridge owns session bootstrap (resume > load > new), explicit MCP injection, and entwurf orchestration — sibling sessions with identity preservation instead of fake worker subprocesses. The point is not merely "multi-agent." The point is to encode how delegation, continuity, and shared tools should behave inside a long-lived working environment.

→ pi-shell-acp

When you work with multiple agents across dozens of projects, the hardest problem is not code generation but continuity. andenken handles semantic memory — embedding, search, cross-lingual retrieval — while agent-config provides the skills, constraints, and interfaces that let agents touch a real PKM instead of a toy demo context.

Three-Layer Cross-Lingual Search:

Query: "보편 학문에 대한 문서" (Korean: "notes about universal learning")

Layer 1 — Embedding (Gemini Embedding 2, 768d)
    "보편" ≈ "universalism" in vector space → match notes tagged [paideia, universalism]

Layer 2 — dblock Graph (Denote + Emacs)
    Meta-note regex: "보편\|특수\|범용\|univers" → 22 linked notes
    (Adler, Bertalanffy, Geoffrey West, Kurzweil...)

Layer 3 — Personal Vocabulary (dictcli)
    expand("보편") → [universal, universalism, paideia, liberal arts]
    A personal ontology no WordNet contains.

Each layer catches what the others miss. Layer 1 alone failed to find "보편학" (universalism) notes. All three together recover the note ecology that a generic RAG stack would flatten.

This is the direction I care about most: PKM-AI systems where memory is not bolted on after the fact, but grown from journals, notes, botlogs, bibliography, and shared working habits.

Stack: Gemini Embedding 2 · LanceDB · dictcli query expansion · session→knowledge auto-fallback · org-aware 2-tier chunking

→ agent-config · andenken

Human and AI agents share the same org-agenda view. Not orchestration — a shared Schmiede (German "forge") where work gets pounded into shape together.

05:53  Human      기상
08:42  Agent(T)   doomemacs-config: feat: agent-shell 0.48.1 업그레이드
09:40  Agent(T)   agent-config: notify.ts 제거 — Emacs RPC 버그 해결!
09:52  Human      많은 것을 금새 해결
10:33  Agent(O)   geworfen: Human/Agent/Diary 통합 + org 링크 클릭
12:00  Human      데모 준비 완료
13:56  Human      깃허브 프로파일 업데이트 프롬프트

Four sources merge on a single time axis: Human (journal), Agent(T) (local pi), Agent(O) (cloud bots), Diary (recurring schedules). Agents read this same view via emacsclient — when an agent stamps a commit, it appears in the timeline. When the human writes "밥먹고 올게" (going to eat), agents keep working. The rhythm is visible instead of hidden inside chat logs.

The agent-server exposes 10 Elisp APIs (agenda, search, bibliography, dblock) through emacsclient socket. Docker containers on Oracle Cloud call the same functions that the local Emacs shows. One time axis, many beings.

→ doomemacs-config

"The thrower of the project is thrown in his own throw." — Heidegger

geworfen renders one human's raw existence data as a WebTUI dashboard. Not a static blog — a transparent data nexus. The front door is org-agenda. Behind it: notes, bibliography, commits, health records, journal — alive on the time axis.

It also acts as the public-facing edge of a deeper PKM system. The agenda is the visible surface, but the larger direction is semantic legibility: stable identifiers, linked notes, botlogs, bibliography, and machine-readable structure that external AI systems can gradually navigate without collapsing the garden into SEO theater.

19 days from design to deployment. Clojure + http-kit + GraalVM native-image (43MB binary). 100 visitors hitting the same date = 1 emacsclient call (cached). SF terminal aesthetics with GLG-Mono web font and Catppuccin theme.

→ agenda.junghanacs.com

notes.junghanacs.com is not a content dump or a personal brand site. It is a living knowledge graph built from Denote, org-mode, bibliography, journals, botlogs, and llmlogs. Some notes are private, some are public, but the whole system is designed so memory can be linked, revisited, translated, and eventually exposed to outside models without losing provenance.

This is the part of the work that sits closest to PKM-AI positioning. I am not only using AI on top of notes. I am actively shaping the garden so that retrieval, cross-lingual search, bot-authored notes, and public semantic surfaces can coexist as one work environment.

Open-source Matter smart home hub with on-device AI agent. No cloud required.

A single Go binary handles Matter device control, real-time SSE streaming, and an LLM agent. Runs on RPi5 + Hailo-8 NPU (Yocto Linux) and RK3576 (Android) from the same codebase. Flutter app as the shell.

What matters here is not a single model benchmark. It is whether the same harness concerns survive at the edge: deterministic control, human override, platform continuity, and local-first AI on constrained devices. The project is where the shared-memory and shared-interface questions meet the physical home.

→ homeagent-config

Starts from LEGO SPIKE / Pybricks and a phone UI, but the point is not coding education. legoagent-config is the toy-scale sibling of HomeAgent: a physical body, direct BLE control, expandable senses through ESP32 / ESP32-CAM, and room for an external agent mind.

The current loop is already proven: Android phone ↔ BLE ↔ SPIKE Prime hub, launching slot 0 and driving the body directly. Small scale, but the direction is serious — reproducible embodied-agent experiments built around play, imagination, parenting, and a child-facing interface.

→ legoagent-config

;; Is this data or code? Both.
(and (> temperature 25) (= light "off"))

Homoiconicity — code and data are the same structure. When an IoT recipe is an S-expression, the AI agent reads it without parsing, transforms it without losing meaning, and verifies equivalence mathematically. This is why durable-iot-migrate chose Clojure over Go (62% code reduction, same test coverage).

The lineage: Papert's Logo taught children to think computationally with Lisp. Sussman's SICM unified physics and code in Scheme. SDF generalized it into flexible software design. Now Clojure carries that philosophy on the JVM — and through GraalVM, into native binaries. geworfen, dictcli, durable-iot-migrate are built with it.

proxycli proved it in practice — Python→Clojure rewrite with 92% code reduction, shipping as a GraalVM native binary. abductcli extends the same Clojure-native CLI style into quantitative abduction: anomaly → signal → memo → evaluation, a tool for reasoning backward from surprising numbers to the hidden scale that must explain them.

sicm-study is where this journey started — the internalization of flexible design from SICP through SICM to SDF. The repo is quiet, but the philosophy lives on in every Clojure project.

Tools that let agents query the actual corpus instead of guessing about it:

Each tool speaks the same language: Denote IDs (YYYYMMDDTHHMMSS) for cross-referencing. Query commits by the same timestamp as journal entries, botlogs, and health records.

Agent collaboration requires a trusted computing environment and an organic tool flexible enough to be shared. Without this forge, everything above collapses.

nixos-config is declarative NixOS across 4 machines: laptop (ThinkPad), NUC, Oracle ARM, RPi5. One flake, nixos-rebuild switch, identical environment. Docker compositions for 17+ services — including openclaw (4 Telegram bots) and geworfen — all declared in Nix. When a machine dies, a new one boots the same world from a single repository.

Reproducibility is not convenience — it's the precondition for agent trust. An agent that knows its environment is deterministic can act with confidence.

doomemacs-config is not just an editor config. It hosts agent-server.el — the Elisp interface that agents use to read org-agenda, search Denote notes, query bibliography, and update dblocks. 10 APIs exposed via emacsclient socket.

The Fence Philosophy: Agents aren't restricted with prompts ("don't do X"). Instead, the host provides a fenced playground — path guards in Elisp (read: 4 directories, write: 2 directories), API functions that cover all legitimate operations. Inside the fence, agents are free. If an agent breaks something, that's a system design problem, not an agent problem. Trust comes from structure, not surveillance.

Fence (agent-server.el)     Playground (agent freedom)     Guardian (host/human)
─────────────────────────   ─────────────────────────────  ────────────────────────
path guard: read 4 dirs     define new functions (REPL)     monitor, recover
API: agenda, search, bib    parse org, update dblock        escalate, redesign
write: botlog + tracking    chain queries, cross-ref        final responsibility

The same agent-org-agenda-day function that Emacs shows the human, that Docker bots on Oracle Cloud call, that geworfen serves to the web — one interface, three consumers.

openglg-config is a new forkable work surface that keeps two halves in one repo: authenticated self-hosted services behind Caddy + Authelia, and a Nix + home-manager bootstrap for reproducing the operator's shell on Debian or Ubuntu.

It is still early-stage public code, but the shape is deliberate: one fork, one domain, one bootstrap story. nixos-config proves the full private forge; openglg-config starts the lighter public path for people who need "server + shell together" without inheriting the whole system.

Cloud bots (openclaw) run on Oracle ARM as Docker containers — 4 Telegram bots (Claude, GPT, Gemini, B-bot) with Gemini Embedding 2 memory search. This is where botlog was born: agents writing org-mode notes about their own work.

Languages: Go · Clojure · Zig · C · Elisp · Nix · Bash · TypeScript

Embedded & IoT: Matter · Thread · Zigbee 3.0 · MQTT · OTBR · Yocto (scarthgap 5.0) · ARM Linux

AI/ML: sLLM (Qwen3, LoRA fine-tuning, GGUF quantization) · Gemini Embedding 2 · LanceDB · Ollama · OpenRouter

Cross-platform: Flutter · Android · Linux · A2UI (Google genui) · GraalVM native-image

Infrastructure: NixOS 25.11 · Docker · GPU cluster (CUDA, 3× RTX 5080)

Knowledge: Emacs 30.2 · Org-mode · Denote · BibLaTeX · Pandoc

Protocols: ACP · MCP · A2A · emacsclient socket · SSE · JSON-RPC 2.0 · REST

Counts rounded to the nearest 100; aligned to geworfen live data and gitcli --me (filters out forks and AI-bot authorship). Measured 2026-04-27.

Last updated: 2026-04-27