home.social

Search

19 results for “_runeo”

  1. Google news gives me two pieces of news about #Greece :
    - Greece sinks decommissioned frigate in major military #drill with #Israel
    - Greece should open/join a vertical axis with #Moscow and abandon the USA solidarity.
    - Greece is a #democratic country where #RuleOfLaw is essential yada yada

    Find the lie :D

  2. An agent that goes quiet for ten minutes does not feel autonomous. It feels broken. A spinner and a made-up “82% complete” label are not much better: they encourage users to trust a number your system cannot justify.

    The fix is not to stream the model's hidden reasoning. It is to publish a small, evidence-backed account of the work: what phase the run is in, the last verified milestone, whether it needs a person, and what will happen next. This article shows how to build that contract for long-running, tool-using AI agents.

    The progress problem is really a trust problem


    Users ask three practical questions while an agent runs:

    1. Is it still alive?
    2. Did it make meaningful progress?
    3. Do I need to do anything?

    A token stream answers none of these reliably. It can continue while a tool is stuck, and it can stop even though a durable workflow will resume later. Likewise, an LLM-generated status such as “almost finished” is a prediction, not evidence.

    Treat status as a product contract. The user-facing timeline should be derived from workflow events your system can verify: a job was accepted, a connector returned records, validation passed, an approval is waiting, or a final artifact was stored. The model may suggest a label, but it should not be the source of truth for state.

    This distinction also protects privacy. A useful update is “Checked 42 invoices; 3 need review,” not a transcript of the agent's scratch work, retrieved customer text, or chain of thought.

    Start with a state machine, not a progress bar


    Long-running agent work has more states than running and failed. Model the states explicitly and make transitions durable.

    StateMeaning to the userRequired evidenceUseful UI actionqueuedWork is accepted but has not startedrun record createdCancelrunningA worker currently owns the runlease heartbeatStopwaiting_on_toolThe run is awaiting a bounded external calltool request ID and deadlineCancelwaiting_on_userA decision or missing input is requiredapproval or question IDReview / answerretry_scheduledThe system will retry laterretry time and error classCancel / view detailssucceededThe requested result was verified and savedoutput receiptOpen resultfailedThe run cannot continue automaticallyfailure class and last checkpointRetry / contact supportcancelledWork was intentionally stoppedcancellation receiptRestart


    Avoid a vague paused state. If the workflow is paused because it needs an address, show waiting_on_user. If it is paused because a vendor rate-limited it, show retry_scheduled. Specific state names let a user decide what to do without reading logs.

    Here is a compact TypeScript event shape. It is deliberately about observable work, not hidden reasoning.

    type RunEvent = {
    runId: string;
    sequence: number; // monotonic per run
    at: string;
    type: "phase_started" | "milestone" | "approval_needed" |
    "retry_scheduled" | "completed" | "failed";
    phase?: "preparing" | "collecting" | "verifying" | "delivering";
    message: string; // reviewed, user-safe copy
    evidence?: {
    kind: "artifact" | "tool_receipt" | "checkpoint" | "approval";
    id: string;
    };
    action?: { label: string; url: string };
    };

    Persist these events in the same transaction that changes workflow state, or attach them to an outbox. A UI event that says “report ready” before the report is stored is worse than no event at all.

    Publish milestones, not a narrated thought process


    Choose milestones at boundaries where the system can prove something changed. Good milestones are stable across model versions and useful if a run resumes tomorrow.

    For a document-analysis agent, the timeline might be:

    • Request accepted
    • Source file scanned and indexed
    • 42 records extracted
    • Policy checks completed
    • Three exceptions need a decision
    • Final report saved

    Notice what is absent: “thinking about clause 7” or “I believe this source is probably relevant.” Those claims are neither a dependable progress signal nor an appropriate audit record.

    Each milestone needs an owner. The workflow engine owns checkpoint messages; the connector owns data-fetch receipts; the policy service owns validation results. If no component can produce evidence for an update, leave it out.

    That rule prevents a common failure mode: a chat interface keeps emitting cheerful prose while the actual job stopped moving. Your supervisor should detect stale progress independently of the agent. For example, mark a run stalled internally when its lease heartbeat is fresh but neither a checkpoint nor a tool receipt has advanced within the expected phase window. The user-facing text can then say, “Still working longer than expected; no action needed yet,” or escalate honestly to “This task needs attention.”

    Design an honest progress model


    Percent complete works only when units of work are known. A migration over 10,000 rows has a denominator. An open-ended research task generally does not.

    Use one of these models instead:

    Work shapeBest indicatorExampleFixed batchcompleted / total318 of 500 files checkedKnown workflowcompleted phaseVerifying findings (3 of 4 phases)Open-ended workelapsed time plus latest verified eventLast verified update: sources indexedApproval flowblocked state and decision impactNeeds approval before sending 3 emailsRetryable external worknext retry and preserved checkpointRetrying connector at 14:05; 18 items saved


    Do not convert phase count into a false percentage. Four phases do not necessarily take equal time, and the model can loop inside one phase. If you show an estimate, label it as a range derived from similar completed runs, and hide it when the sample is weak.

    function statusCopy(run: Run) {
    if (run.status === "waiting_on_user")
    return "Your decision is needed before this task can continue.";

    if (run.completedUnits != null && run.totalUnits != null)
    return `${run.completedUnits} of ${run.totalUnits} items verified`;

    return `Last verified update: ${run.latestMilestone.message}`;
    }

    The word verified matters. It teaches users what the timeline represents and sets a standard your team can test.

    Make waiting visible and actionable


    The most damaging silence is not a slow model call. It is an agent waiting for a person while the product looks busy.

    An approval event should include the decision, the consequence, the safe default, and an expiry rule. Keep the payload concise and reviewable:

    {
    "type": "approval_needed",
    "message": "Three customer records have conflicting addresses.",
    "question": "Which address should be used for the renewal notice?",
    "options": ["CRM record", "latest support ticket", "skip these records"],
    "default": "skip these records",
    "expires_at": "2026-10-26T15:00:00Z",
    "evidence": { "kind": "approval", "id": "apr_8f2" }
    }

    Never bury an approval in a scrolling chat. Surface it as a run state, send a notification only when action is required, and ensure a resumed run re-reads the approved decision from durable storage. This pairs well with approval gates, but it solves a different problem: making the wait understandable to the person who initiated the work.

    Transport updates without building a fragile realtime system


    Start with the simplest transport that fits your product.

    • Polling is enough for minute-scale background jobs. Return status, latest_event, and etag; back off when nothing changes.
    • Server-sent events work well for one-way timelines and reconnect cleanly with Last-Event-ID.
    • WebSockets fit collaborative workspaces where users can also approve, stop, or redirect a run live.
    • Notifications should be sparse: completion, failure, and waiting_on_user are normally worth interrupting someone; routine milestones are not.

    Regardless of transport, the client must tolerate duplicate and out-of-order events. Use the sequence field, make the event stream append-only, and fetch the authoritative run snapshot after reconnecting. The UI is a projection; the workflow database remains the authority.

    Build the API around a durable run record


    A small API surface is easier to secure and test than a channel full of ad hoc text.

    GET /runs/run_123

    {
    "status": "waiting_on_user",
    "phase": "verifying",
    "latest_event_sequence": 17,
    "latest_event": {
    "message": "42 records verified; 3 need a decision",
    "at": "2026-10-26T12:04:12Z"
    },
    "actions": [{ "kind": "approve", "approval_id": "apr_8f2" }]
    }

    Keep sensitive tool arguments, raw documents, and internal exception stacks behind a permissioned diagnostics view. The default run page should disclose only the minimum a user needs to understand progress and take the next action.

    Test the status contract like an API


    Status is part of the user experience, so add tests beyond the happy path:

    1. A run cannot become succeeded without an output receipt.
    2. A waiting_on_user run always exposes a decision action and cannot spend tools until it resumes.
    3. Replayed events create the same final timeline.
    4. A reconnect receives no duplicate visible milestones.
    5. A cancelled run cannot later publish a success event.
    6. A stale worker lease produces an honest recovery state, not permanent “Working…” copy.
    7. User-safe messages contain no prompt, secret, customer text, or chain of thought.

    it("does not claim success before output exists", async () => {
    await workflow.emit({ type: "completed", evidence: undefined });
    expect(await runs.get("run_123")).toMatchObject({ status: "failed" });
    });

    This is also where observability earns its keep. Measure time to first verified milestone, time spent waiting for users, stale-run recovery rate, and the share of runs that finish with a useful artifact. Avoid treating the number of progress messages as a health metric; a noisy timeline can conceal a poor workflow.

    A practical rollout plan


    Do not retrofit every agent at once. Start with one workflow where users currently refresh a page or ask support whether a job is stuck.

    1. Define the state machine and ownership of each transition.
    2. Add durable run records and one evidence-backed milestone per phase.
    3. Replace generic spinners with the latest verified update.
    4. Promote approval waits to a clear, resumable state.
    5. Add stale-run detection and a recovery message.
    6. Instrument completion quality, not just elapsed time.

    The result is deliberately less theatrical than a stream of simulated thinking. It is far more useful: people can leave a long-running agent alone, return with context, and intervene exactly when their judgment is needed.

    Keep the language stable across releases


    Treat visible status copy as part of your API. Changing waiting_on_user from “Needs your decision” to “Paused” may seem cosmetic, yet it can break notification rules, customer runbooks, and accessibility labels. Version the event schema, localize messages at the presentation layer, and keep a small compatibility test suite for every public state. That discipline pays off when new models, tools, and workflow engines arrive: the user still receives the same clear promise about what has happened and what they can do next.

    FAQ

    Should an AI agent show its chain of thought as progress?


    No. Show concise, evidence-backed milestones instead. They are more reliable, safer for sensitive data, and easier for users to act on.

    How often should an agent send status updates?


    Update on meaningful state changes, verified milestones, and action-required moments. For long silent phases, add a bounded heartbeat that says the job is still owned, not a stream of filler messages.

    Is a percentage complete useful for AI agents?


    Only when the work has a known denominator, such as files processed or records checked. Otherwise show the phase, elapsed time, and most recent verified milestone.

    What is the best state for an agent waiting on a person?


    Use a specific waiting_on_user state with the exact question, a safe default, and a resumable approval ID. Do not leave the run labeled running.

    Can polling work for long-running AI workflows?


    Yes. Polling is simple and reliable for background tasks that update every few seconds or minutes. Use ETags and backoff, then move to SSE or WebSockets only when the interaction requires it.

    How do you detect an AI agent that is stuck?


    Track worker leases, tool deadlines, and the time since the last verified milestone. A supervisor outside the model should classify stale runs and surface a recovery state.#ai #ux #programming #devops #software #coding #development #engineering #inclusive #community
    AI Agent Status Updates: Build Progress Users Can Trust Without Exposing Chain of Thought

  3. For two weeks, Claude planned and reviewed my code changes and Xiaomi's MiMo-V2.6-Pro wrote them. That was 95 work orders across 14 of my repos, and 62 of them merged. At list prices, MiMo's side of those 62 changes cost $14.22. The same tokens at Claude Opus 5.5 prices come to $355.

    The catch is time. A merged change took 52 minutes from order to merge (median). MiMo was working for less than half of that.

    The setup


    A dispatcher I wrote (about 10,000 lines of stdlib Python) runs each order in its own git worktree and branch, inside a macOS seatbelt sandbox that can only write to that worktree. Claude writes the order, MiMo implements it and runs the project's checks, Claude reviews the diff and either sends it back with feedback or merges it locally. Nothing gets pushed without me.

    Every order leaves a state file and the worker's full event log, with timestamps and token counts for each model call. All the numbers below come from those files, for orders created 11 to 23 October 2026.

    Where the time went


    I could rebuild the full timeline for 33 merged orders (four more sat overnight and I left them out).

    StageShare of wall-clockMedianWaiting in the queue5%0.1 minMiMo working49%30.7 minBetween rounds (review, feedback, waiting)27%6.4 minLast round finished → merged20%11.2 min


    The orders that passed on the first round make it plain. MiMo worked for 16 minutes (median) and the order took 42 minutes end to end.

    Most of the extra 26 minutes is the orchestrator not looking. Its instructions said to check the queue with sleep 595, then review, then merge. The long interval was there to save Claude tokens. It also left up to ten minutes of dead time every time a worker finished. The merge step adds more: it rebases onto whatever landed in the meantime and reruns the full test suite.

    None of this is the model's fault. It's plumbing.

    Is the model itself slower?


    Less than I expected. I compared MiMo's turns with Claude Opus 5.5 turns from my own Claude Code transcripts. They're different tasks, so read this as a rough comparison, not a benchmark.

    Per model callMiMo-V2.6-ProClaude Opus 5.5Calls measured6,6404,537Seconds per call, median6.77.9Seconds per call, mean21.813.2Output speed47 tok/s81 tok/sContext per call, median153K467K


    The typical call is as fast. The slow ones are slower, which pulls the mean up. A MiMo attempt ran 37 calls and 15 minutes (median).

    The context column matters later. MiMo starts every order from a fresh worktree, so it carries about a third of the context my long Claude sessions do.

    The real gap: rework


    Only 24 of the 62 merged orders (39%) went through on the first round. The rest needed one to six more. Each round means another attempt, another review and another wait, and the token bill climbs fast:

    Rounds to mergeOrdersMedian tokens1243.6M2208.9M3814.8M4 or more1031.0M


    I read the review feedback that sent orders back. Nearly all of it falls into five groups:

    1. Failing silently: a missing column, a join that matched zero rows or a button that wasn't found, all treated as success.
    2. Data edge cases: duplicate rows, a date that's object on one side and str on the other, and tickers like NA and NULL that pandas quietly reads as NaN.
    3. Tests that can't fail. One asserted that a static header string was present in the output. Another wrote into the repo's real output folder. One took 113 seconds against a 60-second limit.
    4. New behaviour with no test, or a runbook left describing the old behaviour.
    5. Matching too loosely: a substring check for selected that also hits unselected, or "click the first OK button on the page".

    None of these are hard to get right. They weren't in the order, and the worker didn't go looking for them. A stronger model goes looking more often. That's most of what you pay Claude for.

    The cost math


    Here's the token mix across the 62 merged orders: 97.8% cache reads, 0.56% output. An agent re-reads its whole context on every call, so the token count is roughly calls × context size. It has little to do with how much code gets written.

    That makes the cache-read price the one to compare, and the headline price misleads:

    Per 1M tokensMiMo-V2.6-ProClaude Opus 5.5RatioInput$0.435$4.009×Cache read$0.0036$0.2056×Output$0.87$20.0023×


    On my mix the blended ratio is 25×. A merged change cost MiMo $0.17 at list price (median) against $3.83 for the same tokens at Opus prices. Even the orders that took four or more rounds stayed far cheaper than handing the job to Claude. And Claude doing the work inside my planning session would carry three times the context per call, so its real bill would be higher still.

    I pay for both through subscriptions, not per token, so list prices are a yardstick here, not my invoice. Xiaomi's Token Plan page doesn't say how cache hits count against the monthly quota. Check that before you rely on a ratio.

    The money that actually leaks is on the orchestrator side. Every time Claude wakes up to poll, it re-reads its own large context. Ten polls on a 300K-token session is 3M Claude tokens spent on checking whether anything happened.

    What I'm changing


    Three changes, all dispatched to MiMo this morning (yes, through the same queue):

    • A wait command that blocks until an order changes state and returns at once. It's read-only, so the orchestrator can run it over a mounted path from a VM. That replaces sleep 595.
    • An automatic review as soon as an order's checks pass, run by Claude Sonnet in headless restricted mode. That means no shell, file reads confined to the review worktree and no MCP servers. The verdict is waiting by the time the orchestrator looks.
    • A self-review section in every implementation prompt built from the five groups above, plus an order template with a mandatory "Failure modes" section. Cheap tokens make a self-check worth running.

    Two of the three merged after two review rounds. The reviewer change took nine. It runs outside the sandbox, and for four rounds in a row a reviewer found another way a file planted in the repo could get executed through PATH. In the end I dropped the PATH lookup instead of patching it again. That one order used 127M tokens, about $1.02 at MiMo list prices. At Opus prices the same tokens would have cost more than all 62 orders above did on MiMo.

    The aim is to get first-round merges from 39% to about 60% and take 20 to 25 minutes off a typical order. I'll post the before and after once there are enough orders to compare.

    Limits


    • One person, 14 repos, two weeks, mostly Python. Your mix of work will differ.
    • The Claude timing comes from different tasks than MiMo's, so it says something about speed and nothing about quality.
    • Rounds are counted from the worker's event logs. The wall-clock breakdown covers the 33 orders with complete timestamps.
    • Prices are list prices checked on 25 October 2026: Xiaomi's rates as listed on OpenRouter, Anthropic's from its pricing page.

    If you're splitting work between a planner model and a cheaper worker, measure the gaps between steps before you shop for a faster model. I do this kind of measurement as a routing audit ([email protected]). If you've measured your own split, I'd like to compare numbers.#ai #llm #agents #productivity #software #coding #development #engineering #inclusive #community
    I routed two weeks of coding to a model 25x cheaper than Opus. The model wasn't the slow part.

  4. Serbia is Europe. To the young people filling the streets of Belgrade, may your hopes become tomorrow’s reality.

    video.infosec.exchange/w/b9i3E

  5. Saturday, October 24, 2026

    Inside the legal design of America's Russia sanctions U-turn . . . . . Analysis: Ukraine’s Starshield access is still crippled, and no one is taking the blame . . . . . Ukrainian media identifies Russian officers responsible for blockade, starvation of occupied Oleshky . . . . . and more

    activitypub.writeworks.uk/2026

  6. Nå begynner det å bli gøy! Må følge flere kontoer på Pixelfed da.

  7. Mener å hus(k)e på Twitter at det var en OTD WW2 bot. Finnes den i dag på Mastodon eller Bluesky?

  8. Unge lovende er klar for en ny uke med ny kursdeltakere, denne gangen med rekord i prosentandel kvinner! Mer kvinner i tekniske yrker! 💪💪🤓🤓

  9. As Halloween nears I'm posting one of my favourite Disney cartoons. I first watched this as a kid on a VHS Video titled Scary Tales!The Legend of Sleepy Hollow narrated by Bing Crosby. No AI was used in creating this piece of beautiful animation. youtu.be/x5KR7TayjAk?si=NiW_xz

  10. Så han som ikke bruker linser fordi det ikke var sjanse i helv.. å få de på, skal nå påføre salve på øynene?!!

    Dette blir tre-fem lange dager.

  11. Den treårige gutten vår blir mer og mer treårig gutt for hver dag som går.

  12. Ventetid på legevakt; kan det kategoriseres som egentid?

  13. Du @TanteGulo ! Hva tenker du? Finnes det øyedråper som er reseptfrie?

  14. Digg når terskelen for å ringe legevakt er skyhøy og så har de ikke tid. Ta smertestillende og ring igjen på dagtid i morgen. Jeej.

  15. Altså, her har jeg mulighet til å se kvalik til Formel 1 live i ro og fred og så sier kroppen og øynene at de er drittrøtt?! Makan!

  16. Aldri har jeg sett så dårlig på nært hold siden jeg returnerte de progressive brillene fordi jeg så dårlig med dem.

  17. I dag fikk jeg øye på en gren. Det gjør vondt ennå. Dette til informasjon.

Share on Mastodon

Enter the server where you have an account.