AI Engineer · Published 2026-10-09

Designing CLIs for Agents, Not Humans — Pedro Lopez, Airbyte

privateReview: unreviewedConfidence: high
MCPcliairbyteoauthagentsjsonagent-clitool-designprogressive-discoveryheadless-authjson-ioagent-interfaces
Open on YouTube ↗

Summary

Overview

  • Speaker: Pedro Lopez
  • Channel: AI Engineer
  • Main topic: Building and designing Model Context Protocol (MCP) servers and CLIs specifically optimized for AI agents rather than human users.
  • Purpose: To share architectural best practices, design patterns, and lessons learned when building agent-facing interfaces (MCP servers and CLIs) for data infrastructure platforms like Airbyte. Pedro Lopez from Airbyte discusses how Airbyte evolved into the data and action layer for AI agents, detailing their experience in building the Airbyte Agent MCP Server and CLI. The talk outlines three main interface capabilities (manage, connect, ask & act), compares MCP and CLI interfaces, explains Airbyte's architectural design decisions (thin unified interfaces over core platform APIs), and shares four key design lessons for MCP (keep tool counts small, use OAuth, avoid elicitation due to poor client support) and four key design lessons for CLIs (JSON in JSON out, consistency is key, skills ship with the tool, auth must be headless).

Topic Map

Introduction & Context on Airbyte

  • Explanation: Pedro Lopez introduces himself as a software engineer at Airbyte and provides context on Airbyte's transition from an open-source data movement standard for SaaS tools to the data and action layer for AI agents via its context store.
  • Key claims:
    • Airbyte connects SaaS tools to data analytics pipelines and now acts as the data and action layer for AI agents.
    • Airbyte Agent product offers a context store providing a search-optimized index of enterprise data for AI agents.
  • Examples:
    • Connecting Zendesk, Stripe, and GitHub data to LLM frameworks like LangChain, Claude, and ChatGPT via Airbyte's context store.
  • Terminology:
    • Airbyte
    • Context Store
    • SaaS tools
    • AI agents
  • Why it matters: Establishes the foundational architecture of how agents interact with underlying enterprise tools and data.

Agent Interfaces: SDK, UI, MCP, and CLI

  • Explanation: Airbyte provides four interfaces to the context store: SDK (Python), UI (web app), MCP, and CLI (terminal). The talk focuses primarily on MCP and CLI for existing agent integrations like ChatGPT and Claude.
  • Key claims:
    • Agent interfaces must support three main capabilities: Manage (workspaces and connectors), Connect (safe third-party authentication), and Ask & Act (search, read, and write across systems).
    • MCP and CLI are thin unified interfaces sitting on top of core platform APIs.
  • Examples:
    • Using ChatGPT and Claude via MCP to query customer support tickets and payment data.
  • Terminology:
    • MCP (Model Context Protocol)
    • CLI
    • SDK
    • Context Store
  • Why it matters: Demonstrates multi-modal access patterns for making enterprise data actionable by AI agents everywhere.

Designing MCP for Agents: Lessons Learned

  • Explanation: Discusses architectural and design lessons learned when building the Airbyte Agent MCP server, focusing on tool count minimization, OAuth authentication, and the limitations of elicitation.
  • Key claims:
    • Keep tool counts small using progressive discovery (e.g., separate describe_connector and execute tools rather than exposing individual tools for every connector entity).
    • OAuth is the required authentication standard because users expect long-lived headless sessions similar to mobile apps.
    • Elicitation (URL-mode or form-mode) is problematic due to inconsistent support across MCP clients.
  • Examples:
    • Connecting to Acme service or Anthropic custom connector via OAuth.
  • Terminology:
    • MCP
    • Progressive discovery
    • OAuth
    • Elicitation
    • describe_connector
    • execute
  • Why it matters: Provides concrete architectural guidelines for developers building MCP servers for AI agents.

Designing CLIs for Agents: Lessons Learned

  • Explanation: Explores how to design CLIs specifically for agent invocation rather than human usage, emphasizing JSON I/O, strict naming consistency, bundled skills, and headless authentication.
  • Key claims:
    • Design CLIs with JSON in and JSON out as the primary interface to allow programmatic construction and leverage Unix piping/jq for large responses.
    • Consistency is key: follow predictable naming patterns (noun-verb order like connectors list, connectors create) to prevent agent errors.
    • Skills must ship with the tool via markdown files to enable agent discovery and effective usage without bloating context.
    • Auth must be headless (environment variables or config files with API keys) because CLI agents cannot wait for interactive human prompts.
  • Examples:
    • Running airbyte-agent connectors execute --json ... and piping output to jq.
    • Using a SKILL.md reference file to teach Claude how to use the CLI.
  • Terminology:
    • CLI
    • JSON in, JSON out
    • Piping
    • jq
    • Skills
    • Headless auth
    • SKILL.md
  • Why it matters: Highlights that human-centric CLI design principles (like interactive prompts and human-readable flags) break when agents invoke terminals.

