Valor vs Managed Agents

1 · The split

Three layers no hosted engine touches

Managed Agents is a better execution engine than a self-maintained harness: sandboxed containers, zero ops, per-millisecond billing where idle time is free, and a battle-tested loop with caching and compaction built in. Valor is a better orchestration layer: stateful, multi-channel, and workflow-aware. Three layers of Valor stay untouched by any hosted engine:

Orchestration

The PM/Dev role split within a session, the SDLC pipeline, and the steering queue — the part that knows what the work is.

Integration

Telegram and email delivery, and a dozen external services routed through one identity.

Memory

Persistent, ranked, decaying recall — production today, where the hosted equivalent is a research preview.

Where the two meet is execution. BUILD and TEST are the clear offload candidates: the longest-running stages, the most self-contained (a plan goes in, a branch comes out), and the ones that benefit most from a clean container instead of local worktree machinery. The remaining stages stay local because they need Telegram context, git credentials, or the review gate's own eyes — the study's standing rule is that a managed agent never approves its own frontend work.

2 · The hard problem

Subconscious memory doesn't port

Valor's memory recall is subconscious by design: a hook fires as the agent works, checks a bloom filter, and injects <thought> stubs into the context. The agent never decides to remember — it just does. Managed Agents has no hook equivalent: once a model turn starts generating, there is no way to insert tokens into it.

The study worked through the alternatives in order. A conscious recall tool was rejected — an agent that must choose to remember will forget to, precisely under pressure. Proxying every tool through Valor was rejected — at that point the container isn't executing anything and you've rebuilt the agent loop with extra steps. The recommended pattern is stealth injection through workflow tools: the agent must call run_tests, git_commit, and submit_work anyway, so those are defined as custom tools that route through Valor, which executes the operation, queries memory for the current context, and returns the result plus recalled thoughts. The agent sees verbose tool output; it doesn't know some of it is memory. Subconscious by design — coarser than per-tool-call recall, but aimed at exactly the decision points where steering matters.

3 · The linchpin

One Redis, shared by both halves

The piece that makes the hybrid work is unglamorous: put Redis somewhere both halves can reach. A hosted container that can reach the same Redis gets the same memory pool, the same session records, and the same conversation history as local sessions — no code changes, because the ORM only needs a URL. Post-session extraction then writes what the hosted agent learned back into the shared pool, where every future session, local or hosted, can recall it.

Notably, this move pays off even if the hybrid never ships: hosted Redis unblocks multi-machine memory sharing on its own. The study flags it as the quick win to take first, along with its inverse: stop investing in worktree edge cases, because container isolation replaces that whole class of machinery.

4 · The verdict

A trigger, not a migration

The conclusion is deliberately not "migrate." It is a trigger condition: when Managed Agents ships production memory and a hook-equivalent API, Valor's subconscious memory — the primary moat — becomes fully portable, and the cost/benefit of maintaining custom execution infrastructure flips. Until both land, the architecture stays hybrid: local brain, hosted hands, shared Redis between them. The study also defined a gated experiment pipeline before production adoption — environment cold-start time, tool-call cadence per turn, whether steering messages can land mid-turn, Redis latency from inside a container, and finally a full BUILD offload judged on code quality against local baselines.

5 · What to watch

Signals that change the answer

• A hook-equivalent API — the real unlock; makes subconscious memory portable.
• Hosted memory reaching general availability — the other half of the re-architecture trigger.
• Mid-turn steering — whether a message sent during a running turn is injected or queued; it decides how fine-grained external steering can be.
• Multi-agent sessions — could eventually subsume the PM/Dev split itself.
• Pricing on long sessions — hour-scale builds at per-hour runtime rates plus tokens need monitoring at scale.