AI Engineer · Published 2026-10-12

Hiring Employable Agents + Startup Battlefield Finals — Howie Liu, HyperAgent

privateReview: unreviewedConfidence: high
agentsfleetsorchestrationstate-machinemarkdownagent-runtimememoryHuman-in-the-loopAutonomy
Open on YouTube ↗

Summary

Overview

  • Speaker: Howie Liu
  • Channel: AI Engineer
  • Main topic: Hiring employable AI agents, product form factors for agents, and the AI Engineer World's Fair Startup Battlefield finals.
  • Purpose: To explain the product design evolution and organizational principles of deploying fleets of employable AI agents in real-world businesses, and to showcase innovative AI agent startups in the Startup Battlefield competition. Howie Liu, CEO of Hyperagent and Airtable, delivers a keynote on 'Hiring employable agents,' exploring the evolution of AI model form factors from completions to chats, agents, claws, and fleets. He argues that the future of software and business is about managing fleets of autonomous agents that collaborate, learn from feedback, and coordinate work across organizations. Following the keynote, the video transitions to the Startup Battlefield finals sponsored by Hyperagent, featuring three competing startups: Commod, Foundry, and Comment.io, with Commod taking 3rd place, Foundry taking 2nd, and Comment.io winning 1st place.

Topic Map

Hiring Employable Agents & Product Form Factors

  • Explanation: Howie Liu discusses how AI models have evolved in form factors—from completion and chat to agents, claws, and fleets—and how businesses can employ them.
  • Key claims:
    • Product form factors for AI models have progressed through completion, chat, agent, claw, and fleet.
    • Agents must be recursive, possess open-ended tool use, and be able to make complex decisions.
    • Fleet-level orchestration allows agents to work asynchronously and continuously without getting stuck in rabbit holes.
  • Examples:
    • A landscaping business using a fleet of agents (Sage, Surveyor, Dispatcher, Collector) to handle end-to-end operations from prospecting to proposal generation.
  • Terminology:
    • Completion
    • Chat
    • Agent
    • Claw
    • Fleet
    • Heartbeat mechanism
    • Sandbox VM
  • Why it matters: Understanding agent form factors helps product builders move beyond simple chat wrappers into autonomous, reliable software systems that run business processes.

Startup Battlefield Finals

  • Explanation: Three startups pitch their AI agent products to judges at the AI Engineer World's Fair Startup Battlefield, sponsored by Hyperagent.
  • Key claims:
    • Startups are building specialized agent swarms for complex traditional industries like commodities trading, content creation, and document editing.
    • Commod brings agentic execution to physical commodities trading.
    • Foundry turns content creators into founders using autonomous agent teams.
    • Comment.io provides a multiplayer markdown editor built for human-agent collaboration.
  • Examples:
    • Commod's CFC state machine automating compliance and document verification for gold and commodity trades.
    • Comment.io integrating AI coding agents directly into collaborative markdown editing threads.
  • Terminology:
    • CFC state machine
    • Agent swarm
    • Multiplayer markdown editor
    • Deterministic evidence-gated workflows
  • Why it matters: Demonstrates real-world applications of agentic workflows winning venture backing and competitions at the cutting edge of AI engineering.

Key Points

The Evolution of Model Form Factors

  • Explanation: AI models have scaled from simple text completion to structured chat, single-turn agents, self-waking claw agents, and multi-agent fleets.
  • Evidence: Howie Liu's spectrum chart showing Completion -> Chat -> Agent -> Claw -> Fleet.
  • Practical implication: Builders should design software interfaces that support long-running, self-waking agent loops rather than single-turn prompts.

Agents Must Learn from Feedback

  • Explanation: Static agents fail in production because they cannot adapt. Successful agents accumulate memory and skills dynamically from user interactions.
  • Evidence: Demonstration of Sage in Slack learning landscaping constraints and updating its memory draft.
  • Practical implication: Embedding memory and skill-building loops directly into agent workflows prevents repetitive errors.

Human Role Shifts to Orchestrator

  • Explanation: As agent capabilities expand, human work shifts from executing individual tasks to orchestrating and unblocking fleets of agents.
  • Evidence: Comparison of single-threaded human coding vs. managing parallel fleets of agentic developers.
  • Practical implication: Management skills in the AI era will involve defining guardrails, reviewing agent outputs, and unblocking execution bottlenecks.