Key Points

Thin unified interface architecture

  • Explanation: MCP and CLI are presented as thin presentation layers sitting on top of shared platform APIs rather than re-implementations of business logic.
  • Evidence: Platform changes frequently (over 10 times a day), so interfaces rely on OpenAPI specs as a single source of truth.
  • Practical implication: Reduces maintenance overhead when underlying platform APIs undergo frequent deployments.

Keep tool counts small via progressive discovery

  • Explanation: Exposing every possible action as a separate MCP tool overwhelms agent context and degrades performance.
  • Evidence: Airbyte consolidated connector interactions into two core tools: describe_connector and execute.
  • Practical implication: Improves agent reliability by letting agents dynamically query schemas only when needed.

CLIs for agents require JSON I/O and strict consistency

  • Explanation: Human-friendly flags and interactive prompts fail when agents invoke commands programmatically.
  • Evidence: All commands accept JSON payloads and output JSON, enabling seamless integration with Unix pipes and jq.
  • Practical implication: Agents can reliably parse responses and handle complex multi-step data cross-referencing operations.

Frameworks, Models & Processes

Airbyte Agent Interface Framework

  • How it works: Exposes core platform capabilities through specialized interfaces (SDK, UI, MCP, CLI) backed by a unified context store and OpenAPI-based APIs.
  • Components:
    • Platform Core / APIs
    • Context Store
    • Presentation Layer (MCP & CLI)
    • Authentication Layer (OAuth & Headless Auth)
  • When to use: When exposing enterprise SaaS tools and data pipelines to AI agents and LLM frameworks.

Examples & Case Studies

An agent cross-referenced Stripe payments with Zendesk support tickets via Airbyte MCP/CLI.

  • Illustrates: Multi-tool data aggregation and action execution by AI agents.
  • Lesson: Providing unified interfaces across disparate SaaS tools allows agents to answer complex business queries accurately.

Actionable Takeaways

  • Immediate:
    • Keep MCP tool counts small and use progressive discovery.
    • Implement OAuth for MCP servers to support long-lived sessions.
    • Design CLIs with JSON in, JSON out to enable Unix piping and jq parsing.
  • Strategic:
    • Treat MCP and CLI as thin presentation interfaces over OpenAPI-driven platform backends.
    • Design CLIs specifically for headless execution without assuming a human is present to answer interactive prompts.
    • Bundle skill documentation (SKILL.md) directly with CLI tools for agent discovery.
  • Questions to investigate:
    • How are different MCP clients handling authentication token expiration across vendors?
    • What are the best patterns for managing rate limits and tool call timeouts in MCP servers?

Claims Worth Verifying

  • Platform APIs change over 10 times a day at Airbyte. (statistic)
  • MCP clients have inconsistent support for URL-mode and form-mode elicitation. (technical observation)

Notable Quotes

"The MCP and CLI are interfaces to the platform. Most of the surface is presentational: take command, call the API, return the result." (at 5:03) "Keep the tool counts small. Easier for an agent to know what to call with minimal guidance." (at 9:14) "OAuth is the way. Users expect long-lived sessions, akin to a mobile app." (at 10:52) "Don't assume that a human is present and able to interactively go through prompts." (at 25:09)

Compressed Summary

  • Airbyte built MCP servers and CLIs to act as data and action layers for AI agents.
  • MCP is ideal for non-technical users and quick prototyping with ChatGPT and Claude.
  • CLI is better for technical users, longer-running tasks, and large response handling via JSON and jq.
  • Key MCP lessons: keep tool counts small, use OAuth, avoid elicitation due to client inconsistencies.
  • Key CLI lessons: JSON in JSON out, noun-verb consistency, bundle SKILL.md documentation, ensure headless auth.
  • Keywords: mcp, cli, airbyte, oauth, agents, json
  • Core insight: Building effective agent interfaces requires designing for headless execution, strict consistency, and minimal tool contexts rather than mimicking human UX patterns.

Core insights

7
Architecturemedium noveltymoderate evidence

