AgentKit vs LLMFeed: Complementary Layers for the Agentic Web

When OpenAI announced AgentKit at DevDay 2025, the immediate reaction was: "How does this relate to LLMFeed?"

The answer isn't "versus"—it's "with".

AgentKit and LLMFeed are complementary infrastructure layers solving different problems in the agent stack. Understanding their relationship is key to building production-ready autonomous systems.

The Agent Infrastructure Stack

Let's start with the complete picture of what autonomous agents need:

┌─────────────────────────────────────┐
│  USER INTERACTION LAYER             │  (ChatGPT, Claude, interfaces)
├─────────────────────────────────────┤
│  AGENT ORCHESTRATION                │  ← AgentKit (OpenAI)
│  • Workflow builder                 │
│  • Logic flows & branching          │
│  • Tool call orchestration          │
├─────────────────────────────────────┤
│  CONNECTOR LAYER                    │  ← AgentKit Registry
│  • Data source connections          │
│  • Third-party APIs                 │
│  • Internal systems                 │
├─────────────────────────────────────┤
│  SAFETY & GUARDRAILS                │  ← AgentKit Guardrails
│  • Jailbreak detection              │
│  • PII masking                      │
│  • Runtime safety policies          │
├─────────────────────────────────────┤
│  PROTOCOL LAYER                     │  ← MCP (Anthropic)
│  • Tool calling protocol            │
│  • JSON-RPC communication           │
├─────────────────────────────────────┤
│  TRUST & DISCOVERY                  │  ← LLMFeed
│  • Cryptographic verification       │
│  • Web-scale discovery              │
│  • Provenance tracking              │
├─────────────────────────────────────┤
│  INFRASTRUCTURE                     │  (Servers, APIs, data)
└─────────────────────────────────────┘

AgentKit lives in the orchestration layer. LLMFeed lives in the trust & discovery layer.

They don't compete—they enable each other.

What AgentKit Does Brilliantly

1. Agent Builder: No-Code Orchestration

AgentKit provides a visual canvas for building agent workflows:

User Intent → Parse → Branch Logic → Tool Calls → Response
              ↓                ↓
         Validation     Error Handling

What this solves:

• Developers don't need to code complex agent logic
• Visual debugging of agent decision paths
• Rapid prototyping of agentic workflows

What this doesn't solve:

• How do agents discover available tools?
• How do agents verify tool declarations are authentic?
• How do tools declare their trust level?

2. Connector Registry: Centralized Data Access

AgentKit's registry consolidates data sources:

Pre-built connectors:

• Dropbox
• Google Drive
• SharePoint
• Microsoft Teams

Third-party MCPs:

• Custom APIs
• Internal tools
• Proprietary systems

What this solves:

• Single admin panel for all data sources
• Enterprise security controls
• Consistent connector management

What this doesn't solve:

• Decentralized discovery (requires central registry)
• Cryptographic trust (relies on admin permissions)
• Web-scale distribution (enterprise-only beta)

3. Guardrails Layer: Runtime Safety

AgentKit includes open-source safety policies:

javascript
// Runtime guardrails example
{
  "jailbreak_detection": true,
  "pii_masking": {
    "emails": "redact",
    "phone_numbers": "redact",
    "ssn": "block"
  },
  "safety_policies": [
    "no_harmful_content",
    "no_unauthorized_actions"
  ]
}

What this solves:

• Real-time content filtering
• PII protection at runtime
• Policy enforcement during execution

What this doesn't solve:

• Pre-execution trust assessment (who created this tool?)
• Provenance tracking (where did this capability come from?)
• Long-term audit trails (cryptographic proof of decisions)

What LLMFeed Adds to the Stack

1. Web-Scale Discovery

AgentKit approach: Central registry submission LLMFeed approach: Decentralized

.well-known/

bash
# AgentKit: Register with OpenAI
→ Submit to OpenAI Connector Registry
→ Admin approves
→ Available to organization

# LLMFeed: Publish to web
→ Create /.well-known/mcp.llmfeed.json
→ Sign with your key
→ Available to all agents globally

Why this matters:

• No gatekeeper approval needed
• Works across all LLM platforms (not just OpenAI)
• Scales to millions of websites instantly

2. Cryptographic Trust Infrastructure