Frameworks, Models & Processes

The Agent Progression Spectrum

  • How it works: Categorizes AI capability and interaction models into five distinct stages of product maturity.
  • Components:
    • Completion
    • Chat
    • Agent
    • Claw
    • Fleet
  • When to use: When designing AI software architectures and determining the appropriate level of autonomy for a use case.

The CFC Protocol State Machine

  • How it works: A patent-filed state machine using eight deterministic, evidence-gated steps to execute complex transactions.
  • Components:
    • KYC/KYB
    • Sanctions
    • Proof of Product
    • Warehouse Receipt
    • Load Inspection
    • Bill of Lading
    • Discharge
    • Settlement Eligible
  • When to use: When building high-stakes, regulated enterprise workflows requiring verifiable audit trails.

Examples & Case Studies

A landscaping business uses a fleet of agents (Sage, Surveyor, Dispatcher, Collector) to handle incoming customer leads, generate photo-realistic proposals, and draft itemized quotes.

  • Illustrates: How non-software businesses can employ full fleets of AI agents to automate end-to-end operations.
  • Lesson: Agent utility extends far beyond pure tech companies into traditional, high-touch industries.

Comment.io introduces a multiplayer markdown editor where AI coding agents collaborate alongside humans in real-time document threads.

  • Illustrates: Bridging the gap between human collaboration software and agentic execution environments.
  • Lesson: Documents and markdown are the natural collaboration medium for mixed teams of humans and AI agents.

Actionable Takeaways

  • Immediate:
    • Adopt agent architectures that support heartbeat mechanisms for self-waking execution.
    • Design user interfaces that allow humans to unblock agents and provide contextual feedback.
    • Explore tools that enable multi-agent orchestration rather than single-agent chat bots.
  • Strategic:
    • The future of enterprise software is agent-native, transforming companies into fleets of employable agents.
    • Trust and taste are the ultimate defensibility when the cost of writing software approaches zero.
    • Vertical integration of agent swarms into regulated industries creates massive efficiency gains.
  • Questions to investigate:
    • How do we establish robust guardrails for autonomous multi-agent fleets operating across enterprise boundaries?
    • What governance models are required when agents execute financial transactions or legal contracts autonomously?

Claims Worth Verifying

  • $17 trillion in physical commodities move every year. (Market Statistic)
  • The cost of building software is approaching zero. (Economic Trend)

Notable Quotes

"I consider myself a product thinker at heart." "Hiring employable agents... as these models have gotten better and better and we've heard from some really, really great speakers." "Physical commodities power the world, but the global trade system is broken." "The cost of building software is approaching zero. What's left is trust and taste."

Compressed Summary

  • AI models have evolved from completions and chats to autonomous agents, claws, and fleets.
  • Successful agents feature heartbeat mechanisms, recursive tool calls, and continuous skill learning from user feedback.
  • Startup Battlefield showcased innovative agent-first companies: Commod (3rd), Foundry (2nd), and Comment.io (1st).
  • Comment.io won first place with its multiplayer markdown editor designed for human-agent collaboration.
  • Keywords: agents, fleets, orchestration, state-machine, markdown
  • Core insight: The shift from human-executed workflows to employable agent fleets requires reimagining software interfaces around agent autonomy, unblocking, and real-time collaboration.

Core insights

6
Architecturehigh noveltymoderate evidence

The 'claw' form factor is a distinct architectural stage between single-turn agents and multi-agent fleets: a self-waking agent driven by a heartbeat mechanism rather than being invoked per request, which changes the runtime from request/response to a long-running loop.

Why it matters

If agents are expected to run continuously and self-wake, the runtime must manage scheduling, persistent state, sandbox VMs, and wake semantics — not just prompt plumbing. This shifts where the hard engineering lives (scheduler + state store) versus the model call.

Generalization

Any autonomous system benefiting from periodic self-initiation (monitoring, prospecting, follow-up) needs an explicit wake/heartbeat scheduler decoupled from user input events.

AI models have scaled from simple text completion to structured chat, single-turn agents, self-waking claw agents, and multi-agent fleets.
Open source video
Adopt agent architectures that support heartbeat mechanisms for self-waking execution.
Open source video
Mechanismmedium noveltymoderate evidence

