You know it is already inaccurate. The next time you open it, adding that one entry is not enough. Did you miss others before it? Did the same purchase appear once in each of two channels? Was the original expense reversed after a refund arrived? If any of those questions remains unanswered, continuing feels like adding numbers to a crooked table.

That is where many people stop. They still want a record of their spending, but they do not want to spend more time on a result they no longer trust.

A recent real reconciliation covered four months, several payment and banking channels, and hundreds of existing records. There was no assumption about where the problems would be. The comparison surfaced omissions, duplicates, refunds, and old-data issues:

• Some expenses appeared on statements but not in the ledger.
• Some purchases left a record in more than one channel.
• Some recorded expenses were later refunded in full but remained in the totals.
• Some old records had no date, so monthly reports could not see them.

Memory is a poor way to reconstruct any of these. Refunds and undated old records are especially difficult because they do not look like errors. They quietly change the result.

Reconcile First, Then Change the Ledger​

The agent did not read the statements and immediately change the data.

It first compared the statements with the existing records and produced an analysis: confirmed omissions, possible cross-channel duplicates, possible refunds, and cases that required a decision. At this stage, it presented evidence without writing or deleting anything.

The human supplied the judgment. Whether a transfer counts as spending, how a refund should be classified, and which of two duplicate records should remain all depend on the owner's accounting rules. The agent wrote and corrected records only after the proposed treatment was approved.

Writing was not the end. It read the ledger back and checked the resulting count and total against the approved list. For every deduplication or deletion, it retained the record identifier, the reason, and the outcome. A conclusion could be traced back to the original record, and the write itself could be checked for mistakes.

Auditability matters more than a claim that the work was automatic. If automation says only, “I recorded it for you,” the person still does not know what it missed or merged. Analysis first, approval before writing, and a read-back afterward make the work safe to delegate.

A Missing Entry No Longer Means Starting Over​

The ledger does not require a perfect daily habit. At the end of the month, the agent can compare statements from different sources with the existing records and surface omissions. Forgetting one entry does not invalidate everything recorded before it.

Duplicates do not have to be guessed by eye either. Similar times, amounts, and descriptions are only clues. Uncertain matches are listed for a human decision instead of being merged silently.

The person's work is reduced to the few places that require judgment: defining the rules, reviewing evidence, and confirming the treatment. The agent handles the statement-by-statement comparison, cross-checking, data entry, and read-back.

When a reconciliation can show what it inspected, what it proposed changing, and what it changed, a missing entry becomes one issue to resolve instead of a reason to abandon the entire ledger.

Self-custody usually means running your own server, and that is exactly where most people give up. Here is a zero-cost path that skips the server entirely: the UnDercontrol desktop app ships with a full backend and keeps your data in a SQLite file on your own disk; Cloudflare Tunnel exposes that machine to the internet for free; the iOS app connects straight to your own endpoint. Check tasks, jot notes, and log expenses from the subway, while the data itself never lives anywhere but your computer. No public IP, no router port forwarding, and no domain to buy (optional, only if you want a fixed address).

Step 1: Install the desktop app, meet the embedded server​

Install the UnDercontrol desktop app (macOS / Windows / Linux) from the download page. It is not a web-page shell: a complete Go backend ships inside, and the moment the app starts, a local server is listening on port 8888 (it moves to the next free port if 8888 is taken), storing data as a SQLite file on your own disk.

On first launch you will see "Welcome to UnDercontrol" and a Start button. One click and you are in: the app auto-creates a local account personal@undercontrol.local with the default password personal123, no registration, no invite code. Remember these credentials, you will need them on the phone in step 4. And change the default password before exposing anything to the internet; the Security section below shows how.

Confirm the server is alive:

curl http://localhost:8888/health
# {"service":"ud-go-production","status":"healthy"}

If you see healthy, your "server" is ready. It is the computer you are using right now.

Step 2: One command to reach the internet​

Cloudflare Tunnel works by reverse connection: cloudflared on your computer dials out to Cloudflare's edge, and outside traffic is relayed back through that connection. Because the connection is outbound, you need no public IP and never touch your router settings.

Install cloudflared:

# macOS
brew install cloudflared

# Windows
winget install Cloudflare.cloudflared

# Linux (Debian/Ubuntu): add the repo from https://pkg.cloudflare.com first
sudo apt install cloudflared

Then one command:

cloudflared tunnel --url http://localhost:8888

A few seconds later the terminal prints a random https://xxx.trycloudflare.com address: your public endpoint, HTTPS included, no Cloudflare account required. Verify from your phone (turn off Wi-Fi so you are on cellular, which proves the path is really public): open https://xxx.trycloudflare.com/health in the browser. healthy means the whole chain works.

Quick tunnels are for trying the flow out: the address changes every time you restart cloudflared, and Cloudflare makes no uptime promise for them. For daily use, spend five minutes upgrading to a named tunnel.

Step 3 (recommended): A named tunnel with a fixed address​

A named tunnel needs a free Cloudflare account and a domain hosted on Cloudflare. The domain costs a few dollars a year and is the only place money can enter this setup.

# 1. Log in; authorize your domain in the browser
cloudflared tunnel login

# 2. Create the tunnel
cloudflared tunnel create ud

# 3. Point a subdomain at it
cloudflared tunnel route dns ud ud.example.com

Write a config file at ~/.cloudflared/config.yml:

tunnel: ud
credentials-file: /Users/you/.cloudflared/<tunnel-id>.json

ingress:
  - hostname: ud.example.com
    service: http://localhost:8888
  - service: http_status:404

Run it, then register it as a system service so it survives reboots:

cloudflared tunnel run ud        # run manually first
sudo cloudflared service install # then install as a service

From now on https://ud.example.com is your fixed endpoint. Remember to stop the computer from sleeping in the system power settings — it is your server now.

Step 4: Point the iOS app at your endpoint​

The iOS app is in public beta on TestFlight (install TestFlight from the App Store first).

Open the app. At the bottom of the sign-in screen there is an API server section showing the current server. Tap Change and enter your public address, including the /api/v1 suffix:

https://xxx.trycloudflare.com/api/v1

The status dot probes as you type: when it turns green with connected · Personal, your phone has reached the server on your computer. Tap Save, then sign in with the account from step 1: personal@undercontrol.local and your password.

What you see on the phone is the data on your computer: tasks, notes, ledgers. Edit on the phone and the desktop has it.

One detail: iOS requires HTTPS for public domains (Cloudflare Tunnel provides it, nothing to do). If you enter a LAN or private-mesh IP instead, write http:// explicitly; without a scheme the app assumes https://.

Security​

Public exposure means anyone with the URL can reach your endpoint. Three things, in order of importance:

1. Change the default password first. Every data endpoint requires login, but the desktop's default password personal123 is public knowledge. Exposing it unchanged is taping the key to the door. The password comes from the PERSONAL_TIER_PASSWORD environment variable; on macOS, launch from a terminal with it set:

PERSONAL_TIER_PASSWORD='your-strong-password' /Applications/UnderControl.app/Contents/MacOS/UnderControl

On Windows, add PERSONAL_TIER_PASSWORD in System Environment Variables and restart the app. Phone and CLI then log in with the new password.

2. A random URL is not a security mechanism. The trycloudflare address is hard to guess, but do not treat that as protection; think before sharing the link.

3. For an extra gate, Cloudflare Access on the free plan can put an email-code check in front of a named tunnel. Configure it once and it applies to every device.

Don't want public exposure at all?​

If all you need is "my devices can reach each other", skip the public internet entirely: use a private mesh network tool to put your phone and computer on the same virtual LAN. Install the client on each device and they see each other; your computer gets a virtual-LAN IP, and the iOS app endpoint becomes http://<virtual-lan-ip>:8888/api/v1 (write http:// explicitly). Zero public exposure, and the free tiers of these tools are usually plenty for personal use. The mesh setup itself is out of scope here; every vendor's docs cover the phone-plus-computer case.

After it works​

The bill: VPS $0, tunnel $0, HTTPS certificate $0. The only optional cost is a domain at a few dollars a year.

• Desktop download: https://oatnil.com/download
• iOS TestFlight: https://testflight.apple.com/join/st2TnaBF

Anchored comments in UnDercontrol keep the discussion next to the original text. Select a sentence in the task body, click Comment in the bubble menu, and a comment carrying that quote appears in the right sidebar while the sentence itself turns into a highlight. Click the highlight later and the sidebar jumps to the matching thread. The quote lives on the comment, so the markdown in the task body is never touched. Copy it out or pull it down from the command line and you get exactly what you wrote.

When a discussion is settled, hit Resolve. The highlight disappears from the body, the thread collapses into a single grey line, and you can reopen it whenever you want. Threads update on their own when someone replies, with no page refresh. On a phone there are no highlights and the comments sit below the body.

Reviewing a spec like you review code​

A reviewer no longer has to write "third section, second sentence". They select the line that says "supports bulk import", ask "what's the upper limit?", and the author answers in the same thread. Agree, resolve, move on.

Once you have been through a spec, the highlights still lit on the page are the parts nobody settled. There is no separate write-up to do afterwards, because the unresolved threads are the to-do list.

Point at a line and let an agent change it​

This is the part that is not like a normal comment section. Select the requirement you want changed, leave a comment that @mentions your agent, and say what it should become. The mention starts an agent session, reusing one that is already running, and when the agent is done its reply is the next comment in that thread, sitting alongside your colleagues' replies with the commit hash in it. Click the highlight and you are back at the text that changed, side by side.

People and agents talk in one thread, so you are not relaying messages between two tools.

Section-by-section discussion on long documents​

Write the task body as a design doc and record each iteration as a note. Discussions anchor to their own section: comments on the body in one group, comments on each note in a group of their own, and unanchored chatter in a third. Three months later, why a decision went the way it did is written next to the sentence it changed.

The same thread from your terminal​

Comments are just as readable and writable from a terminal. The ud CLI treats them as a resource like any other, so an agent can read the discussion a human left in the browser and reply to it:

# read every discussion on a task
ud get comments --task 02c137b3

# reply to a thread
cat <<'EOF' | ud apply -f -
---
task_id: 02c137b3
parent_id: 7a1c9f2e
---
Per-user rate limiting is in, commit a1b2c3d4.
EOF

Claude Code, Codex, OpenCode, or any terminal-based agent works here without an adapter layer. Close a thread out with ud patch comment <id> --status resolved.

Anchored comments have been available since v0.88.0, in the browser, in the desktop app, and from the CLI.

A task in UnDercontrol is already a container: body text, notes, and file attachments. Generate a public share link for it, and anyone who has the link can read the content and download the files. No account, nothing to install. It works like a parcel locker: you drop things in, get a pickup code, and whoever has the code takes them out.

Step 1: put the files on a task​

Create a task and upload the files in its attachments section. The task body is Markdown, so write the instructions right next to the files. Whoever opens the link sees your print requirements, not a bare file list.

Step 2: generate the share link​

Open Share to Public in the task menu. Two settings:

• Expiry: 1 hour / 1 day / 7 days / never
• Allow attachment downloads: off by default; check it when the point is the files

Click Generate Link and you get three things at once: the full link, a 6-letter pickup code, and a pre-composed message (Copy Share Message) that carries both, ready to paste into any chat.

Step 3: pick up on any device​

Three ways in, for three situations:

• You have the link: open it. It's a read-only page with the title, body, notes, and attachments, each with a download button.
• You have only the code: open the share entry page and type the 6 letters. Handy when the code was read out loud, or on a public computer where you'd rather not type a long URL.
• You're standing next to the person: the share page shows a QR code; scanning it lands on the same page.

The security details​

• The token in the link is 32 random bytes (64 hex characters), so it can't be enumerated
• Links expire on schedule. The dialog lists each link's remaining time, and any link can be revoked at any moment
• Attachment downloads go through presigned URLs generated per click and valid for 15 minutes; the file in storage is never public
• The shared page is read-only and carries only the title, body, notes, and attachments. No account info, and comments stay private
• Self-hosted instances can switch public sharing off entirely in system config

