Repository navigation
Releases
v0.31.2 — Navbar machine stats & a context bar for every provider
v0.31.2 — Navbar machine stats & a context bar for every provider
Two navbar upgrades: the TUI title row now shows live machine stats
(CPU %, system RAM %, tagent's own RSS — sampled every 2 s), and the
context bar works for EVERY provider. Unknown models / custom providers
used to resolve a context window of 0 — which hid the bar entirely; the
display now falls back to an assumed 128k window, marked so you always
know what's real and what's estimated.
Added — machine stats in the navbar
- new perf-stats.ts — PerfSampler: cpu % (delta between os.cpus()
snapshots), system RAM % (freemem/totalmem), tagent's own RSS; a 2 s
unref'd interval, O(1) get(), and a sample older than 15 s is
recomputed on read (a suspended laptop no longer shows frozen numbers) - the stats ride the title row's free dash space (roundBox titleRight,
shown at boxW>=58): "🖥 12% · 💾 62% · 210M" — the border row stays
EXACTLY boxW wide, hard-truncated both sides, never wrapped (the
v0.31.1 sticky-math lesson applied from the start) - numbers stay quiet by default — they only take color at cpu>=70% or
RAM>=80% (the bar that matters when the machine is choking)
Added — a context bar for every provider
- the gap, proven: modelContextWindow("custom", "mystery-model-v9")
resolved 0 — custom providers and unlisted models showed NO context
bar at all, while the loop already emitted estimated usage every turn - new ASSUMED_CONTEXT_WINDOW = 128_000 (core/context.ts): the display
falls back to it when the catalog, the registry and
TAGENT_CONTEXT_WINDOW all miss — marked "128k"; estimated usage is" too ("~12.3k/~128k [█░] 10%")
marked " - precedence unchanged: TAGENT_CONTEXT_WINDOW and every real
catalog/registry value always beat the assumption — a known model
never gets a "~" it didn't earn
Fixed — the bar survives (priority + hot-path)
- hint-row priority fit: a long custom model id shrinks first (down to
4 cols) instead of crowding the context bar out of the row - navbar footer ladder: segments shrink or drop in the order ws →
model → -dev → -mcp → -ws → -model before the bar ever does — mode ·
bar · clock survive at every width (verified live at 50 cols) - host.contextInfo() gains a 500 ms cache — the estimated-usage path
walked every session message and read zai-models.json per frame (a
per-render hot path; a perf fix as much as a feature)
/stats & tests
- /stats grows a machine row (cpu · ram · rss · uptime) plus the
"(window assumed 128k)" / "(used estimated)" markers, so the numbers
in the navbar are explainable - new scripts/test-perf-stats.ts — 37 checks: sampler lifecycle
(start/stop/stale-recompute), roundBox exact-width invariants,
bar markers, the gap proof, the host fallback chain (unknown → assumed
128k · glm → 131072 · env wins · fromLoop usage with no window), live
TUI frames at 80/120/50 cols - regression battery green: render-guard 27 · memory-profile 24 ·
glitch-proof.py live-pty 6/6 (the render guard holds with the new
navbar); tsc 117 = baseline, 0 new; PTY suite 10/11 — the one fail
("model list view") is pre-existing on a clean stash, recorded known
Upgrade note
- drop-in: nothing to configure — the stats appear at boxW>=58, the
context bar appears for every provider; if you know the real window
of an unlisted model, TAGENT_CONTEXT_WINDOW= beats the
assumption
v0.31.1 — Small-RAM profiles & render-guard fixes
v0.31.1 — Small-RAM profiles & render-guard fixes
Two stability fixes for the machines tagent actually runs on: a RAM
profile (performance.ramGb — 0 = auto-detect) that scales the TUI
transcript retention, subagent parallelism, the web cache and the
context diet to the machine budget — and the root-cause fix for the
reported render glitch ("box tool call tiba-tiba jadi kayak navbar").
Drop-in: nothing to configure — auto-detect picks the tier; /config ram
to pin it explicitly.
Added — the RAM profile (performance.ramGb)
- new performance.ramGb (default 0 = auto-detect via os.totalmem) — pin
the machine's RAM in GB: 4, 8, 16 … - tiers (monotonic by construction):
- ≤4 GB → transcript 1500 rows · 2 parallel subagents · 48 web-cache
entries · context diet at 100k chars - ≤8 GB → 2500 · 3 · 96 · 120k
- above → the existing defaults 4000 · 4 · 128 · 150k
- ≤4 GB → transcript 1500 rows · 2 parallel subagents · 48 web-cache
- /config ram [gb|auto] — live rescale (no restart), a 🧠 dashboard row,
persisted to the GLOBAL config (a machine property, not per-project);
an explicit config always wins where stricter (min) — e.g.
subagents.maxParallel 1 stays 1 - new core/src/memory-profile.ts; setWebCacheMax eviction is now a
while-loop, so a lowered cap actually drains (clamped 8..128)
Fixed — the render glitch (the "navbar" tool box)
- root cause: the sticky region repaints with cursor-up + erase-below;
a foreign write landing between frames (a plugin console.error, a
stray log) pushed the cursor down → the next erase started too low →
the PREVIOUS frame's top rows (the tool box) froze on screen while
the AI stream kept painting under them. Intermittent because it
needed a plugin error to fire - render guard: while the app owns the screen, console.log/info/warn/
error and stdout/stderr writes are captured — the app's own frame
writes pass through (tuiWriting flag), every foreign write is queued
and flushed as a transcript row inside the next frame; restored on
destroy - resizes (SIGWINCH) re-anchor from the bottom and drop every
width-dependent cache (wrapped / flat / stream) — no more frozen
fragments after a terminal reflow - lines printed while the inline history viewer was open no longer
VANISH when it closes (flatLines flushed too early); streamCache is
keyed by {length, width}
Fixed — the build OOM (the 8 GB laptop report)
- scripts/build-binaries.sh detects free RAM (/proc/meminfo · vm_stat)
and runs bun with --smol (smaller heap, small speed cost) whenever
free is under 6 GB — bun build --compile peaks at a few GB per target - TAGENT_BUILD_SMOL=1/0 forces it on/off; each target still compiles
separately and sequentially; a single-target run
("linux x64") cuts the peak further for the tightest boxes - the hog is the embedded web GUI — ~11.8 MB of base64 baked into every
binary (the price of download-run-done, zero install)
Audit — the rest of the memory surface
- verified bounded: bash tool output capped 32k · MCP stdio fully
piped · session history disk-based (only metadata in memory) ·
pending writes debounced 1.5s · transcript/wrapped/flat caches bound
by the (now profile-scaled) log cap - honest limits, not tunables: the Bun runtime baseline is ~80–150 MB
RSS; MCP child processes are their own OS processes — a RAM pin does
not shrink those
Tests
- new scripts/test-render-guard.ts — 27 checks · new
scripts/test-memory-profile.ts — 24 checks · new glitch-proof.py
live-pty 6/6 (a noisy plugin console.error mid-session + a mid-run
resize: error text as transcript rows, navbar rails intact, editor
intact, coherent repaint) - full battery green (tui-app 44 · plugin-hooks 62 · subagents 71 ·
skills-router 112 · …); tsc 117 — 0 new vs baseline
Upgrade note
- drop-in: nothing required — auto-detect picks the tier on first run;
pin it explicitly with/config ram 8(or/config ram auto)
v0.31.0 — Plugin decision hooks: a gatekeeper + a resolver
v0.31.0 — Plugin decision hooks: a gatekeeper + a resolver
Two decision hooks join the plugin system — beforeToolCall (a gatekeeper
that runs BEFORE the permission gate) and onResolve (a capability resolver
contract) — plus subagent plugin inheritance and the Taceen scaffolding
(template + capability categories; the model itself is future work).
Drop-in: no config required, plugins stay optional — with no plugins loaded
the emit layer is bypassed entirely and nothing changes.
Added — beforeToolCall: the gatekeeper before the permission gate
- fires on every tool call with { tool, input, risk, workspaceRoot,
sessionId }, BEFORE permissions.gate() - the contract — first block/modify across plugins wins:
- {action:'allow'} or void → neutral, the call proceeds
- {action:'block', reason, alternative?} → the call stops: record status
'denied', outputBlocked by plugin: <reason>(+Alternative: <alt>
on its own line) fed back to the agent on the same path as a permission
denial; the permission gate and the tool run are skipped - {action:'modify', input} → the tool input is replaced; the record's
input is updated too, so the transcript shows what actually ran
- fail-open: a hook that throws is logged and skipped — the call proceeds;
a broken plugin never blocks the agent - deviation from the original design snippet, on purpose: the record
status is 'denied' (an existing ToolCallRecord value), not 'blocked'
Added — onResolve: the capability resolver (contract now, call-site later)
- fires with { query, workspaceRoot, mode } and answers
{ available: [{type:'tool'|'mcp'|'plugin'|'skill', name, reason?}],
unavailable?, hint? } — or void for "no answer" - emitOnResolve merges answers across plugins (first hint wins; null when
nobody answered) - there is NO loop call-site yet — deliberate: this is the stable
integration surface for Taceen (the main-agent/sub-agent wiring lands in
a follow-up release); the contract + template ship first - PermissionDecision grows optional reason? / alternative? — unconsumed
prep for the gatekeeper ↔ permission-gate integration
Added — subagents inherit plugins + MCP/plugin tools
- AgentLoopOptions.plugins? is new; spawnSubagent forwards plugins AND
extraTools — spawned subagents (including background subagents, same
code path) now run the gatekeeper and see the host-injected MCP/plugin
tools - e2e: a plugin denial inside a subagent is fed back into the sub
conversation, and the report still reaches the parent - host.ts passes the loaded plugins to the primary AgentLoop (one line) —
without it the gatekeeper would never have fired in real CLI runs
Added — the Taceen plugin template (prep work — no model yet)
Taceen is a planned small (~30–50 MB) local Python Tool & Capability
Resolver. This release ships the scaffolding it slots into — mock +
subprocess modes, everything fails open:
| File | What |
|---|---|
.tagent/plugins/taceen.mjs |
the plugin (mock + subprocess modes) |
.tagent/plugins/taceen.json |
config |
.tagent/taceen/taceen.py |
JSON-over-stdio skeleton (one line in, one out) |
docs/TACEEN.md |
developer doc (EN/ID) |
- config (defaults): enabled
true· mode"mock"· pythonPath"python3"
· taceenScript.tagent/taceen/taceen.py· timeoutMs1500 - mock mode: file/test/web keywords resolve heuristically to
read_file / bash / mcp_browser_navigate; any bash command containing
rm -rf is blocked with an alternative - switch to subprocess mode with {"mode":"subprocess"} in taceen.json —
onResolve and beforeToolCall then shell out to python3 with the JSON
contract above - the fallback rule (design invariant): any Taceen error or timeout →
allow. Every hook body is try/catch → undefined; spawn failure, empty
stdout, unparseable JSON and timeout all collapse to allow. Verified
live with a 1 ms timeout and the missing-script path — the agent stays
unblocked in every failure mode
Added — capability categories (10 categories / 41 capabilities)
- .tagent/taceen/categories.json v1.0 + docs/CATEGORIES.md — the taxonomy
the future resolver model consumes - 10 functional cross-kind categories covering 41 capabilities: all 25
registered tools + the 3 builtin skills + 13 representative MCP
examples (the live MCP list is per-user config; these are demonstrative) - two-stage answers: pick ONE category, return only that category's
capabilities — ~30 tokens per entry, the full catalog under ~1.5k tokens - docs/CATEGORIES.md records the 8 design answers (exposure, no-match
fallback, multi-match ranking, MCP naming, skill handling) + 3 worked
examples
Tests
- new suite scripts/test-plugin-hooks.ts — 62 checks (hermetic mkdtemp
roots, 5 consecutive identical runs): e2e block/modify through a real
AgentLoop, the no-plugins path, subagent inheritance, 12 emit-layer
units, and the real taceen plugin in mock/subprocess/disabled/
missing-script modes — including the proof that the plugin fires BEFORE
the bash blocklist (the /tmp sentinel survived an rm -rf attempt) - scripts/smoke-plugin-hooks.ts — 8 sanity checks (persisted)
- full battery green, matching the release numbers: switch-mode 52 ·
subagents 71 · testmode 59 · ask 41 · features 19 · context-loop 30 ·
browser 32 · v0190 71 · v0220 25 · tui-app ALL PASS · host ALL OK ·
version exit 0 · cache 38 · skills-router 112; source-site snapshot
regenerated for this release (125 passed / 2 failed before the regen —
it predated the loop.ts change) - tsc: 117 total — 0 new vs the pre-change baseline
Upgrade note
- drop-in: no config changes required — plugins stay entirely optional;
with none loaded, the emit layer is bypassed and behavior is unchanged
v0.30.1 — Hotfix: the re-route that never fired, whole-word keywords, a token budget
v0.30.1 — Hotfix: the re-route that never fired, whole-word keywords, a token budget
Three fixes from the v0.30.0 audit, shipped as a drop-in patch — no config
changes required.
Fixed — the topic-shift re-route was a silent no-op
- root cause: RouteContext.existingLoaded was declared and passed but never
read, and the already-loaded dedup ran AFTER the top-max slice — so in
any workspace with a rule signal (package.json, Dockerfile, tsconfig.json
— the common case) the top-N were always the already-loaded 0.9 rule
hits, filtered to [] and the re-route returned null - already-loaded skills are now excluded BEFORE the slice (case-insensitive
— manual load_skill records the user-typed name), so a mid-session "now
build a CLI instead" genuinely loads the new skill - evidence: the end-to-end repro went from re-route = null (session
unchanged) to "🎯 Auto-loaded skills: fake-cli" with the new skill live
in the session
Fixed — keywords match words, not fragments
- before: unanchored substring includes() — "ci" matched "decide"/"social",
"test" matched "latest", firing spurious 0.5 (= threshold) skill loads
in ANY workspace - now: word-boundary matching, case-insensitive; a multi-word keyword
needs every word (per-word AND); the regex avoids lookbehind so it stays
portable - one shared helper (keywordInText in util.ts) backs the router's keyword
detection AND search_skills' query filter — the two can no longer
disagree; frontmatter tag matching stays exact
Added — a total token budget
- new config skills.autoRouteMaxTokens (default 15000): a session-wide
cap over auto-loaded skill bodies — the already-loaded ones plus the new
candidates, estimated at ceil(chars/4) - over budget → the lowest-score additions are truncated first; each is
announced with the exact log line
[auto-router] Truncated: (score ) — total cap hit - the top-scoring skill always survives, and manual load_skill (24k
per-skill cap) is NOT affected - evidence: the repro's worst case went from 16144 uncapped tokens to
14126 ≤ 15000 with the truncation log; pre-fix, the audit measured ~12.1k
tokens/turn of skill bodies riding the system prompt, unbounded across
re-routes
Tests
- scripts/test-skills-router.ts: 73 → 112 checks (39 new regression checks
covering the re-route under rule signals, word-boundary matching, the
total token cap + truncation log, short-follow-up no-duplicate-loads,
manual load_skill uncapped, and search_skills word-boundary); 5
consecutive runs green - full battery re-run green, matching the v0.30.0 release numbers; tsc
total 124 → 117 (zero errors in the test file; the remaining 117 =
106 pre-existing release baseline + 11 audit scripts, out of scope)
Upgrade note
- drop-in patch: no config changes required — the new knob is optional;
set skills.autoRouteMaxTokens only if you want a tighter or looser budget
v0.30.0 — skill discovery: search_skills + auto-router
v0.30.0 — skill discovery: search_skills + auto-router
Skills now come with a two-stage protocol and a proactive layer that
loads the right playbook before you even ask for it.
search_skills — browse before you load
- new tool: browse skill METADATA (name, description, usage, tags) by
keyword query, tags (AND), and limit — read-only, risk:low, every mode - two-stage progressive disclosure: FIRST search_skills to find the
right skill, THEN load_skill(name) for the full body — no more guessing
names from the prompt list or loading skills one by one to peek - mtime-cached listing: re-scans only when a skills dir / SKILL.md
actually changed; cached calls are well under a millisecond
The skill auto-router
- before the first turn, the router matches the task to skills:
· workspace signals (score 0.9): package.json deps (next/react → web,
discord.js/telegraf → bot, express/fastify/hono → API), Dockerfile,
tsconfig.json, app/ or src/pages, .py density, PRD.md hints
· task keywords (0.5–0.7): matched against skill tags + descriptions - matched skills auto-load into context (max 3, bodies capped ~8k chars
each); below-threshold or empty matches load NOTHING — no speculation - one topic-shift re-route per session keeps a mid-session "now build
a CLI instead" covered; a re-route that finds nothing new burns no
budget
Transparency + control
- the TUI shows: 🎯 Auto-loaded skills + the match reasons; WORKLOG.md
gets the [auto-router] entry; the system prompt carries the list
(name, score, reason) plus the bodies - slash commands: /skills (loaded, [auto]/[manual] badges; all =
installed) · /reload-skills · /no-auto-skill · /unload-skill - config: skills.autoRoute (default true) · autoRouteMax (3) ·
autoRouteThreshold (0.5)
SKILL.md metadata
- front-matter now understands usage: and tags: (comma-separated);
usage falls back to the body's first paragraph, tags to [] - the shipped skills (web-app-builder, code-review, bug-hunter) carry
usage + tags
Verification
- new suite scripts/test-skills-router.ts — 73 checks: registration +
mode gating, query/tags/limit filters, two-stage flow, cache timing +
invalidation, router scenarios (web/bot/CLI), scoring caps +
thresholds, config disable, topic shift, slash-command logic, prompt
rendering, 50-skill routing perf (<100ms), and a full AgentLoop
end-to-end with a fake provider (notice fires, body rides the prompt,
search_skills executes through the permission gate) - battery re-run green: switch-mode 52 · subagents 71 · testmode 59 ·
ask 41 · features 19 · context-loop 30 · browser 32 · v0190 71 ·
v0220 25 · tui-app · host · version - tsc: no new errors (one pre-existing fixed); website build clean
v0.29.0 — operating loop v2: PLAN · BUILD · TEST, verified finishes
v0.29.0 — operating loop v2: PLAN · BUILD · TEST, verified finishes
The agent's operating contract is now a strict loop with teeth — same shape
for every project kind (web, CLI, bot, API, library, pipeline).
PLAN ──► BUILD ──► TEST ──┬── PASS ──► ✅ SELESAI summary to the user
└── FAIL ──► BUILD (fix) ──► TEST ──► (loop)
every failed round NEEDS a concrete hypothesis (why + what changes)
blind trial-and-error is FORBIDDEN
5 failed fix rounds → STOP, escalate: what was tried · the last error
verbatim · what is needed
The work loop — PLAN · BUILD · TEST
- PLAN investigates the request AND the repo before writing the steps
(PRD.md is the approved spec); BUILD implements step by step; TEST
verifies for real — "should work" is not a result - PASS means STOP: the final summary is delivered and the agent never
keeps iterating on finished work - hard cap: max 5 fix rounds, then escalation with the full story; real
blockers (credentials, product decisions) escalate immediately
The structured finish — ✅ SELESAI
Every finished task closes with the exact block (labels follow the
user's language):
✅ SELESAI
📌 Yang dikerjakan: what was done — the short story
📁 File yang diubah: every path touched + one-line why
🧪 Verifikasi: what you actually ran and the result — commands, counts
⚠️ Catatan: known gaps, follow-ups — or "-"
- the ✅ is EARNED by verification — untested work must say so under
⚠️
instead of being claimed - caveman mode keeps the structure, one telegraphic line per field
TEST mode — same rigor on every stack
- per-kind methods baked into the QA persona: web (serve + browser +
shots/vision) · CLI (real commands, exit codes, stdout/stderr, edge
cases) · API (curl, status codes, payloads, auth) · bot (real channel,
replies + side effects) · library (test suite, build, public API) ·
pipeline (real sample data, output verified end-to-end) - workflow restated stack-neutral: understand → start it → exercise →
report — the web path stays the fully-detailed reference - "reading the code is not testing" is now explicit
Verification
- switch-mode suite extended to 52 checks (loop branches, numbered
contract, max-5 + escalation, hypothesis rule, stack-agnostic,
✅ SELESAI block, caveman variant); testmode assertions restated (59) - full battery green: subagents 71 · async-subs 40 · testmode 59 ·
ask 41 · features 19 · context-loop 30 · browser 32 · v0190 71 ·
v0220 25 · updater 31 · updater-source 33 · host · tui-app · cache - additive again — every protected prompt contract survives (mode
personas, MCP, ask_user, delegation, PRD/QA, switch_mode gate)
v0.28.0 — the update that fixes updates; switch_mode; elite-executor prompt
v0.28.0 — the update that fixes updates; switch_mode; elite-executor prompt
tagent update never dead-ends again — every install kind recovers, every
failure prints the exact next command.
version check: raw.githubusercontent → jsDelivr CDN → GitHub API
(one flaky host can't kill the check anymore)
binary: ↘ live progress meter
↘ interrupted? RESUME from where it stopped (3 attempts)
↘ SHA256-verified against the release's SHA256SUMS
↘ root-owned /usr/local/bin? rescued to ~/.local/bin — no sudo
npm/bun: package 404s (tagent isn't on npm) → standalone binary fallback
source: detached HEAD recovered · bun-install failures reported
tagent update — bulletproof by default
- the check walks a chain: TAGENT_UPDATE_URL → raw.githubusercontent.com
→ cdn.jsdelivr.net (fast in Asia, rarely blocked) → the GitHub releases
API — 8s per hop, "could not reach the update endpoint" is gone - binary downloads: live curl progress, 3 attempts resuming the partial
file (-C -), stall detection (10 KB/s for 90s kills a hang), an 8 MB
size floor, and SHA256 verification before anything is swapped in - EACCES/EPERM on the swap (root-owned install dir) → the new binary is
installed to~/.local/bin(usually EARLIER on PATH — takes over on
the next launch, no sudo); worst case the one-line fix is printed - a crashed run's verified download is reused, not re-fetched; downloads
are async — the TUI no longer freezes during a 100 MB update - npm/bun installs fall back to the standalone binary instead of a
permanent 404; source installs surfacebun installfailures with the
recovery command instead of printing "updated" over a broken tree
switch_mode — PLAN → BUILD → TEST in one conversation
- the agent flips its own mode mid-run, but every flip is permission-
gated: you see the target mode + reason, nothing changes until you
approve; deny → "Permission denied" fed back, nothing changes - approval swaps persona + toolset for the following turns, persists
session.mode, fires mode:change → TUI navbar chip, GUI, relay viewers - the loop it unlocks: plan approved → build; done → test; bugs → build
- primary agent only — subagents' modes stay fixed at spawn
The operating prompt — elite-executor spec
- identity: autonomous engineer in the Codex / Claude Code / OpenCode /
Aider league — end-to-end executor, not a chatbot - language: ALWAYS mirror the user's language; code stays English-
convention; to-the-point engineer tone - explicit work loop: understand → plan → build → test with evidence;
escalate after ~5 blind retries; switch_mode taught as the phase gate - hard rules: never claim an untested pass, never edit unread files, no
placeholders, no "should work" - structured finishing summary: done · files · verification · notes · next
- additive rework — all protected prompt contracts survive
Verification
- new hermetic suites: test-updater.ts (31 checks — endpoint chain,
checksum refuse/corrupt/missing classes, EACCES rescue, swap),
test-switch-mode.ts (46 checks) - full battery green: subagents 71 · async-subs 40 · testmode 59 ·
ask 41 · features 19 · context-loop 30 · v0190 71 · host · tui-app… - live E2E: a compiled 0.26.0 binary updated itself against a real
release — 101 MB asset downloaded, SHA256-verified, swapped in place,
--versionflipped to the new version
v0.27.0 — async subagents, 3-lane fallback, /config add/apply
v0.27.0 — async subagents: background work, 3-lane fallback, /config add/apply
Subagents no longer block. task {background:true} returns an id (a1, a2…)
INSTANTLY and the main agent keeps working while the sub runs detached in
the background. Reports flow back on their own — mid-run as injected
messages, or as an auto-resume when the agent already finished. The user
is never asked to babysit.
task {background:true, agent:"test"}
└─► "BACKGROUND SUBAGENT STARTED — a1 …" (parent keeps working)
sub finishes, agent mid-run ──► [SUBAGENT REPORT] injected next turn
sub finishes, agent already done ──► agent auto-resumes, continues alone
both cases: notify "subagent a1 finished — report delivered"
Background subagents
task {background:true}returns immediately with the sub's id — the
parent loop never waits; fire several, they run in parallel- report delivery in both directions: live loop → the report is injected
as a[SUBAGENT REPORT]message mid-run; agent already finished → the
host auto-resumes it in a fresh run — no user confirmation, ever - multi-sub by design; the parallel limit is yours:
subagents.maxParallel(default 4, cap 16) via/config subs <n> - reports never strand: a no-action turn with a pending report takes one
more turn; a dead loop's orphan subs are never aborted (stop-block
checks loop.alive)
Monitoring — subs everywhere
- agent-side: the
substool —subslists every background sub
(id, kind, state, elapsed);subs {id}re-reads a finished report - user-side:
/subslive view in the TUI ·subs:viewRPC in the daemon
(GUI) — the registry lives on the host, so both see the same truth
Fallback is per-role now — 3 lanes
- three independent chains: main (the legacy
fallbackfield) ·
subagent (what task subs walk) · vision (the vision tool walks
its own chain — failover tested end-to-end) /fallbackreworked:/fallback <main|subagent|vision> add|rm|clear
plus the full 3-chain view in one command (aliases: utama/sub/media)- role overrides surface as lane primaries: a dedicated subagent or vision
model sits at the head of its own chain
/config is a template now — add · apply
- add: register things — MCP servers, provider+apikey+model, keys
- apply: a provider+model you already added → put it to work as the
model for a role (main · subagent · vision) or as a fallback
for any of the three lanes - the dashboard:
+ add·⚡ apply·⛓ fallback·🤖 subs(limit +
view) · keys · sync (status/push/pull)
Fixes & internals
- race fix:
chatSend's finally only clears ITS loop — a background
deliver landing between runs no longer clears a fresh run's state - 40 new hermetic checks (
scripts/test-async-subs.ts): registry ids /
limit / finish, immediate-return spawn, mid-run injection (the turn-4
model call SAW the report), late delivery after run end, the subs tool,
3-lane fallback, vision failover — every suite green
v0.26.0 — subagents, model roles, deep vision QA
v0.26.0 — the delegation stack: subagents, model roles, deep vision QA
Subagents are real now. The main agent can hand whole subtasks — or an
entire QA pass — to a focused sub-agent that runs in the same workspace,
reads files itself, and reports back. No recursion, no pasted file
contents: the prompt is a work order, not a data dump.
task: verify pages
├─ kind "test" → read-only QA sub (serve + browser + vision)
├─ reads PRD.md / the workspace itself
├─ shots desktop+tablet+mobile → .tagent/test/shots
└─ vision model → typography / responsive / contrast / a11y report
Subagents — the task tool
- built-in kinds: general (full toolset like yours, minus spawning),
explore (read-only recon), test (the QA kit — serve + browser +
vision, read-only) - subs run in YOUR workspace with the same file tools — they read whatever
they need themselves, so prompts carry instructions + paths, never file
contents - no recursion: subs cannot spawn further subs, never face the user
- custom specialists: drop a markdown file in
.tagent/agents/(or
~/.tagent/agents/) — front-matter for model, tools whitelist, mode
(build | plan | test), maxTurns; the body is its persona - economy fast-path: plain "read file X" prompts never spawn a sub at all
Three model roles, set independently
models.subagent— what task-tool subagents run onmodels.media.vision / .audio / .video / .pdf— the analysis models;
the vision tool routes screenshots tomedia.vision- TUI:
/model subagent|vision|audio|video|pdf <provider/model>·
off→ follow main · interactive/modelrole picker - GUI: a Model-roles dialog in the model dropdown
Vision QA — image → model → report
- browser
shotscaptures desktop + tablet + mobile in one call into
.tagent/test/shots; pass the directory, a file, or a comma list to the
vision tool (a directory takes its newest 4) - the dedicated vision model returns a structured review: functionality,
layout & alignment, typography scale, responsive comparison across
viewports, color & contrast, accessibility — then a PASS/WARN/FAIL
verdict with severity-tagged issues and suggested fixes - no dedicated model? the main model is used when it accepts images —
otherwise a setup error points at/model media vision
Fixes
- task {agent:"test"} ran the sub in the parent's mode — a build-mode
parent got a QA sub with a "your job is WORKING CODE" persona and
write_file/edit_file available; only the session metadata said "test".
The built-in test kind now genuinely runs read-only with the
VERIFICATION persona and the full QA toolset (test_report, browser,
vision, serve, bash, bg). The test suite's persona check was a tautology
(|| true) and never caught it — the assertions now read the sub's
actual system prompt (71 checks)
v0.25.1 — one-click GitHub login, on by default
v0.25.1 — the OAuth App is live: one-click login for everyone
The tagent OAuth App is registered and its client id ships inside every
binary — the Connect with GitHub button appears out of the box now:
no TAGENT_GH_CLIENT_ID, no config, no token hunting. One click,
Authorize, done — the token lands in tagent's credential store
without ever being typed.
GitHub login — web connect
✔ browser opened — press Connect with GitHub, then Authorize
waiting for the browser… Ctrl+C to cancel
✔ logged in octocat
⚙ config sync — pushed → octocat/tagent-config
One-click login, on by default
BUILTIN_OAUTH_CLIENT_IDis set — every install gets the button,
tagent auth --deviceworks without env vars, the GUI/TUI options
light up- client-id resolution is now env (
TAGENT_GH_CLIENT_ID) → your config
(github.clientId) → the bundled app — your config finally overrides
the built-in one - the device page opens with
?user_code=appended — GitHub doesn't
sendverification_uri_complete, so we try the prefill ourselves;
the page still shows the code big with a copy button as the fallback
Fixes
- fatal: the device-code request went to
github.github.com(a
broken string replace) — GitHub answered 405 every time, so the
v0.25.0 button never worked against real GitHub. Now it hits
https://github.com/login/device/code - the GUI host had its own client-id resolution (config → env, no
builtin) — it could disagree with the CLI; both now share
getOAuthClientId
Still true from v0.25.0
- "Paste a token instead →" stays one click away — the PAT flow never
blocks you - device-flow
slow_downbacks off instead of dying; the login server
lingers ~2s so the browser always shows the ✔ Connected card - security shape: loopback-only bind, one-time secret URL path, origin
checks on POST, one-shot after login,no-store