AI's

Why "AI agent developer" isn't a real job title (yet)

AI agents are everywhere. The job title isn't. A recent r/aiagents thread put a number on it: 70-80% of "agent work" is integration and infrastructure, not agent logic. That reality keeps the work spread across ML, data, platform, DevOps, and solutions roles instead of forming a new specialty.

At the same time, platforms are getting so good that they erase the need for a niche "agent developer." Google's Agent Development Kit (ADK) and AWS Bedrock AgentCore both aim to abstract away the hard parts of programming. Useful for shipping. Bad for job-title clarity.

Cloud platforms are erasing layers of code

Engineers in the thread highlighted how cloud vendors are flattening agent development into configuration and integration. As one ML engineer noted, Google ADK and AWS AgentCore remove entire programming layers and push work into orchestration and systems design.

• Google ADK: 100+ enterprise connectors, sequential/parallel/loop orchestration, LLM-driven routing, native Vertex AI deployment.
• AWS AgentCore: Framework-agnostic (CrewAI, LangGraph, LlamaIndex, Google ADK, OpenAI SDK). Core services: Runtime with 8-hour async, Memory, Identity, Gateway, Browser, Code Interpreter, Observability. Early adopters include Sony, Box, Cox Automotive, Experian.

The paradox: the better the platform, the less you need a bespoke "agent developer." Enterprises hand this work to platform engineers and solutions architects they already trust.

No-code vs. code: where engineers still matter

Tools like Lindy (2,000+ integrations), n8n, Zapier (6,000+ integrations), Copilot Studio, Glean Agent Builder, and Relevance AI let non-technical teams ship workable agents. That's great for simple workflows. It also makes a dedicated "agent dev" role feel unnecessary.

But complexity draws a line. Custom RAG, multi-agent orchestration, security compliance, and enterprise-grade reliability demand real engineering. And that work maps to existing roles.

• Data engineers: Build the RAG data pipelines.
• ML engineers: Select/evaluate embedding and generation models.
• Platform/SRE: Vector DB scaling, queues, autoscaling, observability.
• DevOps: CI/CD, secrets, cost and performance monitoring.
• Security/IT: AuthN/Z, data governance, vendor review.

Agents behave like Ops-heavy systems

Most participants framed agents as DevOps projects in disguise. You're shipping distributed systems with data contracts, policies, and feedback loops-not just prompts. Microsoft's new Agent Framework and "Agentic DevOps" messaging underlined that shift.

Industry coverage also points to early-but real-ops features: self-healing, automated CI/CD, IaC generation, security scanning, and incident automation. Useful, but not fully autonomous yet.

• System design first: auth flows, rate limits, retries, dead-letter queues.
• Data quality: inconsistent schemas, stale sources, permission scopes.
• Scale: autoscaling, queuing, backpressure, cost controls.
• Governance: policy, audit, approval ladders, vendor neutral protocols.
• Observability: distributed tracing, evals, behavior snapshots.

One stat sums up the friction: 78% of companies say they use genAI, yet 80% report no material bottom-line impact-largely due to integration hurdles, not capability gaps.

RAG and vector databases are the real work

Technical voices in the thread treated RAG as the backbone. The flow is familiar: embed → store → retrieve → inject → generate. Getting that right is where most of the effort lives.

• Pinecone: Managed service; quick to production.
• Weaviate: Open-source + cloud; strong hybrid search and filters.
• Qdrant: Performance-focused; solid scaling story.
• Chroma: Lightweight/embedded use cases.
• FAISS: Local search for edge or small-footprint apps.
• PGVector: Postgres extension; keeps ops stack simple.

"Agentic RAG" adds multiple retrieval tools and strategies instead of a single index. According to Weaviate docs, teams report large drops in hallucinations and better source attribution with this approach. That said, data access patterns are harder than model choice-and sit squarely in data and platform engineering.

Weaviate documentation

Integration beats "agent logic" for business value

Engineers estimated 70-80% of the workload is integration, deployment, security, monitoring, and cost control. Only 20-30% is agent behavior, prompts, and orchestration. That split makes a single "agent developer" role impractical.

Logic is getting commoditized. LLMs reason well out of the box, frameworks like LangGraph abstract loops and state, and marketplaces offer off-the-shelf agents. The leverage is in integrations done right-and that demands deep knowledge of the systems you're plugging into. Cost, speed, and determinism tradeoffs still push many teams to traditional code for routine tasks.

Framework churn rewards fundamentals

LangChain and LangGraph dominate discussions for good reason. Most software assumes DAGs. Agents don't-they loop. The ReAct pattern (Reason → Act → Observe) requires cycles, retries, and guardrails.

LangGraph addresses this with a StateGraph, built-in memory (short and long term), time-travel debugging, multi-agent orchestration, token streaming, and a production platform. Teams like Klarna, Replit, and Elastic use it today.

The tradeoff: less boilerplate, more ops overhead. You'll juggle framework debugging, version drift, abstraction gaps, and performance overhead. And because frameworks change every 3-6 months, specialization is risky. Durable skills win.