AgentKit approach: Admin permissions + runtime guardrails LLMFeed approach: Cryptographic signatures + certification

json
// LLMFeed trust declaration
{
  "feed_type": "capabilities",
  "capabilities": [
    {
      "name": "process_payment",
      "method": "POST",
      "path": "/api/pay"
    }
  ],
  "trust": {
    "signed_blocks": ["capabilities"],
    "certifier": "https://llmca.org",
    "algorithm": "ed25519"
  },
  "signature": {
    "value": "cryptographic_proof",
    "created_at": "2025-10-12T10:00:00Z"
  }
}

Why this matters:

• Pre-execution verification (before agent calls anything)
• Tamper-proof declarations (detect modified capabilities)
• Independent certification (third-party trust validation)

3. Agent Behavioral Guidance

AgentKit approach: Logic flows in builder LLMFeed approach: Declarative behavior hints

json
// LLMFeed agent guidance
{
  "agent_guidance": {
    "interaction_tone": "professional",
    "consent_hint": "Ask user before financial transactions",
    "risk_tolerance": "low",
    "fallback_behavior": "escalate_to_human"
  },
  "capabilities": [
    {
      "name": "transfer_funds",
      "requires_user_consent": true,
      "risk_level": "high"
    }
  ]
}

Why this matters:

• Guidance travels with the capability (not configured separately)
• Works across platforms (any agent reading the feed)
• Signed behavioral contracts (verifiable agent instructions)

The Complementary Architecture

Here's how AgentKit and LLMFeed work together:

Scenario: Enterprise Agent Building a Report

Step 1: Discovery (LLMFeed)

json
// Agent finds analytics.company.com/.well-known/mcp.llmfeed.json
{
  "feed_type": "mcp",
  "capabilities": [
    {
      "name": "generate_report",
      "path": "/api/reports"
    }
  ],
  "trust": {
    "signed_blocks": ["capabilities"],
    "certifier": "https://llmca.org"
  }
}

Step 2: Verification (LLMFeed)

javascript
// Agent verifies signature before proceeding
const isValid = await verifySignature(feed);
const trustLevel = await checkCertification(feed);

if (trustLevel === "certified") {
  // Proceed to orchestration
}

Step 3: Orchestration (AgentKit)

Agent Builder Flow:
1. Parse user request
2. Check available capabilities (from LLMFeed discovery)
3. Verify trust level
4. Execute via connector (AgentKit Registry)
5. Apply guardrails (AgentKit Safety)
6. Return response

Step 4: Audit Trail (LLMFeed)

json
// Session feed preserves provenance
{
  "feed_type": "session",
  "actions": [
    {
      "capability": "generate_report",
      "source": "analytics.company.com",
      "verified": true,
      "trust_level": "certified",
      "executed_at": "2025-10-12T15:30:00Z"
    }
  ]
}

The Division of Responsibilities

.well-known/

Real-World Integration Example

Building a Financial Agent

Using AgentKit Alone:

✅ Build workflow logic
✅ Connect to internal systems
✅ Apply PII masking
❌ How do external agents discover your APIs?
❌ How do you prove your capabilities are authentic?
❌ How do cross-platform agents trust your declarations?

Using LLMFeed + AgentKit:

✅ Publish /.well-known/mcp.llmfeed.json (LLMFeed)
✅ Sign with company key (LLMFeed)
✅ Get LLMCA certified (LLMFeed)
✅ Register in AgentKit Connector Registry (AgentKit)
✅ Build workflows in Agent Builder (AgentKit)
✅ Apply runtime guardrails (AgentKit)

Result:

• Internal agents use AgentKit orchestration
• External agents discover via LLMFeed
• All agents verify trust before execution
• Audit trail preserved cryptographically

The MCP Connection

Both AgentKit and LLMFeed build on Model Context Protocol (MCP):

MCP provides:

• Tool calling protocol (JSON-RPC)
• Resource management
• Server-model communication

AgentKit extends with:

• Visual orchestration layer
• Enterprise connector management
• Runtime safety enforcement

LLMFeed extends with:

• Web-native discovery (

  .well-known/

  )
• Cryptographic trust layer
• Multi-platform compatibility

Together they create:

MCP (protocol)
  + AgentKit (orchestration & safety)
  + LLMFeed (trust & discovery)
  = Complete agent infrastructure