Collapse many per-entity tools into a two-tool discover-then-execute pattern (describe_connector + execute) instead of one MCP tool per connector entity.

Why it matters

Exposing every possible action as a separate tool overwhelms the agent's context and degrades tool-selection reliability; progressive discovery lets the agent fetch schemas only when needed.

Generalization

Any agent-facing API surface with a large or growing action space should expose a stable, small set of meta-tools plus a runtime discovery mechanism rather than enumerating every operation statically.

Exposing every possible action as a separate MCP tool overwhelms agent context and degrades performance.
Open source video
Airbyte consolidated connector interactions into two core tools: describe_connector and execute.
Open source video
Keep tool counts small using progressive discovery (e.g., separate describe_connector and execute tools rather than exposing individual tools for every connector entity).
Open source video
Failure Modehigh noveltymoderate evidence

Elicitation (URL-mode or form-mode) should be avoided in MCP servers because client support is inconsistent across MCP clients.

Why it matters

Designing a bidirectional interaction that depends on client-side elicitation support creates portability failures — the same server behaves differently or breaks across hosts like ChatGPT and Claude.

Generalization

Agent-facing protocols should not depend on optional interactive round-trips whose support varies across runtimes; push required interactions out-of-band rather than into the protocol hop.

Elicitation (URL-mode or form-mode) is problematic due to inconsistent support across MCP clients.
Open source video
OAuth is the required authentication standard because users expect long-lived headless sessions similar to mobile apps.
Open source video
Practicemedium noveltystrong evidence

Agent-invoked CLIs should be JSON-in/JSON-out rather than human-readable flags, enabling programmatic construction and Unix piping/jq for large responses.

Why it matters

Human-friendly flags and interactive prompts fail when agents invoke commands programmatically; JSON I/O lets agents reliably parse responses and chain multi-step data cross-referencing.

Generalization

When a tool's primary consumer is a machine, its I/O contract should be structured and composable; human ergonomics become a secondary concern layered on top.

Design CLIs with JSON in and JSON out as the primary interface to allow programmatic construction and leverage Unix piping/jq for large responses.
Open source video
All commands accept JSON payloads and output JSON, enabling seamless integration with Unix pipes and `jq`.
Open source video
Human-friendly flags and interactive prompts fail when agents invoke commands programmatically.
Open source video
Practicemedium noveltymoderate evidence

CLI commands need strictly predictable noun-verb naming consistency (e.g. connectors list, connectors create) to prevent agent errors.

Why it matters

Agents rely on pattern extrapolation across commands; irregular or human-idiomatic naming breaks that extrapolation and causes wrong-command invocations.

Generalization

Machine-facing API/CLI surface naming should be a strict grammar, not an ergonomic choice, because the caller is a pattern-completing model rather than a human with memory.

Consistency is key: follow predictable naming patterns (noun-verb order like connectors list, connectors create) to prevent agent errors.
Open source video
Mechanismhigh noveltymoderate evidence

Skills documentation should ship inside the tool as markdown files (e.g. SKILL.md) so the agent can discover usage without bloating context.

Why it matters

Bundled skill files let the agent learn tool usage on demand rather than pre-loading documentation into context, decoupling teachability from context budget.

Generalization

Tool documentation should be co-located with the tool and loaded lazily by the agent, rather than embedded in the calling context up front.

Skills must ship with the tool via markdown files to enable agent discovery and effective usage without bloating context.
Open source video
Using a `SKILL.md` reference file to teach Claude how to use the CLI.
Open source video
Architecturemedium noveltymoderate evidence

MCP and CLI should be thin presentation layers over shared platform APIs with OpenAPI specs as the single source of truth, because the platform deploys over 10 times a day.

Why it matters

Re-implementing business logic in each agent-facing interface guarantees drift and maintenance overhead under high deployment frequency; a thin layer over a stable spec keeps interfaces cheap to maintain.

Generalization

Agent interfaces should be generated/presented from the source-of-truth API contract, never fork its logic, especially when the underlying surface changes rapidly.

MCP and CLI are presented as thin presentation layers sitting on top of shared platform APIs rather than re-implementations of business logic.
Open source video
Platform changes frequently (over 10 times a day), so interfaces rely on OpenAPI specs as a single source of truth.
Open source video
Tradeoffmedium noveltymoderate evidence

Authentication for agent-facing tools must be headless (env vars/config files with API keys), with OAuth favored because agents expect long-lived sessions.

Why it matters