Fleet-level orchestration is framed as the mechanism that prevents a single agent from getting stuck in rabbit holes: instead of one long-running thread, work is decomposed across multiple agents running asynchronously and continuously.

Why it matters

This is a reliability pattern, not a scaling pattern: splitting work across a fleet bounds the blast radius of any one agent's failure or fixation, implying orchestration should be designed for containment as much as throughput.

Generalization

Long-horizon tasks can be made more robust by distributing them across bounded-scope agents with independent execution rather than extending a single agent's context and runtime.

Fleet-level orchestration allows agents to work asynchronously and continuously without getting stuck in rabbit holes.
Open source video
Explore tools that enable multi-agent orchestration rather than single-agent chat bots.
Open source video
Architecturehigh noveltymoderate evidence

For high-stakes regulated transactions, the winning architecture is a deterministic, evidence-gated state machine (CFC: eight steps such as KYC/KYB, Sanctions, Proof of Product, Warehouse Receipt, Load Inspection, Bill of Lading, Discharge, Settlement Eligible) rather than free-form agent autonomy.

Why it matters

It suggests a hybrid boundary: deterministic state machines own correctness, gating, and auditability, while agents handle the fuzzy sub-tasks inside each gate. This is a concrete alternative to 'let the agent reason through the whole workflow.'

Generalization

In domains requiring audit trails, encode the outer control flow as explicit deterministic states with evidence gates, and confine model reasoning to within-state work.

A patent-filed state machine using eight deterministic, evidence-gated steps to execute complex transactions.
Open source video
When building high-stakes, regulated enterprise workflows requiring verifiable audit trails.
Open source video
Mechanismmedium noveltymoderate evidence

Memory and skills are accumulated as a side effect of live user interaction, demonstrated by Sage in Slack learning landscaping constraints and updating its memory draft — memory is treated as an editable, reviewable artifact rather than an opaque store.

Why it matters

A user-visible, user-correctable memory draft gives a feedback channel for prompt/behavior correction without retraining, and makes agent drift observable and fixable in production.

Generalization

Exposing agent memory as a human-editable artifact turns memory maintenance into an operational workflow instead of a hidden failure surface.

Static agents fail in production because they cannot adapt. Successful agents accumulate memory and skills dynamically from user interactions.
Open source video
Demonstration of Sage in Slack learning landscaping constraints and updating its memory draft.
Open source video
Architecturemedium noveltyweak evidence

Multiplayer markdown is proposed as the shared collaboration medium between humans and coding agents, i.e. the document/thread — not a chat window — is where mixed human-agent work converges.

Why it matters

Choosing documents as the substrate means agent output must be expressed as versioned, diffable, commented-on artifacts, which changes persistence, concurrency, and review design versus a chat transcript.

Generalization

When agents and humans co-produce work, the shared artifact format (markdown, diff, document) drives the collaboration protocol more than the conversational interface does.

Comment.io provides a multiplayer markdown editor built for human-agent collaboration.
Open source video
Documents and markdown are the natural collaboration medium for mixed teams of humans and AI agents.
Open source video
Mental Modellow noveltymoderate evidence

The human role is reframed as orchestrator of parallel agent fleets, where the new skills are defining guardrails, reviewing agent outputs, and unblocking execution bottlenecks rather than executing tasks.

Why it matters

If the human is primarily an unblocker of parallel workstreams, then bottleneck detection and unblock ergonomics are first-class product features, not afterthoughts.

Generalization

As agent parallelism grows, the limiting resource becomes human review/unblock bandwidth, making queue-visibility and intervention tooling the dominant UX constraint.

As agent capabilities expand, human work shifts from executing individual tasks to orchestrating and unblocking fleets of agents.
Open source video
Management skills in the AI era will involve defining guardrails, reviewing agent outputs, and unblocking execution bottlenecks.
Open source video

Deep dives

5

Heartbeat-driven self-waking runtime for claw agents

Research question

How should heartbeat-driven self-waking be implemented to avoid duplicate wakes, missed wakes, and runaway cost while preserving idempotent execution and sandbox lifecycle management?

Why

If claw agents self-wake rather than being invoked per request, the runtime must own scheduling, wake/idle semantics, durable state, and sandbox lifecycle — making the scheduler and state store the hard engineering surface.