Why "Versus" is the Wrong Question

The Browser Analogy

Think of web browsers:

• HTTP is the protocol (like MCP)
• Browser UI is the orchestration (like AgentKit)
• HTTPS/SSL is the trust layer (like LLMFeed)

You don't ask "Chrome vs SSL"—they solve different problems.

Same with AgentKit vs LLMFeed.

The Stack Reality

AgentKit without LLMFeed:

• Great for enterprise internal workflows
• Limited to registry-approved connectors
• Trust based on admin permissions
• No web-scale discovery

LLMFeed without AgentKit:

• Great for declaring capabilities
• Agents need to build their own orchestration
• No visual workflow builder
• No centralized admin panel

AgentKit + LLMFeed:

• Enterprise workflows and web discovery
• Registry connectors and

  .well-known/

  feeds
• Runtime guardrails and cryptographic trust
• Admin control and decentralized verification

Developer Decision Matrix

Use AgentKit When:

• ✅ Building enterprise internal agents
• ✅ Need visual workflow builder
• ✅ Want centralized connector management
• ✅ Require admin control over data sources

Use LLMFeed When:

• ✅ Publishing capabilities to the open web
• ✅ Need cryptographic verification
• ✅ Want multi-platform compatibility
• ✅ Building decentralized agent systems

Use Both When:

• ✅ Building production autonomous agents
• ✅ Need enterprise + web-scale deployment
• ✅ Require both internal orchestration and external trust
• ✅ Want complete infrastructure coverage

The Strategic Positioning

For OpenAI

AgentKit is brilliant for:

• Onboarding developers to agent building
• Enterprise deployment
• ChatGPT ecosystem integration

AgentKit benefits from LLMFeed:

• Web-scale connector discovery
• Cross-platform trust verification
• Decentralized capability distribution

For LLMFeed

LLMFeed is essential for:

• Web-native agent discovery
• Cryptographic trust infrastructure
• Multi-LLM compatibility

LLMFeed benefits from AgentKit:

• Proven orchestration patterns
• Enterprise adoption validation
• Visual tooling inspiration

The Future: Convergence

We predict these layers will increasingly integrate:

Q1 2026:

• AgentKit Connector Registry supports

  .well-known/

  discovery
• LLMFeed feeds appear in Agent Builder
• Signature verification integrated into AgentKit

Q2 2026:

• Visual builder generates signed LLMFeed declarations
• Cross-platform orchestration using both systems
• Universal agent infrastructure emerges

The endpoint:

Developer workflow:
1. Build in AgentKit Builder (orchestration)
2. Publish to /.well-known/ (LLMFeed discovery)
3. Sign with key (LLMFeed trust)
4. Register in AgentKit (enterprise deployment)
5. Deploy everywhere (universal compatibility)

Conclusion: Better Together

The question isn't "AgentKit vs LLMFeed."

The question is: "How do we build the complete agent infrastructure?"

Answer:

• MCP for protocol foundation (Anthropic)
• AgentKit for orchestration & safety (OpenAI)
• LLMFeed for trust & discovery (community-driven)

Each layer solves problems the others don't address.

Together, they create the complete stack for autonomous AI.

Getting Started

If You're Using AgentKit

Add LLMFeed trust layer:

1. Publish your capabilities:

json
// /.well-known/mcp.llmfeed.json
{
  "feed_type": "mcp",
  "capabilities": [ /* from AgentKit */ ],
  "trust": { /* add verification */ }
}

2. Sign your declarations
3. Enable web-scale discovery

If You're Using LLMFeed

Consider AgentKit for orchestration:

1. Build workflows visually
2. Add your

   .well-known/

   feeds to registry
3. Apply runtime guardrails
4. Manage connectors centrally

If You're Starting Fresh

Use both from day one:

1. Define capabilities (LLMFeed format)
2. Build orchestration (AgentKit Builder)
3. Sign declarations (LLMFeed trust)
4. Deploy everywhere (both systems)

Resources

• AgentKit: openai.com/agentkit
• LLMFeed Spec: wellknownmcp.org/spec
• MCP Protocol: modelcontextprotocol.io
• Integration Guide: wellknownmcp.org/tools

The agentic web needs both orchestration and trust.

AgentKit provides orchestration. LLMFeed provides trust.

Together, they enable autonomous AI.