From Content Retrieval to WeChat Drafts: The Content Creation Toolchain I Design for AI Agents

One thing has become much clearer to me over the last two years:

I do not just want to build a single tool. I want to build a content creation toolchain for AI Agents.

Because the real problem in content automation is rarely just “can the model write.”

The real problem is whether these steps can be connected into a stable workflow:

1. content retrieval
2. topic selection and filtering
3. drafting
4. formatting
5. draft delivery into WeChat

If any of those steps remains manual, fragile, or disconnected, the workflow is still only half-automated.

Why so many AI content workflows stop halfway

Because most products solve only one slice.

Some tools solve:

• AI writing

Some tools solve:

• Markdown to WeChat HTML

Some tools solve:

• source retrieval

Each one can be useful on its own, but the gaps become obvious when you try to chain them:

• where does the material come from
• how does the agent read a URL
• how are topics selected
• how does the output become WeChat-friendly
• how are images and assets handled
• how does the result enter the draft system

That is why I care less about isolated buttons and more about agent-callable workflow layers.

Stage 1: content retrieval is the real beginning

Many people want the agent to start writing immediately.

That sounds efficient, but it usually creates weak input and unstable output.

The first layer should answer:

• where the material comes from
• how the workflow searches for sources
• how a URL becomes readable content
• how web pages enter the agent pipeline

That is where jina-cli fits.

The role of jina-cli in the stack

jina-cli is a web reading CLI for AI Agents.

It handles:

• web search
• reading page content
• turning URLs into Markdown, Text, HTML, or JSON that models can consume more easily

If the whole workflow is a pipeline, jina-cli owns the front input layer.

It is not the final content product.

It is:

• a material retrieval layer
• a URL reading layer
• an agent-facing web input layer

Stage 2: topic selection should not depend on the model inventing context

Once the material is available, the next step should not be unconditional drafting.

A stronger middle layer looks like this:

• summarize sources
• compare sources
• decide which angle matters
• build a structure
• then draft

The core job here is not speed. It is editorial judgment.

This is the kind of work I want the agent to do:

• decide which sources are worth using
• decide which angle fits the audience
• identify which sources reinforce each other
• determine whether the article should be news, tutorial, or opinion
• turn source material into a coherent structure

Without the retrieval layer, this often degrades into:

the model writing from vague memory.

With a tool like jina-cli, topic selection and structure can be grounded in actual source pages.

Stage 3: drafting is the middle layer, not the whole product

It is easy to confuse “AI content tools” with “AI writing tools.”

I do not think that is enough.

Writing matters, but what determines whether a workflow is usable is whether the writing step is connected to both the input side and the publishing side.

At this stage, the agent can do work like:

• outline generation
• angle extraction
• synthesis across multiple sources
• converting notes into a publishable article
• adapting the tone to a target channel

In other words, generation should be grounded in:

• real source material
• chosen editorial direction
• a specific destination channel

Stage 4: formatting is one of the most underestimated layers in content automation

This is where many workflows break.

The article exists, but once it enters WeChat, the formatting falls apart:

• heading structure is inconsistent
• quote styling is weak
• image layout feels wrong
• code blocks and spacing degrade

That is one reason I continued building around md2wechat.

This layer solves:

• Markdown to WeChat-friendly HTML
• formatting automation
• theme and style control
• a more stable bridge into real publishing environments

If jina-cli solves the front-stage input problem, then md2wechat solves the back-stage formatting problem.

Related reading on this site:

• md2wechat-skill
• md2wechat-lite
• What a WeChat Automation Workflow Should Include

Stage 5: draft delivery is where the workflow starts to feel complete

Formatting is not the end.

The workflow gets much closer to business usefulness when the agent can move the result into a reviewable draft state rather than stop at a local Markdown or HTML file.

That is where md2wechat Agent API becomes important.

It fits the back stage of the workflow:

• convert content into WeChat-friendly HTML
• create article drafts
• create newspic drafts
• upload media assets
• send the result into the WeChat draft system

At that point, the pipeline becomes:

Front stage

• jina-cli
• search
• web reading
• source pool creation

Middle stage

• topic filtering
• summarization
• structural planning
• draft generation

Back stage

• md2wechat
• formatting
• media handling
• sending into WeChat drafts

This toolchain is not only about “writing articles”

More accurately, it is about:

turning content creation into a workflow an agent can execute repeatedly.

I want each layer to stay clear in responsibility:

• jina-cli for retrieval
• the agent for understanding, filtering, and writing
• md2wechat for formatting and publishing

That is different from the “all-in-one platform” approach.

I would rather build:

• CLI tools
• skills
• APIs
• workflow layers that can be composed

Because the agent era rewards:

• tools with clear boundaries
• interfaces that can be embedded in runtimes
• modules that can be chained freely

Why I keep building CLI tools for agents

I increasingly believe that many software products are no longer built only for humans.

They are also built for agents.

That means tool design has to consider more than buttons and screens.

It also has to consider:

• how the agent calls a command
• how the agent calls an API
• how multiple tools connect into one workflow

That is why I keep building content-related tools for agents:

• retrieval tools
• web reading tools
• formatting tools
• draft and publishing tools

They may look separate, but they are all solving the same deeper problem:

turn the most fragile parts of automated content creation into reusable agent capabilities.

The long-term goal is not a single article, but a reusable infrastructure

Looking further ahead, I do not want these projects to stay as scattered utilities.

I want them to become a content infrastructure layer for AI Agents.

That kind of infrastructure can support:

• WeChat creators
• technical content teams
• AI news workflows
• niche publishing operations
• teams that need semi-automated publishing

Today that stack may mainly include:

• jina-cli
• md2wechat
• md2wechat Agent API

Later it can expand into:

• topic scoring
• quality evaluation
• voice and style constraints
• multi-channel distribution
• feedback loops from published results

Closing thought

If you want AI Agents to participate in content creation in a meaningful way, the key is not only model choice.

The key is workflow continuity.

For me, the pipeline has at least three major parts:

• front stage: content retrieval
• middle stage: topic selection and drafting
• back stage: formatting and draft publishing

jina-cli solves the front stage.
md2wechat and md2wechat Agent API solve the back stage.
The agent workflow in the middle handles selection, shaping, and writing.

That is the direction I care about:

not one isolated tool, but a content creation pipeline agents can actually execute.

Continue Reading

• Retrieval layer: geekjourneyx/jina-cli
• Formatting and publishing layer: md2wechat Agent API
• Workflow breakdown: What a WeChat Automation Workflow Should Include