Interactive prompts stall unattended agents; a headless auth path is a hard requirement for reliability, and long-lived sessions shape the token strategy.

Generalization

Auth flows for autonomous consumers must not block on human interaction mid-task; credential acquisition should happen out-of-band before the agent runs.

Auth must be headless (environment variables or config files with API keys) because CLI agents cannot wait for interactive human prompts.
Open source video
OAuth is the required authentication standard because users expect long-lived headless sessions similar to mobile apps.
Open source video

Deep dives

5

Optimal tool surface size and progressive discovery for agent-facing APIs

Research question

What is the optimal number and shape of meta-tools (e.g., describe/execute) for a given integration breadth, and how does discovery latency trade against agent reliability and context usage?

Why

Tool count is treated as a first-class design constraint, but no measured threshold or benchmark is given. Getting this wrong either overwhelms agent context or forces excessive discovery round-trips.

Exposing every possible action as a separate MCP tool overwhelms agent context and degrades performance.
Open source video
Airbyte consolidated connector interactions into two core tools: describe_connector and execute.
Open source video
Improves agent reliability by letting agents dynamically query schemas only when needed.
Open source video
Source video

Elicitation portability and capability negotiation across heterogeneous MCP clients

Research question

How should MCP servers degrade gracefully when a target client does not support elicitation or OAuth flows, and what capability-negotiation or out-of-band handoff patterns preserve portability?

Why

Designing bidirectional interactions that depend on optional client features creates silent portability failures. A fallback strategy is needed before building on elicitation.

Elicitation (URL-mode or form-mode) is problematic due to inconsistent support across MCP clients.
Open source video
OAuth is the required authentication standard because users expect long-lived headless sessions similar to mobile apps.
Open source video
Source video

Bundled skill files (SKILL.md) as lazy documentation for agent tool use

Research question

Do bundled markdown skill files reliably teach agents CLI usage and reduce context load compared to pre-loading documentation, and how does this interact with context pressure?

Why

The claim that skills must ship with the tool is asserted without evaluation. If true, it changes how documentation is packaged and loaded for all agent-facing tools.

Skills must ship with the tool via markdown files to enable agent discovery and effective usage without bloating context.
Open source video
Using a `SKILL.md` reference file to teach Claude how to use the CLI.
Open source video
Source video

JSON-in/JSON-out CLI design versus human-oriented CLI affordances for agents

Research question

Do JSON-I/O CLIs improve agent task reliability and composability versus human-oriented flag CLIs, and what are the failure modes when agents encounter interactive prompts?

Why

This is a strong practice claim with clear engineering consequences. If confirmed, human ergonomics must be a secondary layer, and CLI design standards should diverge for machine consumers.

Design CLIs with JSON in and JSON out as the primary interface to allow programmatic construction and leverage Unix piping/jq for large responses.
Open source video
Human-friendly flags and interactive prompts fail when agents invoke commands programmatically.
Open source video
Source video

Thin interfaces over OpenAPI single source of truth under high deployment frequency

Research question

How much does generating agent-facing MCP/CLI layers from an OpenAPI contract reduce interface drift and maintenance effort versus hand-written implementations when the platform deploys 10+ times per day?

Why

The architectural claim is central to long-term maintainability but lacks measured drift or maintenance data. The benefit may depend on the contract mechanism, not just the layering.

MCP and CLI are presented as thin presentation layers sitting on top of shared platform APIs rather than re-implementations of business logic.
Open source video
Platform changes frequently (over 10 times a day), so interfaces rely on OpenAPI specs as a single source of truth.
Open source video
Source video

Article ideas

4

Small Tool Surfaces Win: Why Progressive Discovery Should Be the Default for Agent-Facing APIs

Enumerating every action as a separate agent tool is an architectural anti-pattern; stable meta-tools plus runtime schema discovery should be the default for any growing agent integration, and the cost is bounded discovery latency rather than context collapse.

Angle

Architectural pattern argument backed by the two-tool describe/execute example and the failure mode of oversized tool surfaces.

Source video

The Elicitation Trap: Why MCP Servers Shouldn't Depend on Interactive Round-Trips

Designing MCP servers around client-side elicitation creates portability failures across heterogeneous hosts; robust agent protocols must push required interactions out-of-band rather than into the protocol hop.

Angle

Failure-mode analysis and architectural recommendation for cross-client compatibility.

Source video

JSON-in/JSON-out: Redesigning CLIs for Machine Consumers, Not Humans