A parcel locker for documents too​

The task body and notes are Markdown, written in the same editor UnDercontrol uses everywhere else (notes, finance records). So the thing you share doesn't have to be a file. Meeting minutes, a PC-build checklist, a travel plan — the other side opens a formatted read-only page. Files and documents travel through the same link.

Typical scenarios​

• Print shop: attach the PDFs, type the pickup code on the shop computer, download and print, revoke the link when you get home
• Sending files to someone without an account: paste the Copy Share Message; one message carries the link and the code
• A shared meeting-room computer: type the 6-letter code to open the document read-only; whoever wants a copy afterward scans the QR on the page
• Deliverables for an outside collaborator: pick the 7-day expiry and the link shuts off by itself
• Output from terminal AI agents (Claude Code, Codex, OpenCode, or any terminal-based agent): the agent attaches its report and artifacts to a task; you review, then forward one link

The entry point is Share to Public in the ⋮ menu on the task detail page. Self-hosting? Check that the public share switch in system config is on — it is by default.

More agents didn't fix the bottleneck — it moved. You no longer lack workers. You lack managers, because there's exactly one: you.

That's not a configuration problem, it's an org-structure problem. One person directly managing ten reports doesn't work in human companies either, and the fix was never "hire stronger individuals." The fix is a layer of management.

A lead isn't a smarter agent — it's an agent that knows the roster​

In UnDercontrol you can organize agents into a Team: one lead, any number of members, and each member carries a delegation hint — "what kind of work routes here."

That hint is a job description. It's short, but it decides whether work reaches the right specialist:

- @db-expert [reviewer] — schema changes, slow queries, migration scripts
- @ud-tester — requirement acceptance, black-box regression; don't let it touch code
- @infra-ops [remote — mention only] — servers, deploys, DNS

Here's the part that matters: the moment a lead's session starts, that roster is injected into its initial prompt. You don't introduce the team in conversation, and it doesn't rediscover them each time. It is born knowing who reports to it, what each one is good at, and how to hand work off.

Injected alongside it is a plain but consequential instruction: "As team lead, prefer delegating over implementing yourself. Your job is to coordinate, keep talking to the user, and review the specialist's output. Only implement directly when no member covers the work."

If you've ever managed people, you'll recognize that sentence as the hardest lesson a new lead has to learn.

Two delegation channels: one fast, one on the record​

This is the design most people don't anticipate. Delegation isn't one move. A lead has two channels, and it defaults to the fast one.

Channel 1 — native subagent (default)

The lead runs ud describe agent <name> -o prompt to fetch the member's identity prompt, then spins it up using its own host tool's native subagent capability, appending the task context. The subagent runs inside the lead's session and permissions; the lead consolidates the result and reports it, noting "via @member."

The split is clean: ud supplies identity, skills, and context; the host tool executes. Fast, synchronous, no overhead — right for "take a look at this SQL" work.

Channel 2 — subtask + @mention (escalation)

The lead escalates to the second channel when any of these hold:

• The member is pinned to another machine (an ops agent that only runs on a production jump box, marked [remote — mention only] in the roster)
• The work is long-running and must outlive the lead's session
• You want the work to have its own accountability thread you can audit separately

The move is: create a subtask → ud link task <parent> <child> --subtask → @mention the member in a comment on that subtask. The mention automatically spins up a workspace session for them, and the delegation chain preserves your access scope — a member never receives broader permissions than you have. It reports its conclusion back into the thread.

In one line: fast work goes to a subagent; anything that needs a record, another machine, or a long runway goes to a subtask plus an @mention.

Recursion: agents of agents of agents​

Teams nest — a member can itself be the lead of another Team. Hierarchy grows naturally, and each agent only ever needs to know its direct reports, never the whole tree. That's how real organizations work.

It goes one step further: the default ud agent is the root manager of the whole org. On top of any teams it explicitly leads, every top-level team lead is automatically injected as one of its direct reports — so no matter how many layers your org grows, the entire tree stays reachable from ud.

You don't have to remember who to @. Just @ ud and let it walk down.

So your job changes​

From "dispatching N agents" to three things that look a lot more like management:

1. Write the job descriptions. A vague delegation hint sends work to the wrong specialist. Writing a crisp "this belongs here, that doesn't" beats upgrading an agent to a pricier model.
2. Define acceptance criteria. You review output, not process. Put the criteria in the task description: the lead uses them to check its members, you use them to check the lead.
3. Hold the review gate. However deep the delegation chain runs, you're still the one signing off.

Worth noting: everything agents write back and forth — task descriptions, comments, notes — lives in the same Markdown system as anything you type by hand. And not just tasks: notes, expenses, accounts — every surface in UnDercontrol where you can write text shares one editing experience. Humans and agents read and write the same artifact. There's no "format for the AI" and separate "format for people."

Traps worth knowing about​

• The lead does the work itself. The most common failure mode, and usually it means the delegation hints were too vague — the lead couldn't tell who to route to, so it just did it.
• An offline machine makes @mentions silently vanish. Mentions don't queue waiting for a machine to come online; the delivery is dropped as daemon-offline. Confirm the machine is connected before delegating remote work.
• One active session per member, per task. To have an agent push two things in parallel, split them into two tasks — @mentioning it twice on one task won't do it.
• Nested teams have no cycle detection yet. Nothing stops you configuring A leads B leads A. Keep the depth in your head — three levels is about the ceiling; past that you can't follow what happened in the middle of the chain at review time.
• Review debt. The smoother delegation gets, the faster unreviewed output piles up. The bottleneck migrates from dispatching to accepting — and that part can't be outsourced yet.

In the end​

Any agent can be the lead. Claude Code, Codex, OpenCode, any terminal-based agent can be a lead or a member — roles are defined by prompts and skills, tools by Agent CLI configuration, and every one of them talks to the org through the same AI agent CLI. UnDercontrol isn't tied to any AI vendor.

It does one thing: when you have enough agents that they need managing, it gives you a management layer — instead of making you be that layer.

In UnDercontrol, this pipeline works out of the box: Claude plans, Codex executes, and the task system is the whiteboard they share — you only step in to review at the key points.

Five steps to a working pipeline​

1. Configure two agents. Claude Code, Codex, and OpenCode are built-in Agent CLI templates — just pick one (any custom command works too). Give the planner Claude Code and the executor Codex. Don't feel like configuring? Even this step can be outsourced — there's a built-in Agent Creator: @mention it, describe the combo you want, and it sets the agents up for you.
2. Toss the requirement to the planner. A rough task is fine — just @planner it. The daemon spins up a Claude Code session on your dev machine: it reads the description, clarifies the requirement, and splits it into subtasks with acceptance criteria.
3. The planner delegates to the executor. It @executor-mentions each subtask — an agent-to-agent @mention automatically launches a new workspace session for the other agent, and the delegation chain preserves your access scope.
4. Codex executes. Each session picks up one subtask: writes code, runs tests, commits, notes progress back on the task, and marks it pending when done.
5. You step in at exactly two points. Approve the plan; review the output.

The whole collaboration happens on the task itself — the description is the spec, comments are the conversation, notes are the progress log. Here's a real task detail: the planner's acceptance criteria on the left, the three-way comment thread on the right:

Form a squad: Agent Teams​

Don't want to conduct two agents by hand every time? Organize them into a Team.

A Team has one lead and any number of members, and each member carries a delegation hint — "what kind of work routes here." When the lead's session starts, its roster is injected into the prompt automatically — the lead is born knowing who reports to it, what each specialist is good at, and how to delegate.

"Claude plans, Codex executes" becomes a one-liner: @mention the dev-team's lead and it arranges the rest. Teams also nest — a member can itself lead another Team, so hierarchy grows naturally while each agent only ever needs to know its direct reports.

Watch everything live​

Open a board for the big picture: how much got planned, what's executing, what's waiting for review — one glance. Every agent session's terminal output also streams back to the web in real time — on your laptop, or your phone.

Typical scenarios​

• Queue work before bed, review after breakfast. Drop three feature requests on the planner at night; wake up to split subtasks and several pending implementations, each with its own commits.
• Slice a big refactor. Claude writes the migration plan and cuts it into 20 small tasks; Codex executes them one by one — roll back exactly the step that goes wrong.
• A bug-triage pipeline. The planner reproduces, localizes, and writes up the root cause before delegating the fix — the executor gets "what to change, why, and how to verify," not "there's a bug, fix it."

The combo is yours to choose​

Claude + Codex is just one pairing. UnDercontrol is not tied to any AI tool — Claude Code, Codex, OpenCode, or any terminal-based agent can be a lead or a member, because each of them reaches the shared task board through the same AI agent CLI. Roles are defined by prompts and skills; tools by Agent CLI configuration. Whatever subscriptions you hold and whatever each model is best at, the orchestration is in your hands.

One more thing: the progress agents write back lives in the same Markdown system as everything you write by hand — tasks, notes, comments, even finance records share one editing experience.

Want to try it? Download UnDercontrol, start the daemon, create a Team, and @mention the lead on your first task.

Building UnDercontrol, I've held onto one conviction: a task shouldn't be disposable. Its body is already a Markdown document, its Notes record how it evolved step by step, and the comments keep the arguments from back then. Throwing all of that away when the work is done is just wasteful.

That's why Virtual Path exists.

Give a task a place​

The idea is simple: every task, every uploaded file, even every Skill can carry a virtual path like /engineering/backend/. Everything with a path forms one tree — the Explorer. It looks like a file manager, but there are no real directories underneath. Wherever a path exists, a "folder" exists; delete the contents and the folder disappears on its own. You never have to maintain a pile of empty directories.

When a task is done and worth keeping, drag it into /decisions/ or /engineering/ — it turns from a finished card into a document in your knowledge base. No copy-pasting into another note app; the Notes and comments stay attached.

And the ones not worth keeping? Leave them. Unfiled tasks sit at the tree root and in the "Unfiled" area, never mixing into the folders you've organized. The tree is curated, not accumulated — you decide what earns a place.

Diagrams, screenshots, whiteboard photos can live at the same path too, so a topic's text and assets sit side by side — no more digging through a cloud drive for "that one image."

By the way, this isn't just about tasks. Every writing surface in UnDercontrol — tasks, notes, expense records, account memos — shares the same Markdown editor, so any content can settle down the same way.

Many tasks, one document​

The more common case is this: a topic wraps up after seven or eight tasks, each holding a few scattered findings, none of them usable as a document on its own.

These days I hand that job to an agent. Claude Code, Codex, OpenCode — any terminal agent can read through the batch via the ud CLI, distill it into one new document, and file it into the right folder of the tree. The original tasks stay untouched, kept as raw material you can always trace back to. What the knowledge base keeps is the distilled conclusion, not a pile of process.

Sync it local — offline, and yours​

Knowledge living on a server is only step one. My own habit: documents must be able to land on my own disk, editable with whatever editor I like.

The ud CLI syncs git-style (I wrote about the basics before: Manage Your Tasks Like git: ud pull / push):

ud init /Knowledge/   # bind the current folder to a virtual path
ud pull               # tasks become local .md files
ud push               # local edits go back to the server
ud status             # see what differs

The default vault layout is Obsidian-native:

MyVault/
├─ engineering/backend/
│  └─ SSE reconnect backoff.md     ← one .md = one task
├─ notes/SSE reconnect backoff/    ← the task's Notes, grouped per task
│  └─ soak test results.md
├─ attachments/diagram.png         ← resources (--fetch-attachments)
└─ .udignore

After a pull, this is a fully offline local knowledge base. Plain Markdown on your disk — readable and editable without a connection, works fine on a plane, one ud push after landing. The data is yours. Both copies.

