Agent Workflow Radar • Control Tower

Structure is starting to beat raw model horsepower.

The strongest signal on X today was not a new model. It was a repeatable operating stack: layered agent identity, auto-loaded rules, task-specific skills, bounded subagents, persistent memory, and hard evals. The unlock is simple: agents stop behaving like disposable chats and start behaving like governed coworkers.

Generated

June 15, 2026 • 12:15 PM PT / 19:15 UTC

Theme

Control Tower

Worth Adopting?

Yes for structure, subagents, memory, and evals. Cautious on privacy and autonomous self-modification.

Best For

Operator-led teams running code, ops, GTM, or research from one agent workspace.

What Changed

The conversation shifted from “use an agent” to “run a disciplined agent system.”

Signal Cards

Five concrete workflow moves showed up repeatedly: durable structure, bounded parallelism, shared memory, verifiable evals, and privacy-aware operations.

01 • Core Stack

Layer the agent before you scale it.

High Signal

What happened

Alex Vacca laid out a five-layer Claude Code operating stack: identity, path-based rules, triggered skills, single-purpose subagents, and persistent memory. The important extra piece was governance: execution agents do not rewrite their own rules.

Why it matters

This is the cleanest articulation of why agent systems decay. Drift is usually a structure problem, not a prompt problem.

My take

This is the workflow worth stealing. The “brain vs muscle” split is the part most teams miss, and it is what keeps improvements compounding instead of turning into prompt soup.

Confidence / caveat

High confidence on the pattern. Medium confidence on any one person’s full framework until you test it against your own failure cases.

Source: Alex Vacca

02 • Parallelism

Subagents are becoming an operator feature, not a hack.

Adopt Now

What happened

Yarchi described Claude Code “agent teams” as a first-class pattern: enable the feature, spin up 3-5 role-bound agents, define file ownership, specify message handoffs, and let QA push bugs back to implementation before the lead agent returns.

Why it matters

This turns parallelism into a repeatable workflow instead of ad hoc tab chaos. It is especially good for research-build-QA loops and other separable branches.

My take

The important rule is not “use more agents.” It is “only split when work can truly fork.” The 3-5 agent guidance is sane; anything bigger is usually a coordination tax.

Confidence / caveat

High confidence on the mechanics. Also high confidence on the warning: teams cost roughly 3-4x the tokens and are a bad fit for linear tasks.

Source: Yarchi

03 • State

MCP memory is starting to glue tools into one workspace.

Watch Closely

What happened

Gemsmorro pointed at a persistent memory layer powered by MCP so tools like Claude and Cursor can share live context instead of dropping state every time the operator switches surfaces.

Why it matters

This is the bridge from session-based agents to durable systems. Once decisions, prior work, and state survive tool hops, agents can behave more like a long-running team than a stack of stateless chats.

My take

Worth adopting now in a bounded way: start with append-only task memory and decision logs, not magical “agent memory.” Shared state wins when it is inspectable.

Confidence / caveat

Medium confidence because the post is thin on implementation detail. The direction is right; the hard part is schema, retrieval discipline, and garbage collection.

Source: gemsmorro

04 • Evals

The bottleneck moved from models to verifiable loops.

Critical

What happened

Abhijay Rana argued that workflow-specific evals are the real engineering burden now. Domain experts can judge outcomes, but building an unhackable, repeatable verifier is a separate craft.

Why it matters

If your agent is supposed to improve over time, weak evals will silently poison the loop. Instruction-verifier mismatch and underspecified success criteria are how “optimization” turns into drift.

My take

This is the most useful corrective in the whole batch. Do not chase autonomy before you can score the work. Engineering teams should treat eval design as product infrastructure.

Confidence / caveat

High confidence on the diagnosis. Lower confidence on any universal recipe, because eval design stays domain-specific and ugly.

Source: Abhijay Rana

05 • Caveat

Agent memory without privacy turns into a behavior graph.

Medium Signal

What happened

Veilnet framed the privacy side bluntly: once agents call APIs, manage wallets, store memory, and transact, the logs themselves become a sensitive behavioral map.

Why it matters

Operator stacks are getting stateful fast. That means governance can’t stop at prompts and folder structure; data boundaries and audit exposure are now part of the workflow design.

My take

You do not need crypto rails to learn the lesson. The practical move today is simpler: classify what your agent remembers, who can read it, and what must never leave the machine.

Confidence / caveat

Medium confidence. The source is clearly pitching a product, but the underlying warning is real and timely.

Source: Veilnet

Steal This Workflow

Adapt the layered Claude Code stack, then bolt on subagents, memory, and evals in that order. This is the safest path to something durable.

The adaptation path

Define one identity file. Give the main agent a stable role, routing logic, and hard rules.
Load rules by context. Put GTM, coding, ops, or research rules in separate folders so the right constraints appear automatically.
Encode repeatable work as skills. Sequences, audits, reports, QA checklists, and launch runbooks should not live in prose prompts.
Use 3-5 subagents max. Split only separable branches like research, implementation, and QA. Give each a concrete output contract.
Add inspectable memory. Start with decision logs, task state, and known facts that survive session switches and tool hops.
Gate improvement with evals. Before self-improving anything, build a repeatable verifier and a small regression set.
Separate governance from execution. Execution agents propose rule or skill changes; a human or governance lane approves them.

Why this unlocks work now

What it unlocks: a single operator can run a multi-lane system without constantly re-briefing the model.

Who it helps: people running cross-functional loops where code, docs, GTM, research, and QA keep touching the same context.

Why now: subagents and MCP-style state sharing are finally concrete enough to use, but still need human-governed boundaries.

My recommendation: adopt the stack now, but keep the memory layer inspectable and the eval loop small until you trust it.

2026-06-15-control-tower