Human-oriented CLI affordances such as interactive prompts and ergonomic flags are liabilities when the primary caller is an agent; agent-facing CLIs should adopt structured JSON I/O and a strict naming grammar, treating human ergonomics as a secondary layer.

Angle

Design standard argument with concrete engineering consequences for parsing, piping, and command selection.

Source video

Skills Ship with the Tool: Decoupling Agent Teachability from Context Budget

Bundling markdown skill files with tools allows agents to learn usage lazily and on demand, replacing the need to pre-load documentation into context; this should become a packaging standard for agent-facing tools.

Angle

Mechanism argument for lazy documentation loading and its interaction with context pressure.

Source video

Project ideas

4

Tool Surface Tuner

beyond-evals

Reducing tool count via a two-tool discovery pattern (describe/execute) improves agent task success and reduces context tokens compared to explicit per-entity tools, but beyond a certain integration breadth, extra discovery round-trips begin to offset the gains.

Proof of concept

Build a mock MCP server for a synthetic API with N entities. Generate two variants: one exposing every entity as a separate tool, one exposing describe_entity and execute_entity. Run identical agent tasks across both variants.

Measurement

Task success rate, tool-selection error rate, context tokens consumed, number of discovery round-trips, and end-to-end latency.

Source video

Elicitation Capability Matrix & Fallback Harness

gatehouse

MCP servers that avoid elicitation and use out-of-band auth have higher cross-client task completion than servers that rely on elicitation-dependent flows.

Proof of concept

Implement a server with two variants: one using elicitation for auth or input collection, one using headless out-of-band auth and passive error messages. Test both across multiple mock MCP clients with different capability sets.

Measurement

Task completion rate, failure modes, and portability across simulated client capability profiles.

Source video

SKILL.md Context Budget Evaluator

beyond-evals

Bundling a SKILL.md file with a CLI reduces context tokens and improves agent command accuracy compared to embedding documentation in the system prompt, with the effect size growing as context size increases.

Proof of concept

Build a sample CLI with a SKILL.md reference. Run agent tasks in two modes: docs pre-loaded in system prompt versus docs discoverable via SKILL.md. Vary context sizes to test interaction.

Measurement

Command accuracy, context token usage, and agent satisfaction or error recovery rate under context pressure.

Source video

Spec-Driven Agent Interface Generator

new

Generating MCP and CLI thin layers from an OpenAPI spec reduces interface drift and maintenance effort compared to hand-written interfaces when the underlying API changes frequently (10+ times per day).

Proof of concept

Simulate a platform API with frequent changes. Maintain two agent interfaces: one hand-written, one generated from an OpenAPI spec. Apply the same set of API changes over time.

Measurement

Number of drift incidents (behavior mismatches), maintenance time per change, and time to expose new API capabilities to agents.

Source video

Architectural implications

3

MCP and CLI are layered as thin presentation interfaces over shared platform APIs rather than duplicating business logic.

Before

Each agent-facing interface (MCP, CLI) re-implements platform logic and drifts from the source of truth.

After

Interfaces derive from OpenAPI specs and only present/translate, leaving logic in the platform core.

Consequence

Maintenance cost stays flat even as the platform deploys 10+ times per day.

Source video

Tool surface size is treated as a first-class design constraint rather than a natural consequence of the API's breadth.

Before

Expose one tool per entity/action; the agent sees the full API surface.

After

Expose a fixed small set of meta-tools plus runtime schema discovery.

Consequence

Agent context stays bounded and tool selection becomes more reliable as the integration grows.

Source video

Human-oriented CLI affordances (interactive prompts, human-readable flags) are treated as liabilities for agent consumers.

Before

Design CLIs for human ergonomics and reuse them for agents.

After

Design a separate JSON-in/JSON-out, headless, grammar-consistent surface for machine invocation.

Consequence

Agent-facing tooling diverges from human CLIs, requiring separate design standards and skills documentation.

Source video

Tradeoffs and failure modes

4

Elicitation in MCP

Benefit

Bidirectional/interactive flows (URL-mode, form-mode) can gather input mid-session.

Cost or risk

Inconsistent client support breaks portability across MCP hosts; behavior is unreliable.

Elicitation (URL-mode or form-mode) is problematic due to inconsistent support across MCP clients.
Open source video
Source video

Progressive discovery vs. explicit tools

Benefit

Small tool count keeps context manageable and improves reliability.

Cost or risk

Agents must issue extra discovery round-trips and depend on describe_connector correctness before acting.

