How I Built an Agentic System That Runs My LinkedIn for Free

Stop burning out on content creation. Here is how I engineered a multi-agent AI workforce to research, write, and review my posts so I can get back to actually building.

Demo

If you work in AI, engineering, or tech, you probably know the routine all too well.

You spend your week deep in the trenches, debugging a complex model, designing a scalable microservice, or finally getting that stubborn framework to compile. You have a flash of insight and think, “This would make a great LinkedIn post. Others could learn from this.”

Then there’s the uncertainty and preparation, which is taking too long to execute our proposal.

You open a blank document. You start researching the context. You draft the post. You rewrite the opening hook because it sounds too robotic. You restructure paragraphs to balance technical depth with readability. By the time the post is ready to publish, you’ve spent 45 minutes on a task that feels creatively draining and repetitive.

As an AI Engineer, I realized something deeply ironic: I spend my days building systems to automate complex reasoning for users, yet I was manually grinding through the highly structured, predictable workflow of content creation.

We’ve all tried using tools like ChatGPT to speed this up. But treating AI as a sophisticated auto-complete tool — relying on a single massive prompt — often yields generic, hollow content. It lacks the iterative reasoning, self-evaluation, and contextual grounding that a human writer naturally applies.

I wanted my time back. But I didn’t want to compromise on quality.

So, I asked myself: What if the entire workflow could be automated? Not with a single prompt, but with a system of collaborating AI agents that collectively perform the exact same reasoning process a human writer would?

Let’s dive into the architecture, the LangGraph workflow, and the Python pipeline that powers a self-sufficient content engine.

GitHub - sarveshtalele/linkedin-autonomous-content-creation-agentic-system

The Shift: From Prompt Engineering to Agentic Systems

Most AI content generation fails when quality expectations increase because a single prompt does not allow for iteration. It produces an answer, but it never asks, “Is this actually good?”

Human writers naturally iterate. We draft, review, cringe at our own phrasing, and revise. Agentic architectures replicate this cognitive loop.

Instead of relying on a single model call, I structured this system as a collaborative pipeline of specialized agents. Each agent has a single responsibility — one cleans the input, another extracts concepts, another drafts the post, and a crucial one acts as the editor.

The 7-Layer System Architecture

To make this production-ready, we cannot have our AI drowning in too many tasks at once. The architecture is broken into five distinct, manageable layers:

1. User Interaction Layer: The entry point. You simply provide a topic, a rough thought, or upload raw files (like PDFs or research papers).
2. Client Application Layer: A lightweight Streamlit frontend (src/ui/app.py) that captures your input and triggers the backend without cluttering the UI.
3. Orchestration & Agent Layer: The brain of the operation. Here, a LangGraph state machine orchestrates our specialized “employees”: the Cleaning Agent, Keyword Agent, Writer Agent, Reviewer Agent, and Rewrite Agent.
4. Retrieval-Augmented Generation (RAG) Layer: Before the Writer Agent drafts a post, the system chunks and embeds external knowledge into a Vector Store. A Hybrid Retriever injects grounded, factual data into the prompt, eliminating hallucinations.
5. Ingestion & Storage Layer: Raw data is normalized, and final outputs are securely stored in JSON/YAML stores.

Why this matters to you: Modularity is everything. By isolating the ingestion layer from the generation layer, you can easily swap out data sources — like adding a web scraper tomorrow — without breaking the AI agents. It scales from processing a single thought to ingesting an entire company’s internal documentation.

The LangGraph Flow

Traditional LLM chains (like standard LangChain pipelines) are linear. They move in one direction and terminate. But to get high-quality content, we need a cyclic graph. We chose LangGraph specifically for its ability to create stateful, cyclic routing.

Here is how a thought becomes a polished post:

1. Cleaning Agent: Strips out noise and normalizes your raw, messy notes.
2. Keyword Agent: Extracts core topics and maps them to industry trends.
3. Writer Agent: Combines your keywords, the cleaned context, and retrieved RAG data to draft the initial post.
4. Reviewer Agent (The Editor): This is where the magic happens. It evaluates the draft for clarity, tone, and engagement, assigning a hard numerical score.
5. The Decision Node: If the post scores above an 85/100, the graph terminates and hands you a polished post. If it scores an 80? It gets routed to the Rewrite Agent, which applies the Reviewer’s specific feedback, and sends it back for a second review.