A lot of care went into the details; a few worth mentioning: ud writes exactly one ud-id line into the frontmatter and leaves the rest untouched; rename a file locally and the task title follows after a push; [[wikilinks]] written in Obsidian get translated into ud's task:// links on push and back again on pull, so clicking works on both sides; files you don't want synced go into .udignore, gitignore syntax; conflicts are handled git-style — items changed on both sides get flagged and skipped by default, never silently overwritten. And moving over from the older folder structure is a single ud migrate-layout away.

Let an agent tidy your tree​

Every knowledge base gets messy over time. Folders grow deeper, names drift, stale docs mix with fresh ones — mine too.

But tidying is exactly the kind of bulk work agents are best at. The vault is just a local folder: after ud pull, let an agent read the whole tree — restructure folders, merge duplicates, unify naming, move the stale stuff into an archive. All it does is ordinary file operations; you review the diff with git or ud status, then ud push when satisfied. The Explorer on the web immediately shows the tidied shape.

What makes it safe to let an agent loose here is the clean layering: the vault layer is content — plain text, git-able, anyone can edit it; status, boards, comments, and the Notes timeline are ud's collaboration metadata sitting on top, the way PR comments never get written into the git tree. The agent touches the content layer; the collaboration history loses nothing.

And a tidied tree isn't locked to one machine. Web, desktop, and mobile all see the same tree: skim an ADR on your phone during the commute, edit properly on the web at your desk, hand batch work to the CLI and agents in the terminal. Organize once, use it anywhere.

A task's endpoint shouldn't be "Done." Give the things worth keeping a place in your knowledge tree — one drag, one command, or hand it to your agent.

I studied architecture. Then I switched careers and became a programmer. Later I left everything familiar behind and moved to Singapore, where I now work as a fullstack / DevOps engineer.

Career switchers know what "accumulation" really means​

Switching careers means starting from zero: no four years of CS coursework to lean on — every concept had to be chewed through on my own. That's when I picked up a habit: write down every pitfall I hit, every concept that finally clicked, every config I got working. Not out of diligence — out of fear. If I didn't write it down today, I'd pay for it again tomorrow.

Looking back, that habit is the highest-return investment I've ever made. It carried me through the career switch, through job changes, through moving countries, and eventually through building my own product. Knowledge, like money, compounds — but only if you have an account for it to grow in.

Over the years, my "account" changed three times: Joplin → Obsidian → UnDercontrol. Each migration wasn't chasing something shiny — it was my understanding of how knowledge should work leveling up.

The Joplin era: get things written down (Collect)​

My first stop was Joplin. Open source, free, Markdown, encrypted sync — for someone just getting serious about notes, it solved the most important problem: making "write it down" actually happen.

My early study notes, interview prep, and debugging logs from the career-switch years all piled up there.

But over time, the notes felt like drawers: easy to put things in, but every note lived in isolation. The notes themselves sat inside the app's database; finding things meant folders and keyword search; there were no real connections between notes. The knowledge was stored — but it just lay there. It didn't appreciate.

The Obsidian era: connect the knowledge (Connect)​

So I moved to Obsidian: plain local Markdown files, bidirectional links, a knowledge graph, a rich plugin ecosystem.

This was a genuine upgrade. For the first time, my notes went from "a pile of files" to "a network" — writing something new naturally pulled old notes in. My vault passed a thousand notes in this era, and I could feel the accumulated weight supporting me in retrospectives, in writing, in technical decisions.

The career switch and the move abroad — the two biggest jumps of my life — were both backed by the same body of notes. That was the first time "the compound interest of knowledge" stopped being a platitude for me.

But the deeper the accumulation, the more visible the cracks:

• My knowledge was locked in a local folder. The classic scene: debugging a nasty issue at the office, I suddenly remember — I've hit this exact pit before, and the fix is written up in detail... in Obsidian, on my computer at home. End of story. I can't sync my entire vault onto every machine I touch.
• The graph is a beautiful lie. Mention [[some concept]] anywhere in a note and it enters the graph. A throwaway reference and a carefully built relationship get equal-weight edges. The more nodes, the prettier the graph — and the less it actually tells you.
• Attachments scattered everywhere. Architecture diagrams, flowcharts, PDFs spread across assets folders; move a folder and the links break.
• Every sync option hurts somewhere. Paid sync still needs a client installed; Syncthing can't go on a work machine; Git sync is technically possible and experientially miserable.

What I needed was simple: a web page. Log in, full editing, knowledge available anywhere.

UnDercontrol: make knowledge callable (Compound)​

No tool on the market was shaped quite like what I wanted, so I decided to build one. It's also an experiment: how far can one person, plus AI, take a product?

UnDercontrol is my answer to every crack from the first two eras:

• Available anywhere: log in from any browser; plus a CLI and a desktop app, with ud pull / ud push syncing tasks to local Markdown files bidirectionally — the convenience of the web and the reassurance of local files.
• Links I build explicitly: only deliberately created relationships (peer / parent-child) enter the knowledge graph. Every edge means something. High signal, low noise.
• Centralized resources: images, PDFs, and attachments stay attached to their context, but you can browse, search, and reuse them all in one unified library.
• Not just tasks: UnDercontrol's Markdown editor is shared across every text surface — tasks, notes, finance records, documents, all the same editing experience. A task can be a document, a decision record, a blog draft.
• AI-native: the knowledge base is open to AI. Claude Code, Codex, OpenCode, or any terminal-based agent can read and write the same knowledge through the CLI. In fact, the post you're reading right now was written by an AI agent inside an UnDercontrol task, drawing on my past notes.

This is the third stage of compounding: knowledge is no longer just stored or connected — it can be called. By future me, and by the AI working on my behalf.

Time compounds into strength​

From architectural drawings to code, from China to Singapore, from Joplin to Obsidian to building my own tool — the career changed, the city changed, the software changed. The habit didn't: write down what you figured out today.

The essence of compounding isn't the rate of return. It's not stopping. The point of a tool is to make "not stopping" easy enough.

For me, UnDercontrol is both a product and the container for that habit. I use it every day to manage my tasks, notes, and finances — and to manage the building of UnDercontrol itself. I grow with it, and it remembers everything that time has laid down.

If you've migrated through Joplin, Obsidian, and a dozen other tools — if you also believe knowledge compounds — come try UnDercontrol.

There's a lot it won't show you. You want to see work by client, by sprint, by document type — there's no option for that. You want to pull the unassigned tasks into their own column — also no. You want one column watching overdue items, one watching this week's urgent ones, one just holding whatever was touched most recently, all mixed together — can't do it. The only things you can really change are the column names and their order.

So the board shows you the tool's idea of your work, not yours. The dimensions you care about, it can't hold a single one.

Why most tools work this way​

This isn't one tool's problem. Switch to another and you'll probably still get Todo, In Progress, Done. Most tools look alike because they share an assumption underneath: a column isn't something you define — it is the status enum, hardwired. What you drag a card into is an enum value, not a viewpoint you decide.

Tools have a reason for this. Flexibility usually costs you tuition. A tool that lets a column be anything tends to hand you a query language, a docs site, and a weekend along with it. Most people don't want to pay that, which is fair, so the tool decides for you: three columns, don't overthink it.

UnDercontrol takes a different route. It's a task and knowledge management tool where the day-to-day operations can be handled by an AI agent in your terminal and a command line. On a board, that means a column is no longer equal to a status — it's a condition: what kind of task belongs here. Status is just one condition among many, with no special standing. You can split by due date, by person, by tag, by your own custom field, because to the system these are all the same thing.

As for that tuition, we'll get to how it's waived.

Even the out-of-the-box board isn't only statuses​

That sounds like a promise until you see it. Create a new board and two of the six default columns aren't statuses at all:

The last two have no filter at all — they just sort by time, newest first. They don't belong to any status. They're a viewpoint.

In a tool where a column equals a status, columns like those are hard to express. Here they're unremarkable, part of the default setup.

So what about the tuition?​

If it's this flexible, doesn't that mean I have to learn a syntax before I can assemble the board I want?

No. You just say what you want.

You: build me a board that tracks deadlines — overdue, this week, next week, and no deadline set. Four columns.

That's it. Claude Code, Codex, OpenCode, or any agent running in your terminal takes it from there. What the fields are called, how the conditions are written, what the YAML looks like, which commands to run — all of that is its job.

The query language does exist, and it's complete, but it isn't your homework. It's the agent's working language. You hire someone to renovate; you don't need to lay the bricks yourself.

If you're curious, here's what it wrote for you, without you typing a character:

kind: Board
spec:
  name: Deadline Radar
  columns:
    - name: Overdue
      query: "deadline < now AND status != 'done'"
    - name: This Week
      query: "deadline BETWEEN now AND +7d"

Nice if you can read it, and it makes no difference to your use if you can't. That's the point.

And you don't have to teach the agent either​

Normally, to get an agent to use some tool, you first write it a manual: how to call it, what the fields are named, what the format is. You teach it once, the tool ships an update, the manual goes stale, and the agent starts making things up.

UnDercontrol's command line ships with a recipe catalog. The agent doesn't read source and you don't feed it docs — it asks ud cook board and the tool tells it how to build a board, complete with a runnable example. Its whole learning step is one command. The tool knows how to use itself, so you neither learn it nor teach it.

Drag a card in, and the board makes it true​

There's another half to the flexibility: how these columns respond to a drag is something no one has to configure.

The logic is plain. A column says it holds in-progress tasks. Drop a card into it, and the only reasonable meaning is to make that true, so the status flips to in-progress on its own. Another column says it holds cards tagged blog; drop one in and the tag is added, drag it out and the tag comes off.

You only said what each column holds; how to do it, the system works out itself. There's a quiet benefit to that: a column's description and its behavior can't drift apart, because the second is derived from the first — there's no second copy of the config to go wrong.

It knows when not to act​

Say a column is for what's already overdue. You drop a card into it — should the system change the deadline to yesterday?

That's a guess. It's probably not what you meant; you may have just dropped it in the wrong place. So it does nothing. Any condition that can't be satisfied by one honest write — time ranges, sorting, fuzzy matching — generates no action at all. Those columns become views you look at, and you can't break them by dragging.

Here's the real output, a four-column deadline radar:

  Columns:
    1. Overdue
       query: deadline < now AND status != 'done'
    2. This Week
       query: deadline BETWEEN now AND +7d
    3. Recently Touched
       query: ORDER BY updated_at DESC
    4. Urgent
       query: tags CONTAINS 'urgent'
       on enter: ADD tags 'urgent'  (auto)
       on exit: REMOVE tags 'urgent'  (auto)

The first three — overdue, this week, recently touched — have no actions at all; they're read-only views. The fourth, Urgent, is defined by a tag, which one write can satisfy, so dropping a card in adds the tag and dragging it out removes it, all marked (auto), none of it configured by hand.

The system won't invent a write it can't account for. That restraint isn't a shortfall in capability; it's exactly what lets "a column can be anything" be handed to you safely.

You see the real thing before it exists​

Handing board-building to an agent, the natural worry is what happens if it gets it wrong and makes a mess of your workspace.

It won't, because there's a gate in the middle. The agent runs a preview first: the system renders the board exactly as it would be created — what each column holds, what a drag would do, all laid out — and then stores nothing.

Dry run — board would be created (nothing persisted):
  Name:  Blog Pipeline
  Type:  shared  (a group "Board: Blog Pipeline" would be created for sharing)
  Default tags: blog
  Columns:
    1. Idea
       query: status = 'todo' AND tags CONTAINS 'blog'
       on enter: SET status = 'todo'  (auto)
       on enter: ADD tags 'blog'  (auto)
       on exit: REMOVE tags 'blog'  (auto)
    2. Drafting
       query: status = 'in-progress' AND tags CONTAINS 'blog'
       on enter: SET status = 'in-progress'  (auto)
       ...

Note the nothing persisted. At this point nothing has happened yet.

So the whole thing becomes: you describe it, the agent previews it, you look at the real result, and if it's off you say change the review column to pending, it previews again, you nod, it lands.