Adopt agent architectures that support heartbeat mechanisms for self-waking execution.
Open source video
AI models have scaled from simple text completion to structured chat, single-turn agents, self-waking claw agents, and multi-agent fleets.
Open source video
Source video

Deterministic evidence-gated state machines vs. agent autonomy in regulated workflows

Research question

How do evidence-gated state machines compare with approval-gate and human-in-the-loop models on auditability, latency, and exception handling in high-stakes regulated transactions?

Why

This defines the hybrid boundary: deterministic states own correctness, gating, and audit trails, while agents handle fuzzy sub-tasks inside each gate — a concrete alternative to letting an agent reason through the whole workflow.

A patent-filed state machine using eight deterministic, evidence-gated steps to execute complex transactions.
Open source video
When building high-stakes, regulated enterprise workflows requiring verifiable audit trails.
Open source video
Source video

Form-factor selection criteria: chat, agent, claw, or fleet

Research question

What measurable properties per form factor (interactivity, latency tolerance, need for self-wake, task parallelism) determine when a use case should use chat, agent, claw, or fleet, and what are the consequences of choosing incorrectly?

Why

The progression spectrum is presented as a categorization but without selection criteria; without mapping workload properties to architecture, teams default to chat wrappers or overbuild fleets.

Product form factors for AI models have progressed through completion, chat, agent, claw, and fleet.
Open source video
Explore tools that enable multi-agent orchestration rather than single-agent chat bots.
Open source video
Source video

Fleet orchestration as containment for rabbit-hole failure modes

Research question

Does fleet decomposition measurably reduce stuck-loop incidence and recovery time versus a single long-running agent on the same long-horizon task, when token cost and task completion are controlled?

Why

This reframes fleet orchestration as a reliability pattern (blast-radius control) rather than a scaling pattern; if true, orchestration design should optimize for independent execution and recovery, not just throughput.

Fleet-level orchestration allows agents to work asynchronously and continuously without getting stuck in rabbit holes.
Open source video
Explore tools that enable multi-agent orchestration rather than single-agent chat bots.
Open source video
Source video

Editable memory drafts as operational control for agent drift

Research question

How should versioning, eviction, and rollback be designed for user-editable memory drafts so that accumulated memory improves adaptation without causing behavior drift or regressions?

Why

A user-visible, user-correctable memory draft gives a feedback channel for behavior correction without retraining, and makes agent drift observable and fixable in production.

Static agents fail in production because they cannot adapt. Successful agents accumulate memory and skills dynamically from user interactions.
Open source video
Demonstration of Sage in Slack learning landscaping constraints and updating its memory draft.
Open source video
Source video

Article ideas

4

The Claw Is a Runtime, Not a Model: Why Heartbeat Scheduling Defines the Next Agent Form Factor

The step from agent to claw is not an intelligence upgrade but a runtime upgrade: self-waking loops force product teams to build schedulers, durable state, and sandbox lifecycle management, so the runtime — not the prompt — becomes the product.

Angle

Architectural teardown of the completion→chat→agent→claw→fleet progression, focusing on the wake/heartbeat boundary and its engineering consequences.

Source video

In Regulated Workflows, Deterministic Gates Beat Agentic Reasoning

For high-stakes regulated transactions, correctness and auditability should be owned by an evidence-gated state machine, with agents confined inside each gate; free-form agent reasoning over the whole workflow is an audit liability, not a feature.

Angle

Contrast the CFC eight-state evidence-gated pipeline with free-form autonomy and approval-gate models, and derive a hybrid design rule.

Source video

Fleet Orchestration Is a Reliability Pattern, Not a Scaling Pattern

Decomposing long-horizon work across bounded-scope agents is primarily a containment strategy for rabbit-hole failures and runaway threads; treating fleets only as throughput multipliers misses the blast-radius control that makes them valuable.

Angle

Reframe fleet orchestration through failure containment, independent execution, and recovery, with design implications for handoff, shared memory, and per-agent scope.

Source video

Memory Drafts: Making Agent Drift a Reviewable Artifact

Exposing agent memory as an editable, versioned draft turns drift from a hidden failure surface into an operational workflow; memory maintenance becomes a reviewable product feature rather than an opaque store.

Angle

