AgentModeled on OpenClaw / Harness
The execution-first entry, bound to the project workspace of the current session. The goal is to get things done: it plans its own steps, calls tools in order, and traces every step on the timeline.
Not just a chatbot. Give it a goal — it plans the steps, calls the tools, and gets the job done: files, commands, web search, sub-agents working in parallel. It learns as it works, distilling every finished turn into memory and skills you review before they stick. And it always asks before it touches your files — up to a kernel-level tier for extreme jobs, approved one action at a time. There is also a Siri-style background assistant, one hotkey away.
Agent and Assistant share the same kernel — context, memory, permissions, tools, and the model gateway. They are just different shells: different personas, UIs, default tool sets, and permission levels.
The execution-first entry, bound to the project workspace of the current session. The goal is to get things done: it plans its own steps, calls tools in order, and traces every step on the timeline.
A standalone global butler with Siri-style invocation. No workspace — it is for quick, ad-hoc actions. It lives in the tray, wakes with a single hotkey, and lights up the screen edges with a marquee effect when it does.
Scheduled, heartbeat, and workflow tasks: let the Agent start work on its own, no babysitting required. Results land back in the same conversation, exactly as if you had run it by hand.
The UI and the kernel are two separate processes: the renderer never reads files or spawns processes — every side effect goes through RPC. The kernel owns everything that actually changes your machine, and that is exactly why it can keep it under control.
Each skill is a SKILL.md: the listing goes into the system prompt, and when a trigger word matches, the body enters that turn's context. The model can also distill what it just learned into a new skill.
Remote tools are isomorphic to built-in ones and get the same high-risk handling. Reuse the whole MCP ecosystem — no need to write a fresh adapter for every tool.
Give each sub-agent its own focus, persona, skills, tools, and permissions to form a team; the main Agent assigns work with task, plus task_wait / status / cancel.
Hybrid recall of lexical + true semantic vectors, defaulting to the bge-m3 sidecar. Memories that have not been recalled in a while are down-weighted; ones that get used and are not re-edited are up-weighted.
When the context nears the window limit, older history is compressed by policy — keep the conclusions, drop the noise. Long conversations stay online without blowing the window.
Both OpenAI and Anthropic endpoints, plus local model services. Thinking parameters follow each vendor's style, including DeepSeek V4's thinking and reasoning_effort.
Five permission levels, path guards, high-risk command detection, execution host backups and fingerprints, and an audit hash chain. A permission prompt the UI never answers counts as a denial.
Wire external chats into the Agent: Telegram, Feishu, Discord. Send a line from your phone and it gets to work on the desktop.
Every finished turn is handed to a background distiller: reusable facts go to long-term memory, reusable working methods become skill candidates. Nothing is written silently — candidates wait in a review queue and only enter the real library after you accept them. A thumbs-up or thumbs-down on a message feeds the same loop, and reinforcement plus a forgetting curve keep the recall ranked by what actually helped you.
The fifth permission tier, for jobs nothing else should attempt — drivers, raw disks, system repair. Only the kernel can reach that layer, and the tier itself is never an authorization: it asks every single time, offers only "allow once" with no "remember this" option, and runs under audit, backup and rollback. Off by default until you say otherwise.
The upside is full decoupling: future WebUI / TUI / CLI builds can reuse the same protocol, and swapping the UI never touches a line of kernel code.
Windows and navigation, session list, streaming chat, tool cards, chain of thought, nested sub-agent blocks, context drawer, permission prompts; plus tray / global hotkey / transparent always-on-top window / wake-up glow.
Exposes kernel capabilities over RPC: event streams, live tool output, reverse permission-prompt requests, change records and revert, MCP server management, SKILL listings, and the tool catalog and entry profiles.
User messages / model replies / tool results are persisted immediately — switching sessions or closing the window loses nothing. Events are filtered by sessionId so they never cross wires.
Spawn the MCP server subprocess → handshake → pull tools → register them with the kernel; full CRUD for skills and personas, with the skill lab reviewing self-learned candidates.
Conversations / tools / skills / sub-agents are each persisted separately, through a single-consumer background queue, so persistence never blocks a turn.
Light by default, dark when you switch; the window sits on a system acrylic base. The layout layers through whitespace and hairline borders, and the accent color is reserved for focus and runtime states — below are UI mockups recreated from the real implementation.
8 .tmp and 4 .log files, freeing 21.4 MB.README.md is written in three sections — “Directory purpose / Subdirectory notes / Maintenance notes” — at publish/README.md.Long-term memory, user profiles, and pending-review candidates. Recalled on demand in conversation, with hybrid lexical + semantic vector ranking; recall parameters and context compression policy are tuned on this page too.
Give each sub-agent its own focus, persona, skills, tools, and permissions to build a team that works in parallel; the main Agent assigns work with task.
The default executor when the task tool has no profile; ships with the kernel, not editable or deletable. Kernel built-in · 902 tasks · 3 failed
Focus: find regressions, check edge cases, compare change intent
Focus: verify online, cross-check sources, cite references
Focus: batch cleanup, archiving, generating manifests
Manage your added models: every tunable parameter in the request body lives in advanced editing; quick presets (just fill in the key) and JSON import/export are supported.
Lay out conversations, Token, cost, calls, and errors in a filterable, sortable, exportable analytics panel.
It lives in the tray without taking up your taskbar. Press Ctrl+Shift+Space, and a transparent, always-on-top window rises from the edge of the screen, lighting up the whole screen border; say what you need, hit Enter, and it is on it. Close the main window and it is still there.
Permissions come in five levels, one per entry point, adjustable at any time and effective immediately. The level is not persisted — a restart returns to the default. That is the product's promise: treat letting go as an explicit, bounded authorization, not a permanent handover. The fifth level, kernel-level execution, is the one exception in kind: it exists for extreme jobs, it is off by default, and it authorizes exactly one action at a time.
Tool calls never execute. Look, but do not touch.
Confirm before every single execution.
Routine actions pass through; high-risk ones still ask.
Execution is open, but protected paths still ask.
Extreme jobs only — drivers, raw disks, system repair. Off by default, one action at a time, never a standing grant.
Sensitive directories and protected paths get their own gatekeeping — never silently allowed, even at high levels.
Destructive commands are recognized first, then it decides whether to stop and ask you.
Backups and fingerprints before it acts; on timeout it kills the whole process tree. Make a wrong change and you can revert it.
Every action leaves a record, and the chained hashes make it impossible to alter or deny.
Kernel in C# (.NET 10), UI in Electron; core capabilities are reused as both a DLL and a standalone process.
RinKowAgent · Version 0.07.18 · Alpha · Windows desktop · Distributed as a non-packaged EXE