The key is that you're reviewing the system's output, not the agent's account of its plan. The agent can say the wrong thing, but it can't fake this step's output. So the trust here isn't built on the agent never being wrong — it's that being wrong is fine, because you see it first.

Where this shows up​

Enough mechanism. Here's where it actually lives.

The Monday-morning deadline radar​

You've got seven or eight things going at once, and on Monday morning there's only one thing you want to know: what's about to blow up.

Tell an agent to build a board that tracks deadlines — overdue, this week, next week, no deadline set — and the four columns are there. Every Monday after that, whether the overdue column has anything in it is a glance.

This board has a reassuring property too: those columns are computed from time, so you can't break them. If you fumble a card into Overdue, the system won't take it upon itself to change your deadline to yesterday — it does nothing. Columns like these are made to be looked at.

A team workload view​

Anyone running a team has had the question: who's buried, and who's actually free?

A board with one column per teammate answers it, with a last column for the unassigned. Open it at standup and whose column is stacked, which work is still hanging, you can see without asking.

A board like this is for looking. It flattens work scattered everywhere onto one screen. When you actually need to change who does what, you go back to the task itself.

A content pipeline​

Blogging, videos, announcements — underneath they're the same pipeline: idea, drafting, review, published.

This is a board you drag on. Move a card from Drafting to Review and the status follows, the tag is added, because each column has stated what it holds and the system derives the rest. You just drag; it makes what you said come true.

The plan changed, so say one more sentence​

Two weeks in, you notice there's no home for archived items. Tell an agent to add an archived column; it takes the board's full current state, previews the change for you, and only lands it once you nod.

In another tool, changing a board means clicking through it again. Here it's a sentence, and getting it wrong doesn't matter, because you saw it before it took effect.

Once it's built, it's still yours​

That "add an archived column" works because the board isn't a trail left by clicks — it's something you can lift out whole.

Export it, edit it, put it back — all fine. That's also why the agent never has to guess when it changes the board: it gets the full current state, not a reconstruction from the UI.

A side benefit: the board can go into git, be handed to a colleague, be copied to another project. It's an asset of yours, not config locked inside some screen.

Your board, your design, none of the homework​

Boards all look alike because the tool made the trade-off for you: simple but dumb, or powerful but you have to learn it.

UnDercontrol's answer is that you decide what you want, the agent handles how, and the system keeps it from doing the wrong thing.

So the four-column deadline radar, the by-person team view, the board sliced along your own business dimension — none of these are features someone designed ahead of time. They're just the result of a sentence you said.

If you want to try it, describe the board you want to your agent. It knows what to do from there.

But there's a further question that rarely gets asked: can the AI operate the platform itself? Not just do work inside the system, but run it for you — tidy up boards, archive stale tasks, maintain tags, distill hard-won steps into a reusable capability.

UnDercontrol's answer comes from its core idea: Everything as Code. Because of it, AI here is both a teammate that does the work and an admin that keeps the system in order.

The core: Everything as Code — the platform is the AI's control surface​

In UnDercontrol, tasks, notes, boards, skills, custom fields — all of it is plain Markdown + YAML frontmatter, managed declaratively through one kubectl-style ud CLI:

# Creating or updating a task is just applying some text
cat <<'EOF' | ud apply -f -
---
title: Ship v1
status: in-progress
tags: [release, urgent]
metadata:
  priority: high
---
Pre-release checklist…
EOF

Here's the key: the same abilities an AI agent uses to read and write code — run commands, read and write text — work unchanged on the whole platform. It can create tasks, break out subtasks, change statuses, apply tags, build boards (a board is just a saved query), distill a repeated prompt into a new Skill, patch custom fields… Those management actions are themselves code.

In short: the AI isn't only a worker inside the platform — it can also be an admin, because managing the platform is itself programmable.

Typical scenarios

• "Archive everything marked done this week, then spin up a new board filtered by the release tag" — the agent just does it with ud apply / ud patch, no clicking around.
• "Save the debugging steps you just walked through as a Skill" — the agent turns the method from the conversation into a reusable Skill with ud apply, and the whole team can use it next time.

Breaking it down: the UnDercontrol agent workbench​

Agents as teammates. Write a requirement as a task, @mention an agent, and it claims the task, reads the description, notes, and links as context, writes code, runs tests, commits, and writes progress back into the notes. What it picks up isn't a black-box issue — it's structured Markdown it can also edit itself.

Daemon / runtime. The agent runs on your own dev machine — a background daemon stays connected over SSE and streams the terminal output back in real time. This remote workspace has been in the works since April 2026; today daemon registration, SSE, multi-surface triggering, and session viewing are all in place — you can start and monitor from the web, the desktop app, the CLI, even your phone.

Reusable skills. A Skill is a reusable prompt template stored on the server and injected into any agent via ud prompt. And because everything is code, an agent can write and revise Skills itself with ud apply — the skill library is a programmable asset that compounds over time.

Not tied to any one agent. UnDercontrol is agent-agnostic: an Agent CLI command template plugs in Claude Code, Codex, Cursor, Hermes, or any terminal-based agent. Whichever you pick, it drives the same AI agent CLI — so you can swap models or tools without swapping workbenches.

You own your data. Tasks and notes are plain Markdown files with YAML frontmatter, defined by an open JSON Schema (MIT) — version them with Git, export anytime, and self-host (Docker Compose / K8s, SQLite / Postgres).

Not just tasks: this Markdown editor and the everything-as-code foundation run through every surface of UnDercontrol — tasks, notes, even expenses and resources. The agent workbench isn't a separate module; it's a capability that grows out of that foundation.

Why "AI can operate the platform itself" matters​

In most tools, AI handles the execution layer (write code, run tests), while the management layer — tidying boards, archiving old tasks, maintaining a tag system, distilling experience into SOPs — still sits on humans.

When the platform itself is code, that line disappears: AI can share both execution and management. Your knowledge base is both content and a programmable control surface. You gain a teammate who does the work — and an admin who keeps the system in order.

Wrapping up​

The heart of an "agent workbench" is letting AI do the work reliably, leave durable output, and be directed. UnDercontrol goes one step further — via Everything as Code, it lets AI operate the platform itself:

• Tasks, boards, skills, and metadata are all plain Markdown + CLI-manageable code;
• so the same agent can both work inside the platform (write code, report progress) and operate the platform itself (build boards, archive, write Skills, maintain structure);
• all of it agent-agnostic, triggerable from any device, with your data your own.

In UnDercontrol, AI is both a teammate and an admin.

This is your side project MorningRun — a running social app, currently in Sprint 12. Five columns line up across the board: Todo, In Progress, Review, Deployed, Done. What hasn't started, what's stuck, what's waiting on someone else — you can see it all without opening a single task. Let's walk through a whole week with this one board.

Monday: drag from "Todo" to "In Progress"​

You grab a card — "Implement Google OAuth login" — and drag it from Todo to In Progress. The moment you let go, the task's status flips to "In Progress" on its own. No dropdown, no form.

That's the heart of kanban in UnDercontrol: columns are the stages of your workflow, and dragging is the status change. Whichever column a card lands in, the task's status, tags, even custom fields update to match. And it's instant — the same task in your task list is already in sync.

Tuesday: a card is more than a title​

You open that OAuth card. Inside isn't a single dry line — it's a full Markdown document: a requirements checklist, the technical approach, a couple of open questions. This is the task's living document, its single source of truth.

Below it you append a note: "Callback URL verified on the staging redirect — commit a1b2c3d." Notes are an append-only timeline that records how the work progressed, and each one keeps a full edit history you can roll back to anytime.

Not just tasks: UnDercontrol's editor is shared across every text surface. Task bodies, notes, expense memos, account notes — whatever you write, it's the same Markdown experience. Every card on the board is backed by a container that holds the complete picture.

Wednesday: customize a column, let the board do the chores​

The default columns are status-based. But your team added a code-review step, so you customize a column.

Open "Edit Column" and you only fill in three things:

• Column name: Review
• Match condition: status = 'pending' AND tags CONTAINS 'needs-review' — which cards land here
• Automatic action: when a card enters this column, auto-add the needs-review tag and @-mention your teammate

So when you drag the OAuth card into "Review," a few things happen on their own: the tag is added, your teammate gets pinged. A column's automatic actions are generated from its match condition, always in sync; for anything fancier you can add actions manually.

A few minutes later your teammate leaves a comment on the card: "The callback URL is missing the staging domain in the allow-list." You reply: "Good catch — added it 👍." Comments are a lightweight, threaded discussion — short and focused, back and forth, without switching to IM and without drowning in the body text. The body says "what it is," notes record "how it evolved," and comments are "let's quickly align on this one card."

One column isn't enough. You add a second custom column, "Deployed": match condition status = 'pending' AND tags CONTAINS 'deployed', and on enter it sets the status to done. Two custom columns later, the flow from review to shipped runs right on the board.

This is where kanban gets genuinely powerful — it doesn't just show, it works for you. Drag a card once, and all the status changes, tagging, and notifications happen in one move.

Thursday: columns don't have to be statuses​

Midweek, you realize status columns aren't enough. MorningRun ships next week, and what you really care about is "what must get done this week." So you spin up another board — "Release Sprint" — where the columns aren't Todo / Done but This Week / Next Week / Backlog.

Because behind every column is a query condition. "This Week" filters deadline <= this Sunday; "Backlog" filters status = 'todo' AND deadline IS NULL. A board is essentially a saved query, not a folder that holds things — so the same task can appear on both "Sprint 12" and "Release Sprint" with zero duplication.

Typical scenarios: one board to push daily development by status; another to plan priorities by time; a separate one per client project. Same set of tasks, several angles, each its own view.

Friday: share the board with your team​

MorningRun's designer is taking over the UI cards this week. You open the board settings, click "Share," and pick your team group. She sees the board immediately — but only the tasks that belong to that group; your own private tasks stay hidden. Who's read-only and who can move cards is controlled by permissions.

No extra sync meeting, no "where are we at?" pings. A shared board is where the team stays aligned.

The week, in summary​

This week you didn't hold a single "sync meeting" and didn't bounce between apps. One board showed you the whole MorningRun project:

• Drag = status change — columns are workflow stages, drop to update, synced instantly
• A card is a complete information container — Markdown body + notes timeline + comments behind every card
• Custom columns do the chores — auto-update status, tag, and notify from a match condition; two columns wired up the review-to-shipped flow
• Columns don't have to be statuses — This Week / Next Week / Backlog; a board is a saved query, not a folder
• A shared board = team alignment — only group tasks show, permissions controlled

Want to try it? Open UnDercontrol and drag your first card — and watch the status change itself.

2026-07-12 Blog Draft (scheduled)

Inside it: a complete blog draft. And in the comment thread, two messages left overnight:

01:01 — On it — topic scan done, picking task-management-overview. Drafting now.

01:03 — Done — draft is in the note. Task set to pending for review.

The author is not a person. It's an AI agent. While I was asleep, it picked a topic, checked the product docs, wrote the draft, moved the task to "pending review", and said hi in the comment thread.

I read the draft and replied with one line: "Too broad. Find one concrete use case and tell it as a story." A few minutes later, the draft had been rewritten — the post you are reading now is the product of that rewrite.

This post is about how that pipeline is built, and why a task system is the most comfortable handoff point between humans and AI.

A task is not just a to-do item​

First, a core design idea: in UnDercontrol, a task is a universal information container, not just a to-do.

A task can be:

• An actual to-do ("fix the validation bug on the login page")
• A document (a design proposal, meeting minutes, a wiki page)
• A decision record (why we chose option B)
• A blog draft (this post's draft lives as a note on a task)

The task body is Markdown. Combined with tags and custom metadata, you decide what a task is — instead of being boxed in by the tool's data structure.

The problem: I want a steady blog, without starting from zero every day​

Anyone building a product knows this: content needs to ship consistently, but the activation energy of writing is brutal. Picking a topic, gathering material, structuring, drafting — every step burns energy that should have gone into code.

Let the AI write and publish fully automatically? No. Content that ships without a human gatekeeper burns your own reputation.

What I wanted was a human–AI pipeline: the AI does the grunt work (topic dedup, doc research, first draft), and I only do the one step that's actually worth my time — judgment and feedback.

So the question becomes: where does the AI's work go? Where do I review it? How does feedback flow back?

The answer: all of it lives in the task system.

The pipeline: 24 hours in the life of one task​

There is no dedicated "AI platform" here. The pipeline is assembled from four native capabilities of the task system: scheduled jobs, @mentions, notes, and comments.

01:00 — The scheduled job fires

A daily scheduled job (CRON) creates the day's draft task. The task description is the complete instruction set for the AI, and it opens by @mentioning my agent:

[@ud-agent](mention://member/...)

Generate ONE blog DRAFT for review — do NOT run the full publish pipeline.

1. Pick a topic from `auto/blog-topics.json`. Skip topics already covered —
   check with `ud grep task "<slug>"`. Choose the first uncovered topic.
2. Write ONLY the text draft as a NOTE on THIS task.
3. Set THIS task status to `pending` and reply in the comment thread.

Notice the design here: the task description is the prompt. Instructions, boundaries ("do NOT publish"), acceptance criteria ("set to pending") — all written into the task. No separate configuration system needed. The task is the config.

01:01 — The @mention wakes the agent

The mention triggers an agent work session. It wakes up on my Mac, and the first thing it does is not writing — it's detective work:

• Read the topic list (a JSON file in the repo, 18 candidate topics)
• Search old tasks with ud grep task and ud query "tags CONTAINS 'blog'" to see which topics are already covered
• Sweep 27 historical blog tasks, find only 2 topics left uncovered — pick the first one

Then it leaves its first message in the comment thread ("On it — picking task-management-overview") before writing a word. It also reads the product docs to verify feature details first — an AI's worst habit is confidently making things up, and making it read the docs first cures most of that.

01:03 — The draft lands, the task flips to pending

The finished draft doesn't go to some "AI output panel" — it's attached to the task as a note. The task status is set to pending, which in our status model means "I'm done, waiting on someone else." The agent leaves a second message in the thread and clocks out.

The whole run took two minutes, and it happened after I fell asleep.

08:00 — I come online, and only judge

My review interface is just the task detail page: the draft in a note, the context in the description, the agent's work log in the comment thread. I don't need to open any other tool.

I read the draft and replied with one line in the thread. That line triggered a new agent session — it read the feedback, updated the same note via note_id (not a new note; notes keep full edit history, so a bad rewrite can always be rolled back), then replied in the thread describing what changed.

Back and forth, it feels like collaborating with a remote teammate through a ticket. Except this teammate starts work at 1 A.M. and never complains about rework.

Why the handoff point is a task, not a chat window​

The biggest problem with collaborating with AI in a chat window is that output sinks. What it wrote yesterday is fifty screens up today; switch sessions and the context is gone.

Make the handoff point a task, and every part of the exchange gets a native container:

• Task description = requirements and instructions (a living document, always current)
• Notes = deliverables and process records (an append-only timeline with edit history)
• Comments = lightweight conversation (short, threaded, with @ notifications)
• Status = position in the workflow (pending means "awaiting review" — one glance at the board shows everything waiting on you)

And humans and AI access all of it through the same entrance. I read on the web and my phone; the agent reads and writes from the terminal via the CLI:

ud describe task 51c4981e      # read the task (notes, comments, attachments included)
cat draft.md | ud apply -f -   # write a note

Because the entrance is CLI + Markdown, the pipeline is not tied to any specific AI tool — Claude Code, Codex, OpenCode, or any terminal-based agent can plug in. Swap the agent tomorrow; the pipeline doesn't change by a single line.

Where else this pattern applies​

The blog draft is just the most convenient example. The same loop — "scheduled job / @mention → agent works → notes for the record → pending for review → feedback in comments" — also runs our:

• Release verification: after CI ships a version, a task is created with the release notes attached; the agent runs smoke tests and writes results into a note
• Daily standup: a scheduled job creates a standup task every day; the agent summarizes yesterday's changes across all tasks
• Code research: throw "evaluate option X" at the agent, wake up to a comparison in the notes, ask follow-ups in the comments

There's only one common thread: every step of the AI's work stays in the task, and the human appears only at the checkpoints.

Takeaway​

This pipeline uses no concept invented specifically for AI. Scheduled jobs, @mentions, notes, comments, status — all of it is what a task system already has. It's just that when your task system meets three conditions, it naturally becomes a human–AI workbench:

1. Markdown-native — AI reads and writes without a translation layer
2. A CLI entrance — any terminal agent can plug in; no vendor lock-in
3. Status + comments + notes, all first-class — handoff, review, and records each have their place

One more thing: this very post is what the pipeline produced in the small hours of July 12, 2026. The version you just read is the second draft — written after a human replied with a single line: "Too broad. Find one concrete use case and tell it as a story."

Select-all and copy? You paste a mess of navigation bars, ads, recommendation widgets, and broken formatting. Send the link? Many AI tools can't fetch pages, and when they can, the result is often incomplete.

The UnDercontrol Web Clipper Chrome extension gives you a cleaner answer: click Copy Markdown, and the page's article content is extracted into tidy Markdown on your clipboard — no login, no account, no configuration. Install it and it works on any page. Paste it into Claude, ChatGPT, or any AI, and what it gets is pure content with zero noise.

Copy Markdown: copy, redesigned for the AI era​

This is the extension's most-used feature, and it doesn't depend on an UnDercontrol server at all:

• One-click copy: the page's article content lands on your clipboard as clean Markdown
• Smart extraction: powered by Readability + Turndown — ads, navigation, sidebars, and other non-content elements are stripped automatically
• Zero barrier: no sign-up, no login; works instantly on any page
• Robust: heavy elements like video and canvas are skipped automatically, so complex pages won't drag your browser down

Markdown is an AI's native language — clean structure, no markup noise. For the same article, pasting Markdown instead of a raw select-all copy gets you noticeably better comprehension and answers, and saves tokens too.

Save to Local: archive without logging in​

Local save also works without any login. One click downloads two files:

1. A complete HTML snapshot: built on the open-source SingleFile, it inlines HTML, CSS, images, and fonts into a single self-contained file that opens offline, exactly as the page looked
2. The extracted Markdown: the same clean article content that Copy Markdown produces

Links rot and pages get redesigned, but a snapshot is forever the page as it was the moment you saved it. Archive articles, research material, and time-sensitive pages — no server required.

Save to UnDercontrol: clipping joins your workflow​

If you use UnDercontrol (the extension connects via login or an API key — self-hosted instances work out of the box), clipping goes one step further: the page becomes a task.

• The Markdown content goes into the task description — readable and editable right inside the task
• The HTML snapshot is attached to the task, so you can always reconstruct the original page
• From there you get the full task toolkit: tags, kanban boards, links to other tasks, notes for your conclusions
• AI agents can reach it: through the ud CLI, Claude Code, Codex, OpenCode, or any terminal-based AI agent can read the task — the description already contains ready-to-use Markdown, so the agent never needs to scrape the web page itself

Here's a task produced by a real clip: the description starts with the source URL, the body is the extracted Markdown, and the full HTML snapshot hangs off the attachments panel:

In UnDercontrol, a task has never been just a to-do item — it's a universal information container. Web clipping is simply one more way for information to enter it.

Bonus: Bilibili video subtitles become transcripts​

Web Clipper also ships with Bilibili transcript extraction: on a Bilibili video page, the extension detects the video and lights up a Save Transcript button that turns CC or AI-generated subtitles into a formatted Markdown transcript — download it locally or save it as an UnDercontrol task. Finish a tech talk video, and the transcript is archived in one click; handing it to an AI for a summary is one more.

Typical scenarios​

• Feed your AI: copy a long article as Markdown and paste it into any AI to summarize, translate, or interrogate — far cleaner than pasting a link or a raw copy
• Read-later that actually happens: clip a worthwhile article into a task with a deadline; write your action items into the task notes when you're done
• Competitive research: clip competitors' pricing and feature pages into a research board — when they redesign next week, you still hold today's snapshot
• Bug evidence: a third-party page misbehaves? Clip a full snapshot onto the bug task; even after the page recovers, the scene is preserved
• Video study notes: turn a Bilibili tech video's subtitles into a Markdown transcript — archive it or let an AI distill the key points

Install and configure​

Install from the Chrome Web Store. Copy Markdown and local save work immediately with zero configuration; only "save as task" needs a connection to your UnDercontrol server — log in directly, or create an API key (starts with ak_) under Settings → API Keys in the web app.

Honest limitations​

• Chrome internal pages (chrome://, chrome-extension://) cannot be captured
• Full snapshots of pages heavy with dynamic content can take up to 2 minutes
• A snapshot is a point-in-time copy — it won't change when the original page does (which is exactly the point)

The Web Clipper browser extension itself is open source under AGPL-3.0: github.com/oatnil-top/ud-chrome-extension.

Wrapping up​

Without logging in, it's a clean "web page to Markdown + local archive" tool, born for feeding content to AI. Logged in, every clip lands in a task system with tags, kanban boards, and AI-agent access. Next time you want to hand a web page to an AI, try Copy Markdown first.

UnDercontrol doesn't impose structure. It gives you three composable layers: free-form tags, typed custom fields, and arbitrary key-value metadata. All three are directly queryable, so you can slice the same set of tasks along your dimensions instead of bending to the tool's taxonomy.

This rests on a core UnDercontrol idea: a task is not just a to-do — it's a universal container for information. The same Markdown editor runs across tasks, notes, expenses, and accounts — every text surface. Tags and custom fields are how you layer your own structure on top of that container.

1. Free-form tags: the lightest way to organize​

A tag is just free text you jot down — no predefined vocabulary, write whatever you want (work, urgent, client-acme, bug, all fine).

• Autocomplete built in: as you type, suggestions come from tags you've used before (ordered by recency) — free-form, yet you won't misspell or spawn ten spellings for one concept.
• Batch tagging: on the task search page you can add or remove tags across a batch of tasks at once, no need to open each one.
• Not only on tasks: tags also apply to resources (uploaded files), so you can thread files and tasks together with one shared vocabulary.

Tags themselves are a queryable array field:

tags CONTAINS 'work'                   -- has the work tag
tags IN ('work', 'personal')           -- has work or personal
tags CONTAINS_ALL ('work', 'urgent')   -- has both work and urgent

Typical scenario: a batch of related tasks lands on you — slap a shared q3-launch tag on all of them, then aggregate them from any board with tags CONTAINS 'q3-launch'. When the push is done, keep the tag as an archival breadcrumb, or batch-delete it.

2. Custom fields: typed, structured dimensions​

Tags solve "attach a word". But when what you track has a type and a value range — priority is a number, department is a fixed set of options, owner is a specific member — reach for custom fields.

On the Custom Fields page (/custom-fields, also reachable from a task's properties, the kanban menu, or the command palette) you define a field and pick its type:

• Text — free text value
• Number — numeric, supports comparisons
• Select — a fixed set of options you list up front
• Checkbox — a yes / no boolean
• User — pick a member from your workspace

You can also mark a field required. Once defined, the field shows up in task detail for inline editing, and the value is stored on that task.

Scope a field by tag​

Here's the key design choice: a custom field doesn't have to apply to every task. When you create a field you pick its scope:

• All tasks — every task shows this field
• Tasks with specific tags — only tasks carrying the chosen tags show the field

So "tags" and "custom fields" mesh naturally: a task's detail page only surfaces the fields that match its tags — irrelevant fields stay out of your way. Tag a task bug and "repro steps" / "severity" appear; tag it sales and "client" / "amount" show up instead.

Typical scenario: a team runs "engineering bugs" and "sales follow-ups" side by side. Scope the bug fields to the bug tag and the sales fields to the sales tag. In one board, each kind of task shows only its own field set, with no cross-talk — no need to split into two systems.

3. Arbitrary key-value: for the ad-hoc and the off-schema​

Not every piece of metadata is worth defining a field for. Task detail also has an extra metadata section where you drop arbitrary key-value pairs on a task (e.g. jira: PROJ-123, source: customer email) without declaring anything in settings first.

This layer is the buffer between "free tag" and "formal custom field": jot it down first, and once a key gets used often enough to become a stable dimension, promote it to a typed custom field.

Typical scenario: tasks synced in from an external system carry a pile of loose fields (ticket number, source link, external ID) — stash them as key-value pairs verbatim. Whichever key later turns out to need frequent filtering, formalize it into a custom field.

4. Querying them: the cf. prefix and kanban columns​

The real leverage of custom fields is that they're queryable just like built-in fields. Reference a custom field in a query with the cf. prefix:

cf.priority > 5                          -- priority above 5
cf.priority IN (1, 2, 3)                 -- priority is 1, 2, or 3
cf.department = 'engineering'            -- engineering department
cf.priority IS NULL                      -- tasks with no priority set
cf.priority > 5 AND status = 'todo'      -- high-priority todos
cf.priority > 5 ORDER BY updated_at DESC -- high priority, newest first

Custom fields combine freely with built-in fields (status, tags, deadline, …) in one query. And in UnDercontrol, every kanban column is essentially a saved query — so you can build a column called "High-priority todos" whose condition is cf.priority > 5 AND status = 'todo', and any task that matches drops into it automatically, no manual dragging. The task search page can surface custom fields as columns too.

Typical scenario: build a "by client" board for the team, one column per client, each column's condition cf.client = '...'; a new task snaps into place the moment its client field is filled. The same set of tasks becomes "by priority" or "by department" with a different query — the view follows the dimension, the data stays single-source.

Wrap-up​

UnDercontrol doesn't decide which dimensions your tasks should have — it hands you three layers to stack from light to heavy as needed:

• Free-form tags — zero-cost, jot-and-go, batchable, autocompleted
• Custom fields — typed (text / number / select / checkbox / user), optionally required, and scopable by tag
• Arbitrary key-value — for ad-hoc and off-schema info, promotable to a real field anytime

The common foundation under all three is one query language: tags CONTAINS_ALL(...), cf.priority > 5, freely combined with built-in fields, then frozen into kanban columns. The same set of tasks, sliced however you like — the structure is yours, not the tool's.

All of this rests on UnDercontrol's "a task is not just a to-do" idea: one unified information container, one editor across every text surface, plus tags and fields that let you define your own dimensions. Pair it with Claude Code, Codex, OpenCode, or any terminal-based agent to read and write this structured data — but you always keep the wheel on how it's organized.

UnDercontrol borrows the same idea, just with a different primitive: everything is a Task.

Most tools treat a "task" as a single line with a checkbox. UnDercontrol never did. Here, a Task is a universal information container — it can be a to-do, a document, a reminder, a blog draft, meeting minutes, a decision record, even a wiki page. One data source, organized your way, all in one place.

You don't hop between apps; an AI agent needs just one tool to reach everything you have.

Three content layers​

Every task is made of three layers, each with a design intent — but you're free to use them however you like:

The body is a living document where you keep the complete, coherent narrative; notes record progress over time (session start, each commit, blockers hit); comments are the quick conversation around the content. Clean separation — and all plain text, so both humans and AI read it directly, with no conversion.

A single task detail page makes the point: it's not one line of to-do, but a living document with a Markdown body, tags, status, deadline, a notes timeline, subtasks, and a relation graph.

One content, many views​

Because there's only one primitive underneath — the Task — UnDercontrol can offer many views over the same data, switchable anytime:

• List view: linear and filterable, great for scanning and batch work
• Kanban view: drag cards to change status, manage in-flight workflow visually
• Calendar view: laid out by deadline, so timing is obvious at a glance
• Tree view: expand parent-child relationships to see the hierarchy
• Graph view: traverse links, parents, and subtasks as a graph to see how knowledge connects

A board isn't "another container" — it's essentially a saved query. The same task can appear on many boards at once, with zero duplication. You change the perspective, not the data.

Six statuses that match real workflow​

Tasks support six statuses that fit how real work moves: todo, in-progress, pending (awaiting confirmation/review), done, archived, and stale. Dragging on the board updates status automatically — and status itself is information: one glance tells you where everything stands.

Tell things apart with tags and metadata, not folders​

If everything is a task, then a "document" and a "to-do" are structurally the same thing. What sets them apart is never the structure — it's tags, metadata, and views. UnDercontrol forces neither a tagging convention nor a folder hierarchy on you:

• Tags: free-form labels you define (doc, meeting, reminder — anything)
• First-class metadata: title, status, tags, deadline, assignee, links — the 20% that covers 80%
• Custom metadata: unlimited key-value pairs (doc_type: rfc, client: acme), all queryable too

When you need precise retrieval, UnDercontrol also gives you a SQL-like query language and natural-language queries — save common conditions as board columns and complex filtering is one step away.

Virtual folders + AI: organize information like files​

Prefer a "folder" style of organizing? UnDercontrol has that too — virtual folders. Every task carries a path field (a virtual path, a first-class part of the schema, e.g. /Work/Alpha/) that adds up to a familiar file tree in the app; drag to file things away. An empty path means "unfiled", / is the root, /Work/Alpha/ is a specific folder — and it's not just tasks: resources (attachments), skills, and other entities share the same virtual paths, placed in one tree.

It even syncs between local and cloud like Git: ud pull /Work/Alpha/ checks a virtual directory out into a local folder (creating a .ud/ to hold sync state, just like .git/), edit it with whatever editor you like, and ud push sends it back. To move a folder, just move it locally and ud push updates the cloud path.

What makes organizing truly effortless is adding AI. Because the whole structure is plain text plus paths, an AI agent can read your full picture and tidy it up for you:

• "Move all these scattered meeting notes under /Meetings/2026-Q3/" — the AI rewrites paths in bulk, one sentence
• "Organize this project's tasks into a clean folder structure" — the AI reads the content, decides where things belong, and reorganizes
• "Split this into subtasks and archive the old ones" — the AI handles the splitting, filing, and status changes together

Claude Code, Codex, OpenCode, or any terminal-based agent can do this through one uniform CLI. You do the thinking; the AI puts information where it belongs.

Bi-directional links: weave tasks into a knowledge graph​

Tasks can connect in several ways: peer links relate two things; parent/subtask relationships break a big goal into executable steps. With the graph view, your task base becomes a traversable knowledge network rather than a pile of isolated entries.

Inside the body, notes, and comments you can also reference other entities with Markdown links — another task [Title](task://...), a note [## Heading](note://...), an @mention [@name](mention://member/...), even an embedded uploaded image ![shot](resource://...). The whole base is interconnected.

Not just tasks: one editor across every text surface​

"Everything is a task" has one more layer: UnDercontrol's Markdown editor is not task-only — it's reused everywhere you write in the app: task bodies, notes, even the memos on finance records (expenses, accounts). The editing experience, Markdown syntax, and embedded links and images you know from tasks are identical elsewhere. Learn it once, use it everywhere.

Attachments and collaboration​

Tasks let you drag files in or paste from the clipboard — screenshots, design mockups, documents stay next to the task they belong to. Storage can be local or S3-compatible object storage; your data stays under your control.

For collaboration, tasks are shared through groups with role-based read/write permissions. The same task can appear on a shared board where teammates discuss and update progress — you share the information, not your whole account.

Typical scenarios​

• Personal knowledge base: keep meeting notes, decision records, and reading notes all as tagged tasks; retrieve them anytime with queries and boards — one app holds it all.
• AI agent collaboration: Claude Code, Codex, OpenCode, or any terminal-based agent reads and writes tasks, appends notes, and records progress through one uniform CLI — human and AI share one source of truth.
• Product/engineering pipeline: requirements in the task body, progress in notes, review comments in comments; track status flow on a board and see dependencies in the graph.
• Content creation: a blog's Chinese draft, English draft, and social copy each live as a note; the task itself is the Single Source of Truth, and everything published outward is derived from it.

In summary​

Everything is a task — not just a slogan, but UnDercontrol's underlying design: a Markdown-native, AI-ready universal container, with many views, six statuses, bi-directional links, flexible tags and metadata, and one editor across the whole app. No more shuttling things between a to-do tool, a notes tool, and a docs tool — it all belongs in one place.

Start here​

• 🏠 Website & docs: oatnil.com
• 📦 CLI installation guide: oatnil.com/docs/cli
• 💻 Desktop App & self-hosting: oatnil.com/subscribe

One universal container, one home for all your work — try it now with npm install -g @oatnil/ud.

In one sentence: ud pull checks your cloud tasks, notes, and attachments out as local Markdown files, and ud push sends your local edits back. As natural as git clone and git push.

Many working copies, one server, edit from anywhere.

Why we built this​

UnDercontrol has always been built on one core belief: your data is yours. Tasks, notes, ledgers, resources — every piece of text is plain Markdown, never locked into any single app.

But "exportable" isn't enough. What developers actually want is to treat that content as local files — edit it with their favorite editor, feed it to AI tools, and sync the changes back when done.

So we built a git-style command-line sync: ud init / ud pull / ud push / ud status. There are no new concepts to learn — if you know git, you already know how to use it.

Three commands, the exact same mental model as git​

The first ud pull /Work/Alpha/ binds the current directory to the virtual path /Work/Alpha/: a .ud/ folder appears to hold sync state (just like .git/), and the contents of /Work/Alpha/ land directly in the folder. Every ud pull after that is incremental — only changed items are downloaded.

# In an empty folder, init + checkout in one step
ud pull /Work/Alpha/

# Later: incrementally pull all tracked paths
ud pull

# See what changed on both sides
ud status

# Push local changes back (shows a change list for confirmation first)
ud push

What it looks like locally: a task is a folder, a note is a file​

The checked-out structure exactly mirrors the virtual folder hierarchy inside UnDercontrol:

Alpha/
├── .ud/                      # sync state (like .git/)
│   └── tracking.json
├── Design-Doc/               # one task = one folder
│   ├── index.md              # task body (YAML frontmatter + description)
│   ├── Kickoff-notes.md      # every note = one .md file
│   └── Review-notes.md
├── Sprint-Plan/
│   └── index.md
└── architecture.png          # resources = plain files, placed by virtual path

Open index.md and it's clean Markdown:

---
id: 8f3c...
title: Design Doc
status: in-progress
tags: [design, alpha]
deadline: 2026-07-20
---

## Background
The task description body goes here…

A few deliberate design choices:

• Content is stored verbatim — in-app links like resource://, task://, and note:// stay exactly as they are. Sync is a byte-level round-trip; your content is never rewritten.
• The virtual path is not written into frontmatter — the folder's location on disk is the single source of the path. Want to move a task to another directory? Move the folder locally, and ud push updates the cloud path.
• File names are sanitized, with the original names kept in .ud/tracking.json — special characters and non-ASCII names are handled for you.

On push, ud figures out what you did​

ud push compares your working directory against the "last known state" in .ud/tracking.json, item by item, and infers the right action:

In other words: create a My-Idea.md file locally, run ud push, and it becomes a task in UnDercontrol. And the other way around: a task created in the cloud shows up locally after ud pull. Truly bidirectional.

Conflicts: like git, nothing gets silently overwritten​

If the same task was modified both locally and in the cloud, ud marks it as a conflict:

• ud push skips conflicting items by default (and tells you to pull first), or use --force to overwrite the cloud.
• ud pull keeps the local version by default, or use --keep-remote to let the cloud win.
• In an interactive session, it asks you item by item which version to keep.

Run ud status first, then decide — no data is ever silently lost.

Many working copies, one server, anywhere​

In git's model, one origin can have any number of local clones. ud works the same way — on top of one server, you can have any number of local tracked folders, each bound to a different virtual path:

Laptop              Desktop            Another Mac / server
~/work/alpha  →     D:\notes\alpha  →   ~/proj-x
  binds /Work/Alpha/   binds /Work/Alpha/  binds /Projects/proj-x/
        \                 |                    /
         \                |                   /
          ┌──────────────────────────────────┐
          │      one UnDercontrol server      │
          │ (virtual folders = source of truth)│
          └──────────────────────────────────┘

This buys you a few very practical things:

• One repo per place, fully independent: /Work/Alpha/ and /Projects/proj-x/ are separate tracking roots, each with its own .ud/ state. Check out only the slice you care about right now instead of pulling your entire knowledge base.
• View and edit from anywhere: on any device, ud pull gets you the latest, and ud push syncs your edits to everyone and every client. On your phone? Just open the Web or desktop App — same server, same data.
• Humans and AI share one source of truth: you edit in Obsidian on your laptop, an AI agent edits via the CLI on a server, teammates edit in the App — everything converges on the same virtual path on the same server, and ud status always shows who changed what.

In short: the server is the single source of truth, and local folders are just its working copies. It's the model git has validated for twenty years — applied to your tasks and knowledge base instead of code.

Not just tasks: your whole knowledge base as files​

This part matters: UnDercontrol's Markdown editor is shared across every text surface — tasks, notes, even the memo fields on expenses and accounts are all the same Markdown. So what ud pull checks out isn't an isolated "todo-list export" — it's a local mirror of your entire knowledge base, ready to be opened, edited, and pushed back with any tool.

Typical scenarios​

• Manage tasks in Obsidian / VS Code: ud pull into your vault, enjoy your familiar editor, keybindings, and plugins, then ud push when done.
• Let AI agents read and write your tasks directly: hand the synced folder to Claude Code, Codex, OpenCode, or any terminal-based agent — it can read task context, append notes, even batch-create tasks, because to the agent they're just ordinary local .md files.
• Keep tasks next to your code: run ud init /Projects/proj-x/ in the project root and version design docs and decision records right alongside the code.
• Write offline: edit local files on a plane or in the subway; one ud push syncs everything once you're back online.
• Local backup: a single ud pull is a plain-text, human-readable, never-expiring full backup.

Get started in three steps​

UnDercontrol is a workbench that puts tasks, knowledge base, and AI agents in one place, with a desktop App and self-hosting support — your data stays private, portable, and yours.

1️⃣ Install the CLI (30 seconds)

npm install -g @oatnil/ud
# Don't want to install? Use npx:
npx @oatnil/ud --help

2️⃣ Pull, then edit with whatever you like

ud pull /Work/     # check a virtual directory out locally
ud status          # see what changed on both sides
ud push            # push it back

3️⃣ Grab the desktop App / self-host your own server

Want a GUI, multi-device access, or the whole server running on your own machine? See the links below.

Start here​

• 🏠 Website & docs: oatnil.com
• 📦 CLI installation guide: oatnil.com/docs/cli
• 💻 Desktop App & self-hosting: oatnil.com/subscribe

Your data, your format, your tools. UnDercontrol just makes them flow — try it now with npm install -g @oatnil/ud.

So why are your tasks, notes, and todos still locked inside some SaaS database, reachable only by clicking through its UI one item at a time?

UnDercontrol's answer is Everything as Code. Here, a task is a piece of Markdown with YAML frontmatter. That's it.

What a Task Looks Like​

---
title: Add a smoke test to the release flow
status: in-progress
tags: [release, testing]
deadline: 2026-07-10
---
## Goal
Run the critical path automatically before every release; block the tag on failure.

## Steps
- [x] Log in + create task
- [ ] Browse the three core pages
- [ ] Assert no console errors

The frontmatter is the task's structured metadata: title, status, tags, deadline, assignee, links — the 20% of fields that cover 80% of cases are all first-class, and all queryable. The body below the frontmatter is the task's canonical document (the Single Source of Truth): a living piece of Markdown.

No proprietary format. No binary blob to export. No vendor lock-in. What you see is all there is.

apply, Just Like kubectl​

Save that Markdown to a file, then:

ud apply -f task.md

The rules are exactly like kubectl apply: no id in the frontmatter means create, an id means update. apply is a full replace — the file is the source of truth.

Want to export in bulk, edit, and push it all back? ud get task -o apply prints your tasks in the same format apply accepts — a lossless round-trip. That means your task list can be processed like code with sed / jq / any script, then applied back in one shot.

Why This Is a Superpower for Developers (and AI)​

1. Version-controllable, GitOps-friendly. Tasks are plain text, so they naturally diff, live in Git, and go through PR review. Your project plan and your code can share the same commit history.

2. Native I/O for AI agents. Markdown is human-readable and AI-readable. Any terminal-based coding agent — Claude Code, Codex, OpenCode, or any agent that lives in your shell — can read and write your tasks directly through the ud CLI, with no special plugin or SDK. The whole knowledge base is plain-text-native and AI-ready.

# things an agent can do right in your terminal
ud get task 'status = in-progress'
ud apply -f new-task.md
ud describe task 8b30140e

3. Scriptable and composable. A SQL-like query syntax plus kubectl-style verbs (get / describe / apply / delete / patch) turn task management into something you can drop into any automation. Create a task in CI, bulk-retag from a script, generate a weekly report from cron — each is just a few lines of shell.

Not Just Tasks​

Here's a detail that's easy to miss: UnDercontrol's Markdown editor is not task-specific. It's a single editor shared across every text surface — tasks, notes, even expense and account memos all use the same editing experience and the same Markdown core.

So the "Everything" in "Everything as Code" is literal: your todos are Markdown, your notes are Markdown, the memo on an expense you logged is Markdown. One data source, organized the way you like, all in one place. No switching between apps, and an AI agent only has to learn a single tool to reach all of your information.

Three Content Layers​

Each information unit has three layers. Each has a design intent, but you're free to use them however suits you:

What distinguishes a "doc" from a "task" isn't the data structure — it's tags, metadata, and the view. UnDercontrol doesn't force a folder hierarchy or a tagging convention on you: the same task can appear on multiple boards (a board is a saved query, not a container, so there's no duplication).

Get Started​

If you're tired of trapping your ideas inside a UI, try turning them into Markdown you can apply:

ud apply -f my-first-task.md

Everything as Code isn't just a slogan — it's how your tasks, your scripts, and your AI agents finally speak the same language.

Web App — Remote Access, Zero Install​

UnDercontrol's web frontend is built with Vite + React + TypeScript and serves as the foundation of the entire platform. Open a browser and you're in — no installation required.

Core capabilities:

• Full task, budget, and expense management
• Tiptap rich-text editor (code blocks, Mermaid diagrams, tables, checklists)
• AI chat integration (supports Claude, OpenAI, and other providers)
• SSE real-time notifications with multi-tab sync
• Responsive design that works on mobile
• Bilingual interface (Chinese / English)

The web app also serves as the rendering layer for the Electron desktop app — same codebase, zero duplication.

Typical scenarios

• On the go, quickly check task progress or approve expenses from your phone's browser
• Team members collaborate instantly — just open a link, no software to install
• The convergence point for all clients — docs pushed from CLI, tasks created on desktop, pages clipped by the extension — all viewable and manageable in one place

Electron Desktop App — Offline First, Local Data​

The desktop app is far more than a web wrapper. It embeds a full Go backend and SQLite database, ready to use out of the box with no server configuration.

Embedded backend architecture

• Automatically launches the Go backend on startup
• Dynamic port allocation to avoid conflicts
• Data stored in ~/Library/Application Support/UnDercontrol/ (macOS)
• Fully offline-capable — works without any network connection

Remote backend mode

• The desktop app can also connect to a remote server, sharing the same data source as the web app
• Switch the API address in settings — no reinstallation needed

Daemon mode

• Background daemon process that listens to the task queue via SSE
• Receives and automatically executes remotely dispatched tasks — ideal for AI Agent workflows

Desktop-exclusive features

• System tray (Windows) — minimize to tray for quick access
• .md file association — double-click a Markdown file to open it in UnDercontrol
• Multi-window editing — open multiple editor, task, and sticky-note windows simultaneously
• Workspace management — local terminal windows for running commands

Build targets

• macOS — DMG installer, Universal Binary (x64 + ARM64)
• Windows — NSIS installer (x64)
• Linux — AppImage (x64)

Typical scenarios

• On a plane or train with no network — create tasks and edit documents as usual; everything syncs when you're back online
• At home, connect the desktop app to your company server — see exactly the same data as the web app
• Receive remotely dispatched AI tasks via Daemon and execute them automatically on your local machine

CLI — kubectl-Style, AI Agent Friendly​

The ud CLI is a terminal tool designed for developers and automation, using a kubectl-style verb-resource command system.

Interactive TUI

Run ud to enter a full-screen TUI for browsing and managing tasks with your keyboard.

One-liner operations

ud get task                          # list tasks
ud describe task abc123              # view details
ud apply -f task.md                  # create/update from file
ud task query "status:todo tag:api"  # query and filter
ud task nl "tasks completed last week" # natural language query

AI Agent integration

ud prompt <skill-name> outputs skill documents that teach AI Agents (Claude Code, Codex, OpenCode, and others) how to operate tasks via the ud CLI. Structured command output and Markdown-formatted input make it a natural fit for AI Agents to read and write.

Typical scenarios

• CI/CD pipelines automatically push release notes to ud — the team reads them on the web, no need to dig through Git logs
• Technical docs in your code repo (architecture designs, API specs, runbooks) are synced to ud via scripts — non-developers can read them on the web without accessing the repository
• AI Agents automatically record progress and decisions in task notes during coding — the team sees updates in real time
• Ops scripts periodically collect inspection results and ud apply them as tasks, forming a traceable operations log

Chrome Extension — One-Click Clipping​

The Chrome extension turns any web page into an UnDercontrol task.

• One-click save — captures a full page snapshot (HTML + all embedded resources)
• Markdown extraction — automatically extracts the page body as clean Markdown
• Offline mode — save directly to local disk without logging in
• Remote mode — log in to create an UnDercontrol task directly, with the snapshot uploaded as an attachment

Typical scenarios

• Researching competitors — clip product pages as tasks, then compare and organize on the web later
• Found a great technical article — clip it as Markdown into ud for the team to share
• Received a customer bug report on a web page — clip it as a bug task with full context attached

SSE Real-Time Sync​

All clients connected to the same backend — whether browser tabs, the desktop app, or another device — stay in sync via SSE (Server-Sent Events).

• Task status changes, new comments, attachment uploads — all events pushed in real time
• Daemon SSE Hub dispatches commands to desktop Daemon instances
• Workspace session state is automatically coordinated between the desktop app and the backend

One Codebase, Consistent Experience​

UnDercontrol's multi-platform strategy isn't "build once for each platform." Instead:

• Web app is the single frontend codebase
• Electron loads the web build directly — zero code duplication
• CLI shares the same API and data model
• Chrome extension uses the same API endpoints

And there's more — the open API lets you build any client you want.

Beyond Official Clients — Build Your Own​

Beyond the four official clients, UnDercontrol exposes a full RESTful API. Generate an API Key in your profile settings, pair it with the Swagger docs, and build your own client in any language — Python scripts, automation bots, internal tool integrations, or even your own mobile app.

• API Key authentication — generate in Profile → API Key, call with Bearer Token
• Scoped permissions — authorize independently by module (Tasks, Expenses, Budgets, Files, AI)
• Swagger docs — browse all endpoints at https://your-server/swagger/index.html
• X-UD-Channel audit — custom channel identifier to trace every request's origin
• CI/CD friendly — environment variable configuration for seamless automation pipeline integration

Typical scenarios

• Build a Slack Bot in Python — your team types /task in Slack to create and query ud tasks
• Connect your internal admin panel's ticketing system to ud via API for bidirectional status sync
• Build a native mobile app calling the same API for a personalized phone experience
• Monitoring system alerts automatically create ud tasks with context attached — on-call engineers handle them on the web

Different scenarios, the right tool for the job — data always in sync, experience always consistent.

In UnDercontrol, a Task is the core unit of information. If you've used Jira, think of it as an Issue; if you've used Obsidian, think of it as a Note. A Task is essentially a piece of content bound to a status, with first-class attributes (title, tags, link relationships, etc.) and support for unlimited custom metadata fields (key-value pairs), so you can attach any information to it. Through the Notes mechanism, a Task can continuously evolve — recording progress, discussions, and decisions, accumulating into a complete knowledge context over time.

This post covers the rich-text capabilities shared across all text input surfaces in UnDercontrol. We say "tasks", but it's not just tasks — whether it's a task description, a note, an expense memo, or an account annotation, they all use the same Markdown editor. The code blocks, Mermaid diagrams, tables, and checklists you use in tasks work identically in notes and every other context.

WYSIWYG — A Markdown Editor Built on Tiptap 3​

UnDercontrol's editor is built on Tiptap 3. You can write directly in Markdown syntax or use the visual toolbar — the editor renders in real time, what you write is what you see. No switching between "edit mode" and "preview mode" — the input is the final output.

The editor also supports switching to Source Mode to view and edit the raw Markdown directly — for users who prefer plain text editing or need precise format control, you can freely toggle between WYSIWYG and raw Markdown at any time.

Slash Commands — Format Without Leaving the Keyboard​

Type / anywhere to open the command menu. Insert headings, code blocks, tables, Mermaid diagrams, checklists, and more — all without touching the mouse.

The slash menu supports:

• Headings (H1–H5) for document structure
• Task lists with interactive checkboxes
• Code blocks with language selection and syntax highlighting
• Mermaid diagrams for flowcharts, sequence diagrams, and more
• Tables with full cell editing
• Blockquotes, dividers, and images

Syntax-Highlighted Code Blocks​

Paste code snippets directly into your tasks. The editor supports 100+ programming languages with proper syntax highlighting — from TypeScript and Go to SQL and YAML.

Code blocks include a language selector dropdown and a one-click copy button. Your code stays readable and properly formatted, whether you're documenting an API endpoint or saving a useful shell command.

Mermaid Diagrams — Visualize Architecture Inline​

One of the most powerful features: embed Mermaid diagrams directly in your task descriptions. Insert a Mermaid block via the slash menu, write your diagram syntax, and it renders live.

Supported diagram types include:

• Flowcharts — system architecture, decision trees
• Sequence diagrams — API flows, authentication handshakes
• Class diagrams — data models, entity relationships
• State diagrams — workflow states, lifecycle tracking

The diagram viewer supports fullscreen preview, SVG download, and automatic dark/light theme switching.

Tables for Structured Data​

Need to document status codes, compare metrics, or track a feature matrix? Insert a table and edit cells directly. Add or remove rows and columns, toggle header rows, and merge cells — all from a context menu.

Checklists That Actually Work​

Task lists render as interactive checkboxes. Check items off directly in the rendered view — no need to switch to edit mode. Great for tracking sub-steps, acceptance criteria, or deployment checklists.

Images & Attachments — No More Obsidian-Style Resource Management Headaches​

If you've managed notes with images in Obsidian, you've probably experienced the pain: images scattered across local folders, paths break when you move things, attachments disappear on another device, multi-device sync creates endless conflicts. The root cause — Obsidian delegates resource management to the filesystem, and filesystems are inherently bad at cross-device sync.

UnDercontrol solves this at the foundation. All images and attachments are managed through the resource:// protocol — upload once, stored in the database, no dependency on local paths. Whether you view content on the web, desktop, or via a shared link, images are always available — because resources follow the database, not the filesystem.

UnDercontrol also provides bidirectional local folder sync, keeping files in a local directory synchronized with the server resource library. We'll cover this feature in detail in a future post.

Image Size Control

Inserted images support three size presets — hover in edit mode to switch:

• Small (25%) — thumbnail, suitable for inline display
• Medium (50%) — moderate size
• Large (100%) — full width

Size information is stored in Obsidian-compatible format (![description|s](resource://id)). Click any image for fullscreen preview.

Draw.io Diagrams — Built-in Visual Drawing​

UnDercontrol includes a built-in Draw.io editor, supporting .drawio and .drawio.png formats. Upload or create a Draw.io file, then edit it directly in the app — no desktop software needed. Saved as PNG with embedded XML source data, so it renders as a preview and can be re-edited at any time.

Thanks to the resource:// protocol, Draw.io diagrams are managed as unified resources — no local path dependencies or sync issues.

AI-Powered Text Actions​

Select any text to reveal the bubble menu. Beyond standard formatting (bold, italic, strikethrough), you get AI-powered actions:

• Refine — rewrite selected text for clarity
• Translate — translate to another language instantly
• Chat — ask questions about the selected content

Entity Links — Connect Tasks Like a Wiki​

Link to other tasks, notes, expenses, budgets, and accounts directly in your descriptions using custom protocols like task://, note://, and more. The links render as clickable references — click to jump straight to the referenced entity.

Switch to source mode to see the raw markdown — each link uses a custom protocol like [API Integration Guide](task://189571b0-...):

This turns your task descriptions into a connected wiki, where context flows naturally between related items.

CLI + AI Agent — Let AI Write Your Content​

Because Markdown is plain text, it's a natural fit for AI agent collaboration. Through the ud CLI, you can let Claude Code, Codex, OpenCode, or any terminal-based AI tool read, write, and update task content directly:

• Summarize — have AI read a set of tasks and generate a weekly report or sprint review
• Refine & restructure — turn scattered notes into structured documentation
• Classify & tag — automatically add tags and categories based on content
• Batch create — generate multiple tasks from meeting notes or requirement docs

Content pipes directly in:

cat <<'EOF' | ud apply -f -
---
title: API Integration Guide
status: in-progress
tags: [api, backend]
---
## Authentication Flow

1. Client sends credentials to `/auth/login`
2. Server returns JWT token
3. Include in `Authorization: Bearer <token>` header
EOF

AI-generated Markdown renders identically to hand-written Markdown across web, desktop, and shared views. Your content stays portable and version-controllable.

Markdown support in UnDercontrol means your tasks can be as detailed and technical as they need to be — without leaving the tool where the work gets tracked. Code blocks, diagrams, tables, and checklists all live alongside your task status, deadlines, and collaboration context.

Try it out — create a task and type / to see what's possible.

That's Remote Workspace. It bridges the gap between a cloud-based task manager and your local development environment, turning UnDercontrol into a remote control for AI-powered coding agents.

The Problem​

Most task management tools live entirely in the browser. Your code lives on your machine. When you want an AI agent to work on something, you switch to a terminal, paste context, babysit the process, and manually update the task when it's done. The task tracker and the execution environment are two separate worlds.

Remote Workspace collapses that distance. Your task descriptions become executable instructions. Your browser becomes a control panel. Your machine does the work.

How It Works​

The architecture has four pieces:

1. The Electron Desktop App — runs on your machine and acts as the daemon. When you register your device in the Workspaces page, the app connects to the UnDercontrol server via Server-Sent Events (SSE) and waits for instructions.

2. The Server — relays commands between the web UI and the daemon. Persists session state, notes, and status updates.

3. The Daemon Core — the "brain" inside the Electron renderer. It holds auth tokens, manages SSE connections, and drives all API calls. When a workspace session starts, it forwards the init event to the Electron main process.

4. The AI Agent — a coding tool (like Claude Code) spawned in a pseudo-terminal by the Electron main process. It reads the task, does the work, and reports progress through task notes.

Setting It Up​

Open the UnDercontrol desktop app and navigate to the Workspaces page. Click Register this device — the app detects your machine name and platform automatically. That's it. Your machine is now a daemon, connected and ready.

The Electron app handles everything behind the scenes: daemon registration, SSE connection, heartbeat, and reconnection. No terminal commands needed.

For the AI agent to work, you'll need Claude Code installed on your machine:

npm install -g @anthropic-ai/claude-code

Triggering a Session​

Once your device is registered and online, go to any task in the web UI (or the desktop app itself). Click the globe icon in the actions bar. You'll see a list of your connected daemons — pick one, and the session starts.

The daemon receives the init event, and the Electron main process spawns the AI agent in a PTY window. From this point, everything happens automatically:

1. The agent reads the task description and notes
2. It plans and executes the work
3. Progress notes appear on the task in real-time
4. When done, it updates the task status

Watching It Work​

This is where it gets satisfying. As the agent runs on your machine, you see its progress in the browser — live.

Notes stream in as the agent works: what it's reading, what it changed, which files it committed. You get a running log of the entire session without touching the terminal.

The session panel shows:

• Status — running, planning, awaiting input, idle, or stopped
• Duration — how long the session has been active
• Daemon info — which machine is doing the work
• Notes stream — real-time updates from the agent

Interactive Control​

Remote Workspace isn't fire-and-forget. You can interact with the agent while it's running:

• Send instructions — type additional context or redirect the agent mid-task
• Take screenshots — capture the current state of the workspace
• Interrupt — send a Ctrl+C signal to pause execution
• Stop — end the session entirely

There's also a prompt system. Save frequently-used instructions as templates, and apply them with one click. If you've set up skills in UnDercontrol, you can reference those too — pipe a skill's content directly to the agent.

The Workspaces Dashboard​

The Workspaces page gives you a bird's-eye view of all active sessions and connected daemons.

Each session card shows the task it's working on, which daemon is running it, how long it's been going, and the latest notes. Daemons are listed with their online/offline status, machine name, platform, and sharing permissions.

You can register your device right from this page — one click and you're online.

Security​

Running AI agents remotely raises obvious safety questions. Remote Workspace handles this with a layered blacklist system:

Built-in protections:

• Tools like bash, sh, zsh are blocked as the implementation tool — the agent runs through a controlled interface, not a raw shell
• Destructive commands (rm -rf, mkfs, dd) are blocked at the daemon level

Custom configuration: Drop a YAML file at ~/.config/ud/workspace-blacklist.yml to define your own rules:

blocked_tools:
  - bash
  - sh
allowed_tools:
  - claude
blocked_commands:
  - "rm -rf"
  - "mkfs"

The daemon also requires proper authentication — the Electron app uses your logged-in session tokens, so unauthorized access isn't possible without your credentials.

Sharing Daemons​

In team setups, you can share a daemon with your group. Set the sharing permissions so teammates can trigger workspace sessions on your machine — useful for shared build servers or dedicated CI machines.

Sharing is controlled through the daemon's permissions: read-only lets others see the daemon status, read-write lets them initiate sessions.

Why This Matters​

Most developer tools treat task management and code execution as separate concerns. You plan in one app, execute in another, and manually bridge the gap with copy-paste and context switching.

Remote Workspace merges them. Your task description is the instruction. Your browser is the control panel. The work happens on your machine, with your tools, in your environment — you just don't have to be in the terminal to start it.

For solo developers, it means less context switching. Write the task, trigger the agent, review the output — all in the same interface. For teams, it means a shared queue of work that machines can pick up and execute, with full visibility into what's happening.

The architecture also means you're not locked into any particular AI tool. Today it works with Claude Code; tomorrow it could work with any agent that runs in a terminal. The protocol is simple: receive a task, do the work, report progress.

Getting Started​

1. Download the UnDercontrol desktop app
2. Install Claude Code: npm install -g @anthropic-ai/claude-code
3. Open the Workspaces page and click Register this device
4. Open any task, click the globe icon, and select your daemon

Check the documentation for the full setup guide, including security configuration and troubleshooting.