Inside Pressonify's Multi-Agent AI Architecture: How Press Releases Get Made

Inside Pressonify's Multi-Agent AI Architecture

Most AI writing tools send one prompt to one large language model and hand back whatever comes out. That works for a first draft. It doesn't work for a press release that will be published under a real company's name, parsed by search engines, and quoted by AI assistants.

Our approach: split the job across 16+ specialised PydanticAI agents, each responsible for one part of the work, with typed inputs and outputs so every step can be validated. The result is a publish-ready release, with structured data and fraud checks, drafted in about a minute.

Updated September 2026.

Why One Model Isn't Enough

A press release has to do several jobs at once:

• Read well (clear headline, natural quotes, AP-style structure)
• Stay accurate (only the facts the customer supplied, nothing invented)
• Be machine-readable (Schema.org JSON-LD, FAQ answers, clean metadata)
• Be safe to publish (no scams, no false third-party claims)

Asking one prompt to optimise for all four produces compromises. Splitting the work lets each agent be judged on one thing, and lets us use different models where they perform best.

The Models

Everything is async Python (FastAPI plus PydanticAI), and every agent returns a Pydantic model, so malformed output is caught before it reaches a page.

The Agents, Grouped by Job

1. Writing

• PR Generation Agent: turns your announcement details into a structured release (headline, subhead, body, quotes, boilerplate). It writes from the facts you provide.
• Headline Generator: produces and scores headline options (also available as our free headline generator).
• Press Kit Generator: builds supporting press-kit material from the release.
• PR personas and Translation Agent: adapt tone and language where needed.

2. Accuracy and Safety

• Anti-hallucination controls inside the generator: forbidden-phrase checks that catch invented or unverifiable claims, and a facts-only mode for announcements where precision matters most.
• Validation Agent: checks the submission for completeness and consistency.
• Content Moderation: flags risky content, including claims made about third parties.
• Fraud Detection Agent: a 4-layer system (pattern analysis, entity validation, claim checks, risk scoring) that runs before anything is published.
• Domain verification (a service rather than an agent): business-email checks, MX records and a one-time code. More in why domain verification matters.

And you stay in control: you review and approve every draft before it goes live, so the final word on your announcement is always yours.

3. Discovery and Structure

• Enhanced SEO Agent: generates meta tags and the Schema.org JSON-LD every release carries (NewsArticle, Organization, FAQPage, BreadcrumbList).
• Knowledge Base FAQ Agent: drafts FAQ answers drawn from the release itself.
• Content Analyzer: scores citability (information gain, structure, freshness, authority) and suggests fixes before you publish.
• Wiki Agent: extracts entities from releases for our wiki and knowledge graph.

Once published, the release is added to our sitemap, RSS feed, llms.txt and /knowledge-graph.json, and pinged via IndexNow and WebSub.

4. Research and Measurement

• Query Research Agent: identifies the questions buyers ask AI assistants in your category.
• LLM Simulator Agent: previews how an AI assistant might answer those questions.
• Citation tracking (a service): after publication, it asks AI answer engines (Perplexity for every release, plus ChatGPT and Gemini on Premium and Enterprise) about your company and records when your release is cited. See what our tracked data shows about timing.

5. Amplification

• Social Media Orchestrator and Social Sharing Agent: draft platform-specific posts.
• Broadcast agents (script, voice, video): turn a release into audio and video formats.

6. Shopify (PresSEO)

A separate set of agents optimises product, collection, page and blog content for Shopify stores using the same schema and discovery principles.

How the Orchestration Works

Steps that depend on each other run in order (you can't score a release before it's written). Steps that don't, run concurrently with asyncio. A simplified sketch:

import asyncio
from pydantic_ai import Agent

writer = Agent("openrouter:anthropic/claude-sonnet-5.5", output_type=PRContent)
seo = Agent("openrouter:google/gemini-2.5-flash", output_type=SEOMetadata)

async def build_release(facts: AnnouncementInput) -> Release:
    draft = (await writer.run(facts.as_prompt())).output

    # Independent checks and enrichment run side by side
    seo_meta, fraud, citability = await asyncio.gather(
        seo.run(draft.as_prompt()),
        fraud_check(draft, facts.company_domain),
        score_citability(draft),
    )
    return assemble(draft, seo_meta.output, fraud, citability)

Three decisions shaped the design:

1. Typed outputs everywhere. Pydantic models make every agent's output testable and easy to trace.
2. Right model for the job. A strong writer where quality matters, a fast model for structured tasks.
3. Safety before publication. Fraud and moderation checks gate publishing; they are not an afterthought.

What This Means for You

You fill in one form. The agents write the release, check it, structure it for search engines and AI assistants, and publish it on a permanent page: the draft takes about a minute, and it goes live minutes after you approve it and confirm your company email. Then citation tracking tells you whether AI engines are quoting it.

For a broader overview of the platform, see what Pressonify is, or how this fits into agentic press releases.

Get Started

Try the AI press release generator.

Pricing: €49.95 per release, €9.95 for a company's first release, €200 five-pack. No subscription.

Written by the Pressonify team in Dublin. We build the platform described above, publish our own citation data, and correct it in public when it turns out to be wrong.