This guarantees a quality baseline. Content simply does not reach you unless it passes the algorithmic review threshold.

Under the Hood: Pipeline Execution & Code

Let’s look at how this conceptual graph translates into execution. The entire pipeline relies on a shared AgentState that prevents context loss as data moves between agents.

1. Defining the Shared State

This acts as our single source of truth. Every agent reads from it and appends its specific output.

from typing import TypedDict, List
class AgentState(TypedDict):
    topic: str
    raw_content: str
    cleaned_content: str
    keywords: List[str]
    draft_post: str
    review_score: int
    feedback: str
    iterations: int

2. Wiring the LangGraph Workflow

This is how we orchestrate the routing and the crucial self-improvement loop.

def route_review(state: AgentState):
    score = int(state.get("score", 0))
    rewrites = int(state.get("rewrite_round", 0))
  if score >= Config.REVIEW_SCORE_THRESHOLD:
        return END
    if rewrites >= Config.MAX_REWRITE_ROUNDS:
        return END
    return "rewrite"

def build_graph():
    graph = StateGraph(AgentState)
    graph.add_node("clean", cleaning_agent)
    graph.add_node("keywords", keyword_agent)
    graph.add_node("write", writer_agent)
    graph.add_node("review", reviewer_agent)
    graph.add_node("rewrite", rewrite_agent)
    graph.set_entry_point("clean")
    graph.add_edge("clean", "keywords")
    graph.add_edge("keywords", "write")
    graph.add_edge("write", "review")
    graph.add_conditional_edges("review", route_review)
    graph.add_edge("rewrite", "review")
    return graph.compile()

3. The Self-Evaluation Logic

Instead of assuming the first output is gold, we explicitly prompt the local LLM to critique itself.

def review_node(state: AgentState):
    draft = state["draft_post"]
    
    prompt = f"Evaluate this LinkedIn post. Give a score from 1-100 and specific feedback to improve it. Post: {draft}"
    response = llm.invoke(prompt)
    
    score, feedback = parse_llm_response(response) 
    
    return {
        "review_score": score,
        "feedback": feedback
    }

Empathy in Automation

I didn’t build this to spam LinkedIn. I built this because sharing knowledge shouldn’t feel like a chore.

As professionals, our primary value is in our ideas, our technical execution, and our unique perspectives , not in our ability to agonize over paragraph transitions for an hour. By delegating the operational friction of writing to an agentic system, we free up our cognitive load to do what we do best: innovate.

This pattern is applicable far beyond social media. The exact same architecture can automate technical documentation, summarize complex research, or generate weekly stakeholder updates.

Where We Go From Here (Limitations & Future Scope)

No system is perfect, and transparency is key in AI engineering:

• Evaluation Quality: LLMs can sometimes be overly optimistic when scoring their own work. Future versions will explore ensemble evaluation (multiple models voting on a score).
• Latency: Running multiple agent loops locally (e.g., via Ollama) takes time. Optimization via smaller, highly quantized models is a priority.
• Future Features: I plan to add a trend-detection agent to scrape Hacker News and Reddit, alongside an engagement prediction model to optimize the hooks before publishing.

The Takeaway

The era of manual, prompt-heavy AI interactions is ending. The future of AI engineering is not just about building better, larger models. It is about building better systems.

Systems that critique their own outputs, collaborate across specialized modules, and iteratively improve results.

If you’re tired of the content grind and want to deploy your own automated workforce, you can explore the full code, fork it, and adapt it to your needs.

Full Project Repository: LinkedIn Autonomous Content Creation Agentic System

What do you think about moving from single-prompt generation to multi-agent workflows? Have you experimented with LangGraph in your own projects? Let me know in the comments below, and follow me for more deep dives into Agentic Architectures and LLM engineering!

How I Built an Agentic System That Runs My LinkedIn for Free was originally published in Level Up Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.