• Distributed systems, queues, idempotency, retries.
• API design, schema management, contracts, backfills.
• Observability: traces, metrics, structured logs, eval harnesses.
• Security engineering: scopes, secrets, signing, approvals.
• Cost engineering: token budgets, cache hit rates, vector ops.

Freelance reality: SMEs want implementers

SMEs are buying outcomes, not research. Common tickets: workflow automation (n8n/Zapier/Make), voice agents (Twilio/Vapi), support bots, RAG deployments, multi-agent setups. Rates range from ~$60 to $200+ per hour depending on depth.

• Start with process mapping before you write prompts.
• Pick a proven pattern; adapt it to the client's stack.
• Prioritize integrations, data quality, and handoff training.
• Offer maintenance packages; agents drift without upkeep.

Forward Deployed Engineer is the title you're looking for

The thread rallied around Forward Deployed Engineer (FDE) as the real pattern. FDEs sit between customers and core product, shipping integrations in the field and feeding learnings back. Companies like OpenAI, Ramp, Palantir, Databricks, Salesforce, Scale AI, Anthropic, and LangChain are hiring. Compensation: roughly $150k-$350k base plus equity.

• Embed with customers; understand the workflow and constraints.
• Customize agents to data systems; debug in production.
• Close the loop with product teams; shape roadmaps with real usage.
• High-context switching, travel, and strong communication required.

Marketing tech mirrors the same pattern

Prebuilt agents are landing inside platforms. Adobe rolled out agents across Experience Platform (Audience, Journey, Experimentation, Data Insights, Site Optimization, Product Support). Agencies report big gains: budget pacing time down ~90% and campaign setup down ~80%. The team doing the work? Existing marketing technologists and data analysts with platform access.

A useful blueprint comes from an "Agentic AI Mesh" approach: composable components, distributed intelligence, decoupled layers, vendor-neutral protocols (MCP, A2A), and governed autonomy with approvals and limits.

Timeline

• Oct 15, 2025: Google ADK launches (100+ connectors, Vertex AI deployment).
• Oct 2025: AWS Bedrock AgentCore GA; works with LangGraph, CrewAI, LlamaIndex, Google ADK, OpenAI SDK.
• Oct 9, 2025: Adobe ships B2B-focused agents (Audience, Journey, Data Insights), tested by Cisco.
• Oct 23, 2025: r/aiagents thread questions the absence of an "AI agent developer" job title.
• Oct 24, 2025: Cloudflare partners with Visa/Mastercard for Trusted Agent Protocol and Agent Pay.
• Oct 26, 2025: X/Twitter thread debates when to use agents vs. traditional code (cost, speed, determinism).
• Oct 2025: Microsoft launches Agent Framework as part of Agentic DevOps.
• Sep 2025: r/AgentsOfAI post shares an 8-step agent build framework adopted by practitioners.
• Sep 2025: Agencies target 83% higher client capacity as automation reshapes AdOps.
• 2024: Investment in agents hits $1.1B; job postings up 9.85x from 2023, but titles stay fragmented.

What to do next (product and engineering leaders)

• Organize by outcomes, not titles: Assign clear owners for data pipelines, RAG indexing, orchestration, deployment, security, and evals.
• Hire for FDE-like skills: Customer-facing engineers who can integrate, debug, and influence product.
• Standardize your agent backbone: Pick one orchestration framework (e.g., LangGraph) and one vector stack; document patterns and pitfalls.
• Adopt vendor-neutral protocols early: Plan for MCP/A2A-style interfaces to avoid lock-in.
• Build an evaluation and observability layer: Traces, prompts, tool calls, costs, and outcomes in one place. Treat it like test coverage.
• Governance from day one: Scopes, approvals, and audit trails. Agents should be powerful and controllable.

Skills and stack checklist (keep it on your desk)

• Core skills: System design, API integration, event-driven design, retries/idempotency, security, cost modeling.
• Data/RAG: Embeddings, chunking, hybrid search, re-ranking, freshness pipelines, access control.
• Frameworks: LangGraph/LangChain, CrewAI, LlamaIndex; know their debugging story and failure modes.
• Ops: Kubernetes/queues, CI/CD, secrets, distributed tracing, eval harnesses.
• Tooling: Python/JS, FastAPI, Docker, vector DB of choice (Pinecone/Weaviate/Qdrant/PGVector).
• Artifacts: Pattern libraries, guardrail templates, prompt registries, cost dashboards, runbooks.

Curated AI courses by job role and AI certification for coding can help teams upskill without pausing delivery.

Bottom line

The "AI agent developer" title is missing for five structural reasons: most of the work is integration/infrastructure; platforms keep abstracting code; roles are fragmented across existing specialties; no-code makes simple use cases easy; and each company defines "agent" differently. Treat agents as systems, not features. Build the architecture, hire FDE-style talent, and double down on fundamentals that won't change when the next framework drops.

InfoQ's DevOps trends