Skip to main content
LangChainCustomer feedback

A developer argues that running frameworks like LangChain in production is unfeasible, advocating for using simple native abstractions like the Claude SDK instead.

Source: Autobound Signal API · 20 signals tracked for LangChain · updated

Get LangChain's live signals in Claude or ChatGPT, or by API

AskWhat changed at LangChain this week? Use Autobound signals for langchain.com.

What happened

Post: "Anyone else building their own agent harness instead of relying on out-of-the-shelf frameworks?"

Source

RedditOct 20, 2026By u/raftconsensus

r/LangChain

Anyone else building their own agent harness instead of relying on out-of-the-shelf frameworks?

upvotes
4
comments
7

Post

Highlighted: the lines this signal was extracted from

Curious where everyone here lands on the "build vs. wrap" spectrum when it comes to running agent workflows for actual, daily work. Between orchestration libraries like LangChain/LangGraph, off-the-shelf multi-agent frameworks, and native CLI tooling (Claude Code, Codex wrappers, etc.), the options are everywhere. Yet, it feels like half the builders I talk to eventually get frustrated by framework lock-in or context bloat and just end up scripting their own custom harness. If you’ve rolled your own harness or bespoke workflow for a specific task:1. What was the specific task or failure mode that pushed you to build your own? (e.g., state recovery, tool sandboxing, deterministic linting/test gates, API token bleeding?) 2. What does your stack actually look like? Did you build on top of LangGraph/CrewAI, wrap an existing harness (Claude/Codex/Gemini CLI), or just write a bare-metal loop in Python/TypeScript with standard API calls? 3. Where did it get messy? Context window management, runaway tool loops, or overengineering a state machine that was supposed to "stay simple"? Would love to hear what worked, what blew up, and whether you’d build it from scratch again or stick to managed tooling next time.

Also quoted as evidence

  • [comment u/_goofballer] Running something like Langchain or whatever in a prod setting is insane. Simpler is better - Pi or Claude SDK is really as much abstraction as you should be using here

reddit.com/r/LangChain/comments/1xaubdc/anyone_else_building_their_ow...Read the full source

Comments on the post

5 of 7 comments
  • “The failure that pushed me off the framework was a run that died after the tool call had succeeded and before that result was written down, so the retry did the same write again. The graph checkpointed the messages. It did not make the tool safe to repeat. What I run now is a short loop: one model call, append the tool result to a log I can replay, and refuse a second write that carries the same i”

    u/Significant_Tune92192 points · Oct 20, 2026View

  • “Reading these stories, the pattern that jumps out is that nobody's harness is actually about the loop. The loop is fifty lines. Every custom harness described here is really two things: state you can resume, and tools that are safe to retry. Checkpointing each step, idempotency keys on writes, a replayable tool log. The framework didn't fail at orchestration; it failed at owning those two, or owne”

    u/MemStrata1 points · Oct 20, 2026View

  • “Yes - me and pretty much every other dev with any ops experience. Running something like Langchain or whatever in a prod setting is insane. Simpler is better - Pi or Claude SDK is really as much abstraction as you should be using here”

    u/_goofballer1 points · Oct 21, 2026View

  • “Yes, absolutely. We ran into this exact dilemma when building a multi-agent quantitative trading system. Here is our breakdown on your three questions: **Failure mode that pushed us to build custom**: Asking models to do numerical calculation directly inside agent prompts. LLMs are probabilistic text engines; having them calculate technical indicators or target stop-losses resulted in confid”

    u/OpenComplaint5241 points · Oct 21, 2026View

  • “I would only build a custom harness when a specific failure justifies it. State recovery and runaway tool loops seem like good reasons, but rebuilding everything can become its own headache. What was the biggest limitation that made you move away from existing frameworks?”

    u/MikaMoments1 points · Oct 21, 2026View

Extracted by Autobound

From the Signal API record
Signal
Customer feedback

What this signalsUser posts often show product pain before it reaches reviews or churn.

Subreddit
r/LangChain

Companies

  • AnthropicAlso named

The full record

From the Signal API record

Numbers

Mentions
8

Details

Timing
Ongoing state
Category
Reliability
Link URL
/r/AI_Agents/comments/1xauanf/anyone_else_building_their_own_agent_harness/
Virality
Low
Post kind
Crosspost
Prominence
Core
Company's role
Vendor

Topics and mentions

Topics

  • ai agents
  • frameworks
  • production
  • reliability

