How to Talk to Anyone — Leil Lowndes

Exploring the role of a Field CTO and its principles

Great communication is a learnable skill, not a magical gift. Charisma breaks down into a set of concrete, practisable techniques rather than innate talent. For a Field CTO whose value rests on trusted-advisor relationships, this reframes executive presence as something you can deliberately build. Your first impression isn't just important — it's practically permanent. When someone meets you their brain takes a snapshot and files it in a mental folder, and every future interaction is filtered through that initial image. The opening seconds of a customer engagement therefore carry disproportionate, hard-to-reverse weight. A genuine smile builds slowly and should be tailored to the individual, not broadcast uniformly. Fake smiles are easily spotted and read as mere politeness; handing everyone in a group the identical smile feels like a performance of connection. A slower, person-specific smile signals sincerity, and a steady smile projects confidence. Greet people as if they're not strangers and turn your whole body towards them. Facing someone with your entire torso, not just your head, signals undivided attention, and meeting them as if you're delighted to see them dissolves social friction instantly. Engineer conversation hooks early — plant threads the other person can pull on. Rather than leaving rapport to chance, deliberately create openings and interesting things for people to ask you about, which makes the exchange feel natural and unforced. Confidence and energy carry more weight than the precise words (affinity bias). Small talk is the bridge from stranger to trusted contact, not filler to be rushed. Most people run a "quiz show" of short questions met with flat answers that dead-end the conversation. Instead, anticipate the predictable questions, answer expansively, and open several conversational doors — not just one — that the other person can walk through. Keep the spotlight on the other person, and mirror their language back. The best conversationalists say little, reflect the other person's own phrases and terminology back as questions to invite elaboration, and set up whoever has the great story to tell it. Using their words rather than your own leverages affinity bias and makes them feel understood. Withhold your weaknesses and secrets until you've earned credibility. Confessing struggles too early makes people wonder what else you're hiding or failing at. In the early stages stay interested, curious and positive, and save vulnerability for once trust is genuinely established. Give praise immediately, specifically, and before high-stress moments. Don't bank praise for later — deliver it in the moment, tailored to the exact act, and get it in early ahead of something stressful like public speaking to steady the other person. Handle others' emotions with patience, and never make anyone the target. When someone needs to vent, resist the urge to fix the problem or shift the conversation; simply being patient helps them calm down, and you should let people finish what they started rather than leaving it hanging. Questions and humour should never tease, embarrass, or come at someone else's expense. A deep, varied vocabulary signals intelligence and creativity — retire your repetitive words. Audit the words you overuse and find fresh replacements to sharpen how you come across.

The Five Dysfunctions of a Team — Patrick M. Lencioni

Exploring the role of a Field CTO and its principles

Brilliant individuals do not automatically produce brilliant teams — cohesion is the real competitive advantage. A cohesive unit of average players beats a collection of stars almost every time. Teamwork is hard to replicate; competitors can copy your technology, pricing, and products, but not a team that genuinely operates as more than the sum of its parts. The five dysfunctions stack as a pyramid: no trust → no conflict → no commitment → no accountability → bad results. Each layer depends on the one below it. Miss the foundation and every layer above it crumbles. The model is predictable, which means it's also fixable — but only if you work bottom-up. Vulnerability-based trust is the foundation, and leaders must go first. This isn't "I trust you to hit your deadline" reliability — it's the belief that exposing a weakness or admitting a mistake won't be weaponised. When the most senior person in the room makes themselves vulnerable, it gives everyone else permission. Without it, every meeting becomes a performance. Healthy conflict is the absence of politics, not the absence of passion. Teams mistake politeness for alignment. In reality, suppressed disagreement produces vague non-decisions and hallway grumbling. Constructive conflict — passionate debate about ideas, not people — is what surfaces the best thinking. Trust is what makes challenge feel like help rather than attack. Commitment doesn't require consensus — it requires that everyone was genuinely heard. Great teams rally behind decisions they personally argued against, because they trust the process. Any clear decision beats no decision; ambiguity at the top cascades into misalignment at every level below. Accountability must be peer-driven, not leader-dependent. When only the leader holds people to standards, the team never truly owns its performance. Calling out a colleague is uncomfortable but is a mark of respect. Make performance visible, celebrate the act of holding each other accountable, and standards rise organically. Collective results require goals so clear and measurable that no one can quietly optimise for their own scorecard. The culture shift is from "how does this help me advance?" to "how does this help us win?" At DecisionTech, a single specific target — 18 customers by year-end — unified the team so completely that engineering voluntarily supported sales demos. Time together is the enabler of everything else — regular meetings compound into trust, speed, and alignment. It feels expensive upfront but eliminates wasted effort, redundant work, and slow decisions. The investment isn't meetings for meetings' sake; it's creating the conditions for all five behaviours to take root through repeated, deliberate practice.