Improves agent reliability by letting agents dynamically query schemas only when needed.
Open source video
Source video

Human vs. agent CLI design

Benefit

JSON I/O and strict naming enable reliable programmatic parsing and piping.

Cost or risk

Human ergonomics are sacrificed; interactive prompts and human-readable flags no longer work.

Human-friendly flags and interactive prompts fail when agents invoke commands programmatically.
Open source video
Source video

Headless auth

Benefit

Agents can authenticate without stalling on interactive prompts.

Cost or risk

Requires managing API keys in env vars/config files, shifting secret-management burden and shaping OAuth session expectations.

Auth must be headless (environment variables or config files with API keys) because CLI agents cannot wait for interactive human prompts.
Open source video
Source video

Open questions

4

What is the practically optimal number and shape of meta-tools for a given integration breadth, and how does this trade against discovery latency?

Why unresolved

The summary asserts tool count should be small and cites a two-tool example but gives no measured threshold or benchmark.

Research direction

Run controlled evaluations varying tool counts and discovery-tool vs explicit-tool designs, measuring selection accuracy and task success.

Source video

How should servers degrade gracefully when a target MCP client does not support elicitation or OAuth flows?

Why unresolved

Elicitation support is described as inconsistent, but no fallback strategy or capability-negotiation mechanism is given.

Research direction

Design and test capability-negotiation protocols and out-of-band auth handoff patterns across heterogeneous MCP clients.

Source video

Does bundling skills as markdown files (SKILL.md) reliably teach agents CLI usage, and how does it interact with context pressure?

Why unresolved

The claim is asserted but no evaluation of agent accuracy or context savings is provided.

Research direction

Benchmark agent command correctness with and without bundled skill files across varying context sizes.

Source video

How much of the maintenance benefit of a thin interface layer depends on OpenAPI being the single source of truth versus other contract mechanisms?

Why unresolved

The mechanism is described conceptually but the summary gives no data on drift or maintenance cost under frequent deploys.

Research direction

Measure interface drift and maintenance effort across generated-from-spec vs hand-written agent interfaces.

Source video

Key claims

8
causalVerification needed

Exposing every possible action as a separate MCP tool overwhelms agent context and degrades performance.

Evidence

Exposing every possible action as a separate MCP tool overwhelms agent context and degrades performance.

Question

Does tool-count reduction measurably improve agent task success or latency in controlled tests?

Source video
factualVerification needed

Elicitation (URL-mode or form-mode) is problematic because MCP clients support it inconsistently.

Evidence

Elicitation (URL-mode or form-mode) is problematic due to inconsistent support across MCP clients.

Question

Which MCP clients currently support elicitation, and how do failures surface?

Source video
causalVerification needed

Designing CLIs with JSON in and JSON out enables programmatic construction and Unix piping/jq for large responses.

Evidence

Design CLIs with JSON in and JSON out as the primary interface to allow programmatic construction and leverage Unix piping/jq for large responses.

Question

Do JSON-I/O CLIs improve agent task reliability versus human-oriented flag CLIs in practice?

Source video
causalVerification needed

Strict noun-verb naming consistency prevents agent errors.

Evidence

Consistency is key: follow predictable naming patterns (noun-verb order like connectors list, connectors create) to prevent agent errors.

Question

Does naming consistency measurably reduce agent command-selection errors?

Source video
causalVerification needed

Skills must ship with the tool via markdown files to enable agent discovery without bloating context.

Evidence

Skills must ship with the tool via markdown files to enable agent discovery and effective usage without bloating context.

Question

Does bundling SKILL.md reduce context load and improve CLI usage accuracy?

Source video
causalVerification needed

Auth must be headless because CLI agents cannot wait for interactive human prompts.

Evidence

Auth must be headless (environment variables or config files with API keys) because CLI agents cannot wait for interactive human prompts.

Question

Which headless auth patterns (env vars vs config files) are required for reliable unattended agent runs?

Source video
factualVerification needed

Platform changes frequently (over 10 times a day), so interfaces rely on OpenAPI specs as a single source of truth.

Evidence

Platform changes frequently (over 10 times a day), so interfaces rely on OpenAPI specs as a single source of truth.

Question

How does deployment frequency map to interface drift if interfaces are not generated from the spec?

Source video
opinionVerification not requested

OAuth is the required authentication standard because users expect long-lived headless sessions similar to mobile apps.

Evidence

OAuth is the required authentication standard because users expect long-lived headless sessions similar to mobile apps.

Source video

Connections

4