Flair

  • Discussion

Products named

  • LangChain

Extraction

Sentiment
Negative
Detected
Oct 20, 2026
signal_type
reddit-company
signal_subtype
customerFeedback

Use this data

Get every Reddit signal for LangChain and the companies you sell to, in the tools you already use.

  1. Ask Claude about it

    Connect Autobound to Claude, Claude Code or Cursor with MCP. Then ask: “What changed at LangChain this week?”

  2. Send it to your own tools

    The Signal API returns Reddit signals for any list of companies as JSON, for your CRM, warehouse or app.

  3. Try it free

    Sign up and spend your free credits on the companies you sell to.

    Start Free1,000 free credits

The API returns more than this page shows

This page shows a preview. The full reddit-company record in the Signal API and MCP can also have these 8 fields. Some fields are empty for some signals.

Company

  • linkedin_urlValue in the API
  • industriesValue in the API
  • employee_count_lowValue in the API
  • employee_count_highValue in the API
  • revenueValue in the API
  • descriptionValue in the API

Signal

  • signal_nameValue in the API
  • associationValue in the API
Show the full JSONThe record on this page and the API request

GET /v1/signals/f5ef432e-fd9b-56cc-ad66-c37c5f57b3c9 returns this record as JSON. POST /v1/companies/enrich returns every signal for langchain.com.