The First Minute — Chris Fenning

Exploring the role of a Field CTO and its principles

Framing — telling people what you're about to tell them — is the single highest-leverage communication habit. It sets the listener's mindset before the detail lands, preventing them from getting lost or building the wrong mental model. State your intent up front: are you seeking input, supplying information, or requesting a decision? Deadlines belong at the start, not buried at the end. Lead with Goal, Problem, Solution — not with background detail. The GPS framework forces you to open with what you're trying to achieve, what's in the way, and what you propose. Solution-first communication respects the audience's cognitive load and keeps discussion anchored to outcomes rather than wandering through context. Ensure your audience is ready to listen before you start talking. Confirming people are available and prepared to engage is a prerequisite, not a nicety. Respecting others' time and attention means you don't waste the first minute repeating yourself to people who weren't mentally present. Written communication needs the same structure: GPS bullets in emails, purpose and agenda in meeting invites. The framing principle isn't just verbal — emails without a clear goal/problem/solution bury the lead, and meetings without a stated purpose drift. Structured summaries work in every medium.

Prototype — Agent-Harness Claude Code plug-in

AI Agent Orchestration, Harnesses & Swarms

Prototype proved viable but shipped to "stop" — Superpowers already covers this ground well. The harness worked end-to-end, but duplicating an existing well-executed solution wasn't a sensible use of further effort. The learning from building it was the real deliverable, not the artefact. Reviewer agents are non-negotiable — sub-agents drift from spec and need reining back. Even with detailed specs, sub-agents deviate from instructions repeatedly and silently produce wrong work without a dedicated reviewer pass. Without that loop the whole harness can't be trusted. The reviewer loop is also where most of the cost and latency lives. Coordination plus review-and-correct dominates the spend, often outweighing the original task execution. Anyone budgeting for agent swarms must model this honestly rather than assume parallelism implies speed-up. Multi-agent harnesses are slower and more expensive than single-threaded for most tasks. The orchestration tax only pays off on genuinely large or long-horizon work. Default to single-threaded execution unless the scope clearly justifies the overhead. Worktree-based isolation is a genuinely powerful primitive for concurrent agents. Running sub-agents in their own git worktrees gives real parallelism without state collisions, and merging results back is cleaner than expected. This is the right pattern for any harness that needs multiple agents touching code at once. Sonnet vs Haiku is a real cost-versus-instruction-following trade-off, not just a speed knob. Haiku is cost-effective for narrow, well-specified subtasks; Sonnet earns its premium when the task requires holding context or making judgement calls. Routing tasks to the right model is a meaningful lever in harness design. Agent swarms are the right tool for complex or unsupervised work — and only that. When task size is such that human oversight cost dominates, parallel agents with reviewers are the only way to scale. Below that threshold, the economics simply don't hold.

Man and His Symbols — Carl Jung

Exploring the role of a Field CTO and its principles

The unconscious mind communicates through symbols and dreams, offering advice, warnings, and creative solutions that rational thought cannot reach. While we've consciously abandoned symbolic thinking, the unconscious still speaks this ancient language. Dreams can surface knowledge we already possess but haven't consciously registered — ignoring them widens the conscious-unconscious gap, leading to anxiety and dissociation. Archetypes — hero myths, the shadow, anima/animus — are universal psychic patterns shared across all of humankind that drive psychological development. These aren't learned but inherited as deep structures. The hero myth maps the journey to ego-consciousness; the shadow reveals repressed flaws; the anima/animus forces integration of opposite-sex qualities. Recognising these patterns in yourself and others is a practical tool for navigating personal growth and leadership transitions. Individuation is the process of reconciling conscious and unconscious by engaging seriously with dream symbolism — and it produces tangible life changes. It begins with emotional pain, progresses through confronting shadow and anima/animus figures, and culminates in encountering the Self (the totality of the psyche). Jung's case studies demonstrate that sustained engagement with unconscious material translates directly into real-world confidence and decision-making. Modern rationalism has severed our connection to symbolic meaning, and the cost is a dehumanised, anxious culture cut off from instinct. We traded mythological richness for efficiency but lost the sense of connection symbols once provided. Contemporary art — fragmented circles, dislocated forms — mirrors the disordered state of the collective unconscious, a diagnostic signal that this rift is civilisational, not merely personal.

AWS Summit London 2026 - ExCeL London

General breadth of knowledge improvements

AI dominated the agenda — the industry has unmistakably doubled down. Bar a handful of stands, virtually every booth and session pitched AI or agentic workflows. AI is no longer a track at AWS Summit; it is the substrate on which everything else is being rebuilt. Supply chain security has become a first-class concern, not an afterthought. Chainguard and similar vendors had a strong presence, framing operational security as the direct response to incidents like the Axios attack and SolarWinds. Hardened base images and provenance tooling now belong on the architectural shortlist for new services. Code scanning has moved well beyond static linting. Semgrep and socket.dev showed real maturity in detecting dependency-level threats and semantic vulnerabilities, not just syntactic patterns. Worth re-evaluating our existing scanning stack against these — the gap to next-gen tooling is widening rapidly. Snyk versus SonarQube is a closer fight than I'd assumed. Snyk's pitch focused on developer-loop integration and SCA depth rather than purely SAST, which is a different value proposition to SonarQube. They should be evaluated head-to-head rather than treated as interchangeable tooling. Kinesis and Lambda internals clarify when sync vs async is the right primitive. The deep-dive talks broke down the underlying mechanics of event delivery, retry semantics, and back-pressure, making the design trade-offs concrete rather than abstract. This is the level of understanding needed to choose between event-driven patterns confidently rather than by default. CloudFlare is not a practical fit for web scraping use cases. Direct conversation with their team confirmed their Workers platform and tooling weren't designed for this — the friction outweighs the benefit. Rules out a path I was considering and saves a speculative prototype. Direct relationship with our AWS account rep is now established. Met our named contact in person, which changes the dynamics of escalation and roadmap conversations versus going through generic support. Worth maintaining proactively rather than only reaching out when something is broken.

Claude Flow (ruvnet) — MCP-coordinated swarms (GitHub)

AI Agent Orchestration, Harnesses & Swarms

"Claude Flow coordinates, Claude Code creates." Clean MCP-as-coordinator / Claude Code-as-executor separation — coordination logic lives outside the LLM session, which is the right architectural cut. Spawn all agents in one message, never poll status after. Batched dispatch avoids the parallel-permission-prompt bug and keeps orchestrator turns cheap; polling is banned by convention. Cross-agent state via SQLite + HNSW vector memory is heavy. Powerful but expensive dependency surface for a plug-in; a lighter scratchpad-on-disk approach covers most of the same ground.

BMAD-METHOD — agile-roleplay pipeline (GitHub)

AI Agent Orchestration, Harnesses & Swarms

The task envelope is a markdown Story file with a Status: field. Human-readable, diffable, revertable — the envelope doubles as the audit trail, which is a genuinely nice property for regulated environments. Role-play ceremony is the cost. PM/Architect/SM/Dev/QA personas add sequential overhead; the QA handoff is aspirational rather than enforced, so BMAD relies on discipline where a harness should rely on hooks. State is polled, not pushed. Agents wait on the sprint file rather than receiving events — wastes orchestrator turns and masks stuck agents, since a silent hang reads identically to work in progress.

Spec-Flow — ultra-lightweight orchestrator (GitHub)

AI Agent Orchestration, Harnesses & Swarms

State lives on disk, not in context. The orchestrator re-reads state.yaml each turn rather than remembering — which is the right call because context is free to re-read but costly to carry. Sentinel return strings beat structured contracts. ---COMPLETED--- / ---NEEDS_INPUT--- / ---FAILED--- is a minimal, robust "done" channel parseable from the final assistant message — no schema needed. Questions batch back to the main context. Workers return questions; the orchestrator collects, asks the user once, and re-spawns — avoiding per-agent user prompts and the N-approval-prompt bug.

ezyang — Parallel Agents ❤ Sapling

AI Agent Orchestration, Harnesses & Swarms

Git is poorly suited to coordinated agent stacks. When a shared ancestor is amended, git worktrees force manual rebase per branch; Sapling's sl follow / sl adopt let dependent branches re-sync automatically. VCS choice is an orchestrator design constraint, not a taste preference. Parallel-agent throughput is bottlenecked by how cheaply the VCS handles divergent branches — a point most harness designs understate. The isolation backend should be abstracted. A harness targeting git today should leave room for jj/Sapling backends rather than baking git-worktree assumptions into the core.

HumanLayer — A Brief History of Ralph

AI Agent Orchestration, Harnesses & Swarms

Anthropic legitimised Ralph by shipping it in December 2025. The official ralph-wiggum plugin is a Stop hook that intercepts session end and re-feeds the prompt — confirmation that the community pattern is the sanctioned one. Boris Cherny uses it personally. Load-bearing signal: the Claude Code creator runs Ralph loops on his own work, which shifts Ralph from fringe hack to industry-standard technique. Completion-promise exact-string matching is brittle alone. Community wisdom converged on combining it with max_iterations, a no-change circuit breaker, and external verification — no single gate is trustworthy.

Ghuntley — Everything is a Ralph loop

AI Agent Orchestration, Harnesses & Swarms

Ralph generalises beyond coding. Huntley argues any task with a verifier and a fresh-context restart is a candidate — the pattern is a loop topology, not a coding trick. Parallel Ralphs for search/writes, serial Ralph for build/test. Backpressure at the verification step prevents the "all agents pass tests they wrote themselves" metric-gaming failure. The persistent artefact is the plan file, not the conversation. Each iteration reloads IMPLEMENTATION_PLAN.md; learnings go there rather than into context, which is why /compact timing becomes irrelevant.

Ghuntley — Ralph Wiggum as a "software engineer"

AI Agent Orchestration, Harnesses & Swarms

Ralph in its purest form is one line of bash. while :; do cat PROMPT.md | claude-code; done — the insight isn't the loop, it's the deterministic stack reload (prompt + specs + plan) on every iteration, with no conversation carried forward. "One item per loop" is the core discipline. Eventual consistency is load-bearing; the agent never attempts a large refactor in one turn, so context stays small and each iteration is cheaply recoverable. LLMs are mirrors of operator skill. Ralph failures point back to the prompt, not the model — treat every divergent iteration as a prompt-tuning signal rather than a tool limit.

Beuke — Ralph Wiggum Loop failure modes

AI Agent Orchestration, Harnesses & Swarms

The worst Ralph failure mode is hallucination amplification. A false assumption gets entrenched across iterations because each restart reloads the same corrupted plan file — the fix is to edit the prompt and start from scratch, not to let the loop push through. Oscillation is a symptom of weak verification. Fix A breaks B, fix B reintroduces A — the cure is a verifier that checks both invariants simultaneously, not better agent instructions. Piping errors back into context is actively harmful. Dense error-focused context degrades every subsequent attempt; fresh sessions per iteration are non-negotiable, which is why the loop topology beats a single long session.

Simon Willison — Hallucinations in code are the least dangerous form of LLM mistakes

AI Agent Orchestration, Harnesses & Swarms

Code hallucinations self-correct; prose hallucinations do not. The compiler, type checker, and test runner catch fabricated APIs immediately — the dangerous hallucinations are the ones no machine can verify. Agentic code loops amplify this advantage. Claude Code and similar systems that write-then-execute in a loop spot their own errors and self-repair, making code the safest domain for agent autonomy. The real risk is plausible-but-wrong code that compiles. Logic errors that pass tests but violate invariants are where engineering discipline (code review, property tests, invariant checks) has to compensate for LLM weakness.

Multi-Agent Risks from Advanced AI (arXiv 2502.14143)

AI Agent Orchestration, Harnesses & Swarms

Three structural failure modes: miscoordination, conflict, and collusion. The taxonomy is incentive-driven rather than symptom-driven, which is more predictive than "it didn't work" catalogues. Seven risk factors compound the failure modes, including information asymmetries, network effects, and emergent agency. The point is that swarms exhibit behaviours absent from any individual agent — a harness designer cannot reason about specialists in isolation. Multi-agent security is a discipline in its own right. Prompt injection and tool poisoning become orders of magnitude more dangerous when agents message each other directly — worth flagging before any inter-agent communication channel is added.

RichSnapp — Context Management with Subagents in Claude Code

AI Agent Orchestration, Harnesses & Swarms

Subagents are context firewalls, not just workers. Expensive exploration happens in a subagent so the main thread sees only the final message — architectural intent stays near the top of the orchestrator's context. "Context rot" is the real enemy. Tokens earlier in the window lose influence as implementation detail piles up, which is why long marathon sessions drift from the original design. Return a path, not content. The consensus pattern across harnesses is for specialists to write bulk output to disk and return a one-line summary plus file path — orchestrator context stays thin.

OpenAI Swarm — lightweight multi-agent orchestration (GitHub)

AI Agent Orchestration, Harnesses & Swarms

Handoffs and routines are the only two primitives. OpenAI's minimal framing reduces multi-agent orchestration to "which agent runs next" plus "what instructions does it follow" — deliberately smaller surface area than AutoGen or CrewAI. Swarm runs stateless on the client. No server, no persistence — the design explicitly rejects hidden state, which is the right default for debuggability even if production deployments add a state layer. Officially superseded by the OpenAI Agents SDK. Swarm is now an "educational framework"; the production path is the Agents SDK, which inherits the handoff primitive but adds guardrails and tracing.

AutoGen — Enabling Next-Gen LLM Applications via Multi-Agent Conversation (arXiv 2308.08155)

AI Agent Orchestration, Harnesses & Swarms

