Skip to main content

Building a Write-Only Social Media Agent with Remote MCP

··829 words·4 mins
Tip

TL;DR: By pairing an AI agent with Buffer’s remote Model Context Protocol (MCP) server (https://mcp.buffer.com/mcp), I created a “write-only” workflow that lets me draft, refine, and queue social media posts without ever setting foot in “The Feed.”

As a Developer Relations Engineer, I need to maintain an active presence on social media. Social media platforms reward you if you maintain a streak of regular posting (and can bury your content if you don’t play their game). But social media also wants you to stick around and scroll through ads and irrelevant content to get to the good stuff.

To avoid getting distracted by the feed, I figured and agent could help by queueing some posts. This would allow me to keep my posts consistent, without having to consume The Feed.

The Mental Model: Write-Only Social Media
#

When I do have thoughts to share, I often get distracted by The Feed, which is usually the first thing you see on any social media site. Next thing you know, it’s been 15 minutes and I’ve lost the thought I went there to post 👎.

So I set out to create a “write-only” architecture to interact with social media platforms safely:

flowchart TB
    A[Thought or Idea] --> B[AI Agent]
    B -->|HTTP SSE/Stream| C[Buffer Remote MCP Server]
    C -->|Creates Draft| D[Buffer Draft Queue]
    D -->|Manual refinement| E[Post Queue]
    E -->|Scheduled release| F[Social Media Sites]

To make this pattern work, I rely on Buffer, which offers several key capabilities for this workflow:

Buffer Free Tier
Supports up to 3 social channels without a paid subscription.
Post Scheduling
Automatically queues and publishes drafts on a predefined cadence.
Comment Handling
Manages follow-ups and replies without requiring full site navigation.
Remote MCP Server
A hosted HTTP MCP endpoint (https://mcp.buffer.com/mcp) that exposes Buffer tools directly to any MCP-compatible client.

Connecting directly to Buffer’s Remote MCP Server
#

Instead of using MCP’s stdio transport, Buffer provides a direct remote HTTP MCP endpoint. You can generate an API Key under Buffer Settings > API and configure your MCP client to connect directly:

{
  "mcpServers": {
    "buffer": {
      "url": "https://mcp.buffer.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Once I configured my agent with this remote server and instructed it strictly to create drafts (never auto-publish immediately), I could iterate on social media copy directly with my agent.

Then I periodically go through the list of draft posts in Buffer, refine them, and add a few to the queue. Buffer will then post them on the configured schedule, and the Buffer app notifies me when my queue is empty so I can publish a few more drafts!

As a bonus, I spend very little time in the Buffer UI itself (which does try to constantly upsell me on their own AI features), and more importantly, I spend less time looking at social media sites.

Caution

I found that when asking for analysis, the buffer MCP server was providing me mock data that was “skinned” to look vaguely like mine. This only seemed to happen with the list_posts tool. Its not clear to me if this was a temporary issue, or a systemic one, so be on the lookout for “plausible but mock” data.

Standalone Agent
#

I’m thinking a lot about shared agents as a way to package capabilities, rather than using a more API-centric approach like MCP. So, naturally, I decided to build a standalone agent to handle the details of posting.

With ADK Go, and the auth helpers from my experimental AgentHost framework, setting up remote MCP tooling is pretty straightforward:

// import "github.com/GoogleDevRelExplorations/agenthost/auth"
client, err := auth.NewClient("buffer")
if err != nil {
    return nil, fmt.Errorf("failed to get auth client: %v", err)
}
mcpToolset, err := mcptoolset.New(mcptoolset.Config{
    Transport: &mcp.StreamableClientTransport{
        Endpoint:   "https://mcp.buffer.com/mcp",
        HTTPClient: client,
    },
})
agent := llmagent.New(llmagent.Config{
    //other stuff omitted
    Toolsets: []tool.Toolset{
        mcpToolset,
    }
})

This agent how has access to all the Buffer MCP tools! 🎉

Buffer’s MCP service relies on an Authorization header with your API key as the bearer token. The auth.NewClient() call creates a client that will automatically inject this header in outgoing requests. This can also be done by manually adding the header to a standard http.Client if you prefer.

What’s Next?
#

As useful as agents are in the creation of social media content, I think they have much more potential as an incoming filter – surfacing only the posts that are likely to be interesting to me.

This obviously runs afoul of social media business models, so the “consumer side” tools are not broadly available. But I think with enough steering, an agent could navigate a social media site by URLs alone.

I’m still exploring here, but I’m hoping that agents can help us combat some of the dark patterns that certain types of sites are prone to (particularly news and social media).

Have you experimented with agents on social media? What type of tasks are they doing for you, or what would you like them to do?