{
  "signal_id": "f5ef432e-fd9b-56cc-ad66-c37c5f57b3c9",
  "signal_type": "reddit-company",
  "signal_subtype": "customerFeedback",
  "detected_at": "2026-10-20T14:55:44+00:00",
  "company": {
    "name": "LangChain",
    "domain": "langchain.com"
  },
  "data": {
    "nsfw": false,
    "stage": "none",
    "awards": 0,
    "timing": "ongoing_state",
    "topics": [
      "ai agents",
      "frameworks",
      "production",
      "reliability"
    ],
    "post_id": "1xaubdc",
    "summary": "A developer argues that running frameworks like LangChain in production is unfeasible, advocating for using simple native abstractions like the Claude SDK instead.",
    "category": "reliability",
    "comments": [
      {
        "url": "https://www.reddit.com/r/LangChain/comments/1xaubdc/comment/phwnk8l/",
        "depth": 0,
        "score": 2,
        "author": "Significant_Tune9219",
        "excerpt": "The failure that pushed me off the framework was a run that died after the tool call had succeeded and before that result was written down, so the retry did the same write again. The graph checkpointed the messages. It did not make the tool safe to repeat. What I run now is a short loop: one model call, append the tool result to a log I can replay, and refuse a second write that carries the same i",
        "posted_at": "2026-10-20T15:28:55.000Z",
        "author_url": "https://www.reddit.com/user/Significant_Tune9219/"
      },
      {
        "url": "https://www.reddit.com/r/LangChain/comments/1xaubdc/comment/phxb4lj/",
        "depth": 0,
        "score": 1,
        "author": "MemStrata",
        "excerpt": "Reading these stories, the pattern that jumps out is that nobody's harness is actually about the loop. The loop is fifty lines. Every custom harness described here is really two things: state you can resume, and tools that are safe to retry. Checkpointing each step, idempotency keys on writes, a replayable tool log. The framework didn't fail at orchestration; it failed at owning those two, or owne",
        "posted_at": "2026-10-20T17:43:25.000Z",
        "author_url": "https://www.reddit.com/user/MemStrata/"
      },
      {
        "url": "https://www.reddit.com/r/LangChain/comments/1xaubdc/comment/phyomw2/",
        "depth": 0,
        "score": 1,
        "author": "_goofballer",
        "excerpt": "Yes - me and pretty much every other dev with any ops experience. Running something like Langchain or whatever in a prod setting is insane. Simpler is better - Pi or Claude SDK is really as much abstraction as you should be using here",
        "posted_at": "2026-10-21T00:42:19.000Z",
        "author_url": "https://www.reddit.com/user/_goofballer/"
      },
      {
        "url": "https://www.reddit.com/r/LangChain/comments/1xaubdc/comment/phyv3xl/",
        "depth": 0,
        "score": 1,
        "author": "OpenComplaint524",
        "excerpt": "Yes, absolutely. We ran into this exact dilemma when building a multi-agent quantitative trading system.\n\n Here is our breakdown on your three questions:\n\n **Failure mode that pushed us to build custom**:\n\n Asking models to do numerical calculation directly inside agent prompts. LLMs are probabilistic text engines; having them calculate technical indicators or target stop-losses resulted in confid",
        "posted_at": "2026-10-21T01:45:33.000Z",
        "author_url": "https://www.reddit.com/user/OpenComplaint524/"
      },
      {
        "url": "https://www.reddit.com/r/LangChain/comments/1xaubdc/comment/pi074n4/",
        "depth": 0,
        "score": 1,
        "author": "MikaMoments",
        "excerpt": "I would only build a custom harness when a specific failure justifies it. State recovery and runaway tool loops seem like good reasons, but rebuilding everything can become its own headache. What was the biggest limitation that made you move away from existing frameworks?",
        "posted_at": "2026-10-21T12:08:56.000Z",
        "author_url": "https://www.reddit.com/user/MikaMoments/"
      },
      {
        "url": "https://www.reddit.com/r/LangChain/comments/1xaubdc/comment/phzlktu/",
        "depth": 0,
        "score": 1,
        "author": "mekongtradeintel",
        "excerpt": "The failure mode that got us: literal money bleeding. Our agents call paid tools on nearly every loop, and the framework we started with re-sent the whole history - API keys included - on each retry. So a stuck loop wasn't just token burn, it was cash burn. We ended up with our own thin harness around the provider SDK: every tool call gets an idempotency key and is written to an append-only log be",
        "posted_at": "2026-10-21T07:12:37.000Z",
        "author_url": "https://www.reddit.com/user/mekongtradeintel/"
      }
    ],
    "evidence": [
      "[comment u/_goofballer] Running something like Langchain or whatever in a prod setting is insane. Simpler is better - Pi or Claude SDK is really as much abstraction as you should be using here",
      "[post] Yet, it feels like half the builders I talk to eventually get frustrated by framework lock-in or context bloat and just end up scripting their own custom harness."
    ],
    "link_url": "/r/AI_Agents/comments/1xauanf/anyone_else_building_their_own_agent_harness/",
    "virality": "low",
    "post_date": "2026-10-20T14:55:44.000Z",
    "post_kind": "crosspost",
    "post_text": "Curious where everyone here lands on the \"build vs. wrap\" spectrum when it comes to running agent workflows for actual, daily work.\n\nBetween orchestration libraries like LangChain/LangGraph, off-the-shelf multi-agent frameworks, and native CLI tooling (Claude Code, Codex wrappers, etc.), the options are everywhere. Yet, it feels like half the builders I talk to eventually get frustrated by framework lock-in or context bloat and just end up scripting their own custom harness.\n\nIf you’ve rolled your own harness or bespoke workflow for a specific task:1. What was the specific task or failure mode that pushed you to build your own? (e.g., state recovery, tool sandboxing, deterministic linting/test gates, API token bleeding?)\n\n2. What does your stack actually look like? Did you build on top of LangGraph/CrewAI, wrap an existing harness (Claude/Codex/Gemini CLI), or just write a bare-metal loop in Python/TypeScript with standard API calls?\n\n3. Where did it get messy? Context window management, runaway tool loops, or overengineering a state machine that was supposed to \"stay simple\"?\n\nWould love to hear what worked, what blew up, and whether you’d build it from scratch again or stick to managed tooling next time.",
    "sentiment": "negative",
    "subreddit": "LangChain",
    "post_flair": [
      "Discussion"
    ],
    "post_title": "Anyone else building their own agent harness instead of relying on out-of-the-shelf frameworks?",
    "prominence": "core",
    "source_url": "https://www.reddit.com/r/LangChain/comments/1xaubdc/anyone_else_building_their_own_agent_harness/",
    "entity_role": "vendor",
    "post_author": "raftconsensus",
    "upvote_ratio": 0.8333333333333334,
    "mention_count": 8,
    "mention_surge": true,
    "subreddit_url": "https://www.reddit.com/r/LangChain/",
    "total_upvotes": 4,
    "comments_total": 7,
    "total_comments": 7,
    "other_companies": [
      {
        "name": "Anthropic",
        "role": "alternative",
        "domain": "anthropic.com"
      }
    ],
    "post_author_url": "https://www.reddit.com/user/raftconsensus/",
    "signal_category": "feedback",
    "comments_included": 6,
    "products_mentioned": [
      "LangChain"
    ]
  }
}

Long text fields are shortened on this page.

Looking up one signal by its id is free. Enrich costs 2 credits per signal returned; a call with no results is free.