The Full Lifecycle: How an AI Agent Runs My Social Media and Content Publishing

I spent one Sunday morning building this. By Monday it was running unattended. Here’s the whole lifecycle — from the 7 AM news scan to the part almost nobody automates: learning what actually landed.

Morning Pipeline: 7:00–7:45 AM Bangkok Time

Everything starts while I’m still asleep.

At 7:00, my AI agent scans headlines across 30+ feeds — TechCrunch, The Verge, Bangkok Post, Thai-language tech media, retail trade press. It picks the stories worth reacting to and drafts 2–3 social posts, each with hashtags, source links, and platform-specific formatting.

At 7:15, a separate tracker compiles the Trump trading-activity report and emails it to me.

At 7:30, the headlines roundup lands in my Telegram — a curated digest of what matters in tech, AI, and business across Asia.

At 7:45, the performance brief arrives, and this is where the learning loop closes. It pulls engagement on every post from the last 72 hours, analyzes the patterns with real statistics — tercile comparisons, Welch t-tests, hard p-value gates, not vibes — and surfaces testable hypotheses about what’s working. It also checks the site: pageviews, top articles, follower growth. If something broke overnight, it says so. If an API token is about to expire, it says so before it bites.

The whole pipeline runs autonomously. I wake up to a finished intelligence package.

The Human Decision Layer

This is the part that matters most. The AI never autoposts.

I read the drafts over coffee. Some get approved as-is. Some get rewritten — often heavily. The AI offers a hook; I swap it for a sharper one. Some don’t make the cut at all.

Occasionally a draft outgrows a social post and becomes an article. When a topic deserves the longer argument — more context, more analysis, a real thesis — I route it to WordPress instead of X or LinkedIn.

Every draft is stamped with a rule version before it enters the queue. This isn’t bookkeeping; it’s the hinge the entire learning loop turns on. Without it, you can’t attribute an outcome to a decision — and an outcome you can’t attribute teaches you nothing.

Once items are marked ready, the posting scripts take over. They don’t run on a schedule of their own — they fire when I tell them to, when the queue’s cron comes round (every four hours for X), or when I trigger a publish by hand.

The Posting Flow

When a post goes out, four things happen as one atomic sequence:

1. Pre-post guard. The script calls begin_post() — an idempotency check. If the item is already posted, or in-flight from another process, it stops. No double posts, ever.

2. API call. The actual publish. For X, a tweet with inline links and validated @handles. For LinkedIn, text with an image in the body and the article link in the first comment — never inline, because inline links get throttled. Organization mentions like @Microsoft resolve through a curated map to real LinkedIn org URNs.

3. Success write-back. The instant the API returns a post ID, record_post() writes it back to the queue, marks the item published, and seeds a metrics entry tagged with the rule_version that was live when the draft was written. That tag is what makes the loop measurable later.

4. Failure handling. If the call fails, fail_post() clears the in-flight marker and records the error so the morning brief surfaces it — instead of the post vanishing into the void.

WordPress runs the same begin → API → record sequence: the article goes up through the WordPress.com API as Gutenberg blocks, with SEO metadata and a featured image attached.

Image Generation

Every LinkedIn post and every article needs an image. The agent generates one on demand with Google Gemini — dark gradient, abstract tech aesthetic, no text, 16:9. They’re not masterpieces, but they read as professional and they beat the default link-preview card every time.

The image is generated before the post goes out, its path stored on the queue item, and the poster verifies the file exists before it tries to publish.

The Learning Loop

This is where most AI-agent setups quietly stop — they publish, and that’s it. But publishing without measurement is just shouting into the void in a more organized way.

Three independent channels, never pooled into one number:

X/Twitter scores on early engagement rate — likes + reposts + replies over impressions, measured at the first settled day-one checkpoint. That denominator and that timing matter: they strip out reach and post age, the two confounders that otherwise dominate raw counts. The analyzer compares the top third against the bottom third using Welch t-tests for numeric features (character count, hashtag count, line breaks) and two-proportion z-tests for binary ones (does it ask a question? carry an emoji? contain a link?). A finding only surfaces if it clears the gate: p < 0.15, a minimum group size, a real effect. And it surfaces as a hypothesis to test — never as a command, never as a rule fed back into the generator to grind voice down into a formula.

WordPress / axelwinter.com gets its own instrument, because the curve is nothing like X’s. Articles accumulate views over weeks through search and slow discovery, not in hours through feed velocity. So the metric is views-per-day — total views over days since publication — age-normalized so a 30-day piece doesn’t lap a 3-day one by default. Same tercile structure, different clock.

LinkedIn is the blind spot. The API blocks engagement read-back on personal profiles, so there’s no automated signal — it’s judgment-only distribution. When I note a post’s LinkedIn performance by hand, that gets recorded, but it stays a separate channel with a separate verdict.

The loop closes when the analyzer groups posts by rule_version and asks one question: did the posts written under the latest epoch beat the baseline? If yes, that’s evidence. If the comparison can’t be made cleanly yet, the brief calls it provisional rather than dressing up noise as a result.

The Models — and What Isn’t a Model

Google Gemini handles perception and creation — image generation and web search. Every header image, every LinkedIn visual, every search query feeding the draft generator runs through it.

DeepSeek V4 Pro handles reasoning and composition — reading the 30+ feeds, generating the drafts, writing the brief in prose. What it deliberately does not touch is the statistics. The tercile comparisons and significance tests run in plain Python — Welch t-tests, two-proportion z-tests, hard p-value gates — precisely so the verdicts are auditable arithmetic, not a model’s hunch. The model proposes; the math decides.

That’s the real division of labor: Gemini for perception, DeepSeek for reasoning and prose, and ordinary deterministic code for anything that has to be trusted.

What This Isn’t

It isn’t a content farm. The AI doesn’t choose what to publish, doesn’t stamp posts out of templates, and is never allowed to optimize toward engagement at the expense of voice. Every post passes through a human filter. Every hypothesis is a suggestion, not a directive. Every channel keeps its own instrument.

What the system actually does is collapse the distance between awareness and measurement — the gap between noticing a story and knowing whether it landed. That gap used to cost days of checking dashboards and scrolling feeds. Now it fits inside the morning brief.

The architecture is sound. The operating contract is clear. And it all runs on a machine in Bangkok while I have breakfast.

Built with OpenClaw, Tweepy, the WordPress.com API, Google Gemini, DeepSeek V4 Pro, and a lot of Sunday-afternoon debugging.