Skip to content

Releases

v0.31.2 — Navbar machine stats & a context bar for every provider

Choose a tag to compare

@asysurya asysurya released this 11 Oct 08:36

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
    marked "
    " too ("~12.3k/~128k [█░] 10%")
  • 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

Choose a tag to compare

@asysurya asysurya released this 06 Oct 04:58

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
  • /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

Choose a tag to compare

@asysurya asysurya released this 27 Sep 12:03

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', output Blocked 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 · timeoutMs 1500
  • 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

Choose a tag to compare

@asysurya asysurya released this 27 Sep 02:14

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

Choose a tag to compare

@asysurya asysurya released this 26 Sep 03:33

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

Choose a tag to compare

@asysurya asysurya released this 24 Sep 12:14

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

Choose a tag to compare

@asysurya asysurya released this 24 Sep 10:37

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 surface bun install failures 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,
    --version flipped to the new version

v0.27.0 — async subagents, 3-lane fallback, /config add/apply

Choose a tag to compare

@asysurya asysurya released this 23 Sep 09:00

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 subs tool — subs lists every background sub
    (id, kind, state, elapsed); subs {id} re-reads a finished report
  • user-side: /subs live view in the TUI · subs:view RPC 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 fallback field) ·
    subagent (what task subs walk) · vision (the vision tool walks
    its own chain — failover tested end-to-end)
  • /fallback reworked: /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

Choose a tag to compare

@asysurya asysurya released this 23 Sep 07:31

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 on
  • models.media.vision / .audio / .video / .pdf — the analysis models;
    the vision tool routes screenshots to media.vision
  • TUI: /model subagent|vision|audio|video|pdf <provider/model> ·
    off → follow main · interactive /model role picker
  • GUI: a Model-roles dialog in the model dropdown

Vision QA — image → model → report

  • browser shots captures 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

Choose a tag to compare

@asysurya asysurya released this 23 Sep 00:45

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_ID is set — every install gets the button,
    tagent auth --device works 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
    send verification_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_down backs 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