Operational design for memory drafts: what to persist from live interaction, how users correct it, and how to handle eviction, rollback, and conflict.

Source video

Project ideas

4

Heartbeat Harness

new

Adding an idempotent heartbeat scheduler with lease-based wake locks reduces duplicate executions and missed wakes compared to naive cron/event triggers, without increasing cost per successful wake.

Proof of concept

Run a self-waking agent loop under simulated failure, restart, and concurrent wake conditions; compare naive triggers vs lease-based heartbeat scheduling with durable wake log.

Measurement

Duplicate executions per 100 wakes, missed wakes, cost per successful wake, recovery time after restart.

Source video

EvidenceGate Comparator

gatehouse

In regulated transaction workflows, an evidence-gated state machine yields fewer unverifiable transitions and lower audit-reconstruction time than free-form agent reasoning, at comparable task completion.

Proof of concept

Implement a CFC-like eight-state pipeline with evidence gates; run synthetic commodity trade cases through both the state machine and a free-form agent baseline.

Measurement

Missing evidence incidents, audit reconstruction time, exception handling rate, task completion rate.

Source video

Fleet Rabbit-Hole Benchmark

beyond-evals

Distributing a long-horizon task across role-specialized agents with independent execution reduces stuck-loop incidence and time-to-recovery versus a single long-running agent, even when total token cost is held equal.

Proof of concept

Benchmark single-agent vs fleet on a landscaping/dispatch scenario (Sage, Surveyor, Dispatcher, Collector), instrumenting thread fixation and recovery.

Measurement

Stuck-loop incidence, time-to-recovery, task completion rate, token cost per completed task.

Source video

Editable Memory Draft Protocol

new

A user-editable memory draft with versioning and rollback reduces post-correction regressions compared to an opaque memory store, as measured by retention of corrected constraints across later sessions.

Proof of concept

Build a memory draft for a Sage-like agent; simulate user corrections to landscaped constraints; compare versioned editable memory vs opaque memory over repeated interactions.

Measurement

Retention of corrected constraints, regression rate after correction, rollback success, review time per memory update.

Source video

Architectural implications

4

Agents move from request-scoped invocation to self-waking long-running loops.

Before

Software interfaces built around single-turn prompts and synchronous responses.

After

Interfaces supporting long-running, self-waking agent loops with heartbeat scheduling and persistent state.

Consequence

Runtime must own scheduling, wake/idle semantics, durable state, and sandbox lifecycle rather than relying on caller round-trips.

Source video

Full-process automation is decomposed into named specialist agents (Sage, Surveyor, Dispatcher, Collector) rather than one generalist.

Before

One agent or chatbot owning an end-to-end business process.

After

A fleet of role-specialized agents coordinated by fleet-level orchestration.

Consequence

Orchestration, handoff, and shared memory become the critical design surfaces; per-agent scope stays bounded.

Source video

Regulated, high-value transactions are routed through deterministic evidence-gated states.

Before

Free-form agent reasoning over the entire transaction with no enforced gates.

After

Eight explicit deterministic states with evidence gates (KYC/KYB through Settlement Eligible), agents working inside gates.

Consequence

Auditability and correctness come from the state machine; agents cannot skip required evidence, reducing unverifiable autonomy.

Source video

Documents rather than chat become the human-agent collaboration surface.

Before

Human-agent interaction mediated by a chat transcript.

After

Multiplayer markdown documents where agents edit, comment, and collaborate in real time.

Consequence

Persistence, concurrency control, versioning, and review tooling must be built to artifact semantics, not message semantics.

Source video

Tradeoffs and failure modes

4

Autonomy vs. rabbit holes

Benefit

Asynchronous fleet execution lets agents work continuously without waiting on a single thread.

Cost or risk

Single long-running agents can get stuck in unproductive loops; mitigation requires fleet-level orchestration whose coherence costs are not described.

Fleet-level orchestration allows agents to work asynchronously and continuously without getting stuck in rabbit holes.
Open source video
Source video

Determinism vs. flexibility in high-stakes workflows

Benefit

Deterministic, evidence-gated steps produce verifiable audit trails for regulated transactions.

Cost or risk

Rigid pre-defined states may not accommodate unmodeled transaction variants, and the summary provides no evidence of how exceptions are handled.

