News for hackers. Stuff that matters.

webpolis

Re:Show HN: Cloud VMs with a Built-In REST API for AI Agents on Thursday March 12, 2026 @08:04AM (#47349442)
Loop detection is the harder problem and almost nobody solves it well at the infra layer. The pattern you're describing — write, fail, "fix," regress — is fundamentally a semantic loop, not a mechanical one. You can't catch it by diffing outputs or counting retries because each iteration looks superficially different. The agent thinks it's making progress.

What actually works in my experience: budget the agent a rolling token window per subtask, not per session. If it burns 40% of its context on a single function without a passing test, force an early return with the error context and let the orchestrator decide whether to retry with a different prompt or bail. Putting that logic in the VM host is tempting but wrong — the host doesn't have the semantic context to know "stuck" from "legitimately hard." That belongs in the agent framework or a thin supervisor shim between the framework and the execution environment.

Re:I'm going to build my own OpenClaw, with blackjack and bun on Wednesday March 11, 2026 @12:35PM (#47337799)
Browser plugins have a security problem that's easy to miss: the agent runs inside your existing browser profile. That means it has access to your active sessions, stored credentials, autofill data — everything you're already logged into. A sandboxed machine is actually the safer primitive for untrusted agent tasks, not the more paranoid one. I work on Cyqle (https://cyqle.in), which uses ephemeral sessions with per-session AES keys destroyed on close, because you want agents in a cryptographically isolated context — not loose inside your personal browser where one confused-deputy mistake can reach your bank session.
The hard part here isn't checkpointing the agent's conversation state — that's just a list. It's checkpointing the world state. If step 5 wrote rows to Postgres and step 7 called a third-party API, forking from step 6 means you need the DB at its post-step-5 snapshot and some way to mock or replay the external call. Without that, you're replaying agent logic against a world that's already diverged. We ran into this enough building agent sandboxing at Cyqle (https://cyqle.in) — our approach is snapshotting the entire ephemeral environment at each checkpoint so the fork includes filesystem, DB state, everything. Curious how Time Machine handles external side effects that can't be rolled back.
The keychain-per-agent model is the right instinct, but the threat model gets complicated fast. When five agents share a keychain process, a prompt injection in agent A can exfiltrate credentials for agents B–E — one bad LLM output becomes a full company compromise.

The safer architecture is per-session credential scoping: each agent gets credentials minted for that specific task, revoked on completion. That's what we built Cyqle (https://cyqle.in) around — ephemeral sessions where the encryption key is destroyed on close, so if an agent misbehaves, the blast radius is bounded to that session.

The keychain needs the same isolation principle, but applied at the task boundary, not the agent boundary.

Show HN: Cyqle – Multiplayer cloud desktops with AI agent sandboxing

https://cyqle.in/

Hey HN,I've been building Cyqle for a while — it's a shared cloud desktop you open in a browser tab and invite people into. Everyone gets their own cursor and keyboard. Think Google Docs, but for an entire Linux machine.The use cases that surprised me most once people started using it:- AI agent sandboxing — spin up a disposable desktop, hand it to an agent, let it browse/run/execute...

( Read More... | no comments | on HN )
The macOS sandbox approach is clever, but there's an interesting philosophical split here: sandboxing constrains a local agent, whereas running agents in ephemeral cloud desktops removes the local risk surface entirely.

We built Cyqle (https://cyqle.in) partly around this idea — each session is a full Linux desktop that's cryptographically wiped on close (AES-256 key destroyed, data unrecoverable). Agents can do whatever they want inside, and the blast radius is zero by design. No residual state, no host OS exposure.

The tradeoff is latency and connectivity requirements. For teams already doing cloud-based dev work, it's a natural fit. For local-first workflows where you need offline capability or sub-50ms responsiveness, something like Agent Safehouse makes more sense.

Both approaches are worth having — the threat model differs depending on whether you're more worried about data exfiltration or local system compromise.

The blast radius point is right, and I think it points at a design split that's underappreciated.

Most sandboxing approaches — including this one — optimize primarily for isolation from the host: prevent the agent from escaping, limit what it can touch. That solves the runaway agent problem.

But there's a second axis: observable execution for human collaborators. When an agent modifies a codebase or runs a research task, a teammate often needs to watch it happen in real time, intervene before it commits a wrong turn, or audit what actually ran. Async logs and artifact outputs don't cover this well.

We've been building Cyqle - https://cyqle.in -- (disclosure: I work on it) from that angle — cloud desktop sessions where agent runs are shared live with whoever needs visibility. Isolation is at the VM/session level rather than syscall granularity. Different tradeoff: you give up process-level permission mapping, you gain real-time collaborative access to the running environment — watch, intervene, hand off.

The use cases probably don't overlap much with Terminal Use (async batch filesystem agents clearly want deep process isolation + lifecycle APIs). But this thread made me think "agent environments" is actually several distinct problem spaces: async autonomous execution, interactive human-supervised sessions, team-observable debugging runs. The right primitives look very different depending on which you're solving.

Re:LLM prompts as versioned, composable software artifacts on Monday August 11, 2025 @10:00PM (#44871531)
As I started building agentic workflows, I found myself frequently creating, improving, and tweaking prompts by editing hardcoded strings and managing text files. I realized this process lacked the crucial software engineering principles that make any project more robust and reliable: versioning, modularity, maintenance, and testing. One of the most important parts of AI agent development is the system prompt, as the success of the workflow's execution depends on it. So, why was I handling this critical step with such a rudimentary approach? With that in mind, I designed a framework that helps AI engineers build an agent's mind in a composable, shareable, and consistent way. The ultimate goal is to build a public repository for sharing prompt components that anyone can use to shape intelligence.