Agents are modelled as conversable entities, not task-runners. AutoGen's primitive is a two-way dialogue — handoffs, critique, and control flow are all expressed as messages rather than structured calls. Mixing natural language and code in conversation patterns is the key flexibility. The same framework supports autonomous agent chat, human-in-the-loop, and hybrid workflows by swapping message handlers rather than rewriting topology. The paper predates the current "avoid multi-agents for coding" backlash. AutoGen's design assumes inter-agent dialogue is beneficial; modern practice (Cognition, Anthropic's own caution) is more guarded — worth reading as the high-water mark of the conversational approach.

Why Do Multi-Agent LLM Systems Fail? (arXiv 2503.13657)

AI Agent Orchestration, Harnesses & Swarms

14 failure modes span three execution stages: pre-execution, execution, post-execution. The taxonomy is the first rigorous one for multi-agent LLM systems — useful as a checklist when debugging harness misbehaviour rather than guessing. Most failures are specification and coordination bugs, not model capability bugs. Swapping in a smarter model rarely helps; fixing role definitions, handoff contracts, and termination conditions usually does. Failure patterns are consistent across frameworks. AutoGen, MetaGPT, and ChatDev hit the same categories — evidence that the problem is architectural rather than framework-specific.

Cognition — Don't Build Multi-Agents

AI Agent Orchestration, Harnesses & Swarms

Context fragmentation is the original sin of multi-agent systems. When a task is split across agents, critical context gets lost in handoff — Cognition's Flappy Bird parable (Mario-style background plus incompatible bird) illustrates why compositional output fails. Single-threaded linear agents beat swarms in 2025. Cognition's blunt claim: every action should see every other relevant decision, which only a single context can guarantee. The Cognition vs Anthropic split is the defining architecture debate of the year. Anthropic counters that multi-agent wins for research (embarrassingly parallel exploration); Cognition argues code generation needs unified context. The right answer is task-shape-dependent.

Anthropic docs — Orchestrate teams of Claude Code sessions (Agent Teams)

AI Agent Orchestration, Harnesses & Swarms

Agent Teams remain experimental and gated on an env flag. They bring shared task lists, teammate-to-teammate messaging, and TeammateIdle/TaskCompleted hooks, but at the cost of stability — /resume does not restore in-process teammates. Teams cost roughly 7× a standard session in tokens. Each teammate maintains its own full context window, so parallel benefit must be real before scaling past the recommended 3–5 teammates. Quality-gate hooks are the killer feature. Exiting 2 from TaskCompleted rejects a "done" claim and forces the teammate to keep working — external verification the LLM cannot bypass.

Anthropic — How we built our multi-agent research system

AI Agent Orchestration, Harnesses & Swarms

Multi-agent beats single-agent by 90.2% on research tasks — but at 15× the tokens. The economics only work when task value justifies the spend; most business workflows do not clear that bar. Vague subtask prompts are the dominant failure mode. Subagents given thin descriptions duplicate work or re-run identical searches; detailed objective + output format + tool guidance + task boundaries is non-negotiable. The lead agent must learn to scale effort to complexity. Models are poor at judging "how hard is this?" so Anthropic bakes scaling heuristics into the orchestrator prompt rather than leaving it to the LLM's judgement.

Anthropic docs — Hooks

AI Agent Orchestration, Harnesses & Swarms

Exit code 2 is the only blocking signal. Exit 1 is non-blocking and silently dropped — a footgun that makes "broken safety net" hooks indistinguishable from working ones. SubagentStop with an agenttype matcher is the right lever for enforcing completion contracts. The hook receives lastassistant_message and transcript path, so a harness can verify a specialist's output before letting the result bubble up to the orchestrator. Hook types extend beyond shell commands. prompt-type (LLM evaluator) and agent-type (agentic verifier) hooks unlock review-style gates without writing scripts — useful for subjective completion criteria.

Anthropic docs — Plugins reference

AI Agent Orchestration, Harnesses & Swarms

Plugin-shipped agents lose hooks, mcpServers, and permissionMode frontmatter for security. Quality gates and budget caps must therefore live in plugin-level hooks/hooks.json with agent_type matchers — not per-agent. Plugins run from a cache directory, not in place. Paths like ../shared break post-install; use ${CLAUDEPLUGINROOT} for bundled assets and ${CLAUDEPLUGINDATA} for persistent state across updates. A version bump is required to push changes. Without it, users never see updates due to caching — an easy-to-miss trap during iterative plug-in development.

Alluxio: A Virtual Distributed File System (Haoyuan Li, UC Berkeley PhD Thesis)

Learn About Active Data Storage

The Virtual Distributed File System (VDFS) is the academic foundation of what's now called "data orchestration". Li's thesis frames the problem as a missing abstraction layer — analogous to how virtual memory abstracted over physical memory, the VDFS abstracts over heterogeneous storage systems. The original motivation was storage API fragmentation, not just performance. HDFS, S3, GCS, Azure Blob, NFS — every compute engine had to integrate each separately. The VDFS collapses the N×M integration matrix into N+M. Memory-centric design is a deliberate architectural choice, not an optimisation. The thesis argues memory is the new "storage" tier for analytics workloads; disk-first designs carry assumptions that no longer hold when DRAM and NVMe are plentiful. Lineage-based fault tolerance borrows from Spark's RDD model and applies it to a storage layer. Recomputing lost in-memory data via lineage (rather than replication) trades CPU for memory efficiency — a subtle but important design decision for cost-sensitive deployments. The academic framing predates the commercial terminology by years. "Active data storage", "data orchestration", "compute-side cache" are marketing repositionings of the core VDFS idea — valuable to know when evaluating newer-sounding vendor pitches. Advisors (Shenker, Stoica) anchor this in the Berkeley systems lineage. Alongside Spark, Mesos, and Ray, Alluxio is part of the same AMPLab research programme — a useful lens when comparing architectural choices across that family of systems.