When building high-stakes, regulated enterprise workflows requiring verifiable audit trails.
Open source video
Source video

Cost of software vs. defensibility

Benefit

When software construction is cheap, differentiation shifts to trust and taste.

Cost or risk

This is a forward-looking claim with no supporting evidence in the summary; teams optimized purely on build velocity may misallocate investment.

Trust and taste are the ultimate defensibility when the cost of writing software approaches zero.
Open source video
Source video

Dynamic memory vs. behavior stability

Benefit

Memory and skills accumulated from user interactions let agents adapt instead of failing statically.

Cost or risk

Continuously updated memory can drift; the summary shows a memory draft under user review but does not describe eviction, versioning, or rollback.

Static agents fail in production because they cannot adapt. Successful agents accumulate memory and skills dynamically from user interactions.
Open source video
Source video

Open questions

4

How do you establish robust guardrails for autonomous multi-agent fleets operating across enterprise boundaries?

Why unresolved

Listed explicitly as an open question in the summary with no proposed mechanism.

Research direction

Prototype cross-boundary policy enforcement points and per-fleet permission scoping, then measure containment under adversarial or ambiguous instructions.

Source video

What governance models are required when agents execute financial transactions or legal contracts autonomously?

Why unresolved

The summary raises governance as unresolved despite presenting the CFC state machine as a partial answer.

Research direction

Compare evidence-gated state machines against approval-gate and human-in-the-loop models on auditability, latency, and exception handling.

Source video

What criteria determine whether a use case should use a chat, agent, claw, or fleet form factor?

Why unresolved

The progression spectrum is presented as a categorization but the summary gives no selection criteria or failure consequences for choosing incorrectly.

Research direction

Define measurable properties per stage (interactivity, latency tolerance, need for self-wake, task parallelism) and map them to architecture choices.

Source video

How should heartbeat-driven self-waking be implemented to avoid duplicate wakes, missed wakes, and runaway cost?

Why unresolved

The summary names heartbeat mechanisms and sandbox VMs but gives no scheduling, idempotency, or cost-control detail.

Research direction

Build a harness measuring wake frequency, duplicate execution, and cost under failure/restart conditions.

Source video

Key claims

7
comparativeVerification needed

AI product form factors have progressed through a sequence: completion, chat, agent, claw, fleet.

Evidence

Product form factors for AI models have progressed through completion, chat, agent, claw, and fleet.

Question

Is this progression a real industry-wide trend or a vendor framing, and are the stage boundaries (especially claw vs agent) defined consistently elsewhere?

Source video
causalVerification needed

Static agents fail in production because they cannot adapt; successful agents accumulate memory and skills dynamically from feedback.

Evidence

Static agents fail in production because they cannot adapt. Successful agents accumulate memory and skills dynamically from user interactions.

Question

What failure rates or task-completion deltas are observed between static and feedback-accumulating agents?

Source video
causalVerification needed

Fleet-level orchestration prevents agents from getting stuck in rabbit holes by allowing asynchronous, continuous work.

Evidence

Fleet-level orchestration allows agents to work asynchronously and continuously without getting stuck in rabbit holes.

Question

Does fleet decomposition measurably reduce stuck-loop incidence versus a single long-running agent on the same task?

Source video
factualVerification needed

The CFC state machine uses eight deterministic, evidence-gated steps to execute complex commodity transactions.

Evidence

A patent-filed state machine using eight deterministic, evidence-gated steps to execute complex transactions.

Question

What are the eight states precisely, and does determinism hold on real-world exception paths?

Source video
factualVerification needed

$17 trillion in physical commodities move every year.

Evidence

$17 trillion in physical commodities move every year.

Question

What is the source and vintage of this market-size figure?

Source video
predictionVerification needed

Trust and taste are the ultimate defensibility when the cost of writing software approaches zero.

Evidence

Trust and taste are the ultimate defensibility when the cost of writing software approaches zero.

Question

Is there evidence that trust/taste moats outperform distribution, data, or integration moats as software construction costs fall?

Source video
causalVerification needed

Agent utility extends beyond tech companies into traditional, high-touch industries such as landscaping.

Evidence

Agent utility extends far beyond pure tech companies into traditional, high-touch industries.

Question

What evidence exists that non-software SMBs sustain agent fleets in production, versus one-off demos?

Source video

Connections

5