Over the last while, I’ve been building Echo Irish, an AI-powered news platform focused on stories from across the Republic of Ireland.

The basic idea sounds straightforward: find important Irish news, understand what is actually worth reporting, write a clean article, and publish it.

The difficult part is doing that automatically without ending up with a site full of duplicate stories, low-quality summaries, irrelevant content, or articles that lose the context of the original reporting.

Echo Irish is my attempt at building that pipeline properly.

The idea

Most news aggregation systems are essentially feeds. They collect links from publishers and present them in one place.

Echo Irish works differently.

Instead of simply aggregating articles, it continuously searches for developing stories, decides whether they are relevant, checks whether the story has already been covered, and then generates an original article based on the available reporting.

The goal is for the system to behave more like a small automated newsroom than an RSS reader.

At a high level, the pipeline looks something like this:

Discover → Analyse → Deduplicate → Research → Generate → Validate → Publish

Each part sounds simple on its own, but most of the engineering work is in making those steps work reliably together.

The stack

Echo Irish is built primarily with:

• SvelteKit for the website and application layer
• Node.js / TypeScript for the news processing pipeline
• MongoDB for storing articles, comments, processing state and related data
• PM2 for keeping the production application running
• Nginx as the public-facing reverse proxy
• scheduled jobs for recurring news scans
• AI models with web-search capabilities for story discovery and research

The production application runs on my own Linux server.

Rather than relying on a long-running worker that constantly polls for stories, the news scanner is currently triggered periodically by cron. That makes the pipeline easier to reason about and means each scan behaves like an isolated job.

For example, the server can periodically run a command similar to:

npm run news:scan

The scanner performs the discovery and publishing process, exits, and then runs again at the next scheduled interval.

Finding stories

One of the first challenges is deciding what actually counts as a story.

Searching for “Ireland news” will return everything from major political developments to football results, weather warnings, local planning applications and articles that may be several days old.

The discovery system therefore needs to do more than simply collect search results.

For each candidate story, Echo Irish has to determine things such as:

• Is this actually about the Republic of Ireland?
• Is it recent?
• Is it significant enough to publish?
• Is it a new development?
• Is it simply another publisher reporting something already covered?
• Has Echo Irish already written about it?

The AI layer is useful here because the problem is largely semantic.

Traditional keyword matching can tell that two articles both contain “Dublin Airport”, for example, but it cannot reliably determine whether they describe the same event.

A language model can compare the actual meaning of the stories.

Avoiding duplicate news

Deduplication has been one of the more interesting parts of the project.

News stories evolve.

Imagine Echo Irish publishes an article in the morning about a major incident. Two hours later, another source reports additional information.

There are several possible outcomes:

1. It is the exact same story and should be ignored.
2. It contains a minor update that does not justify another article.
3. It contains a major development that does justify new coverage.
4. It is actually a separate story involving the same people or location.

A simple title comparison does not work particularly well here.

Instead, the system keeps a record of recently published stories and gives the AI enough context to compare new candidates against them.

The important distinction is between similar wording and the same underlying event.

For example:

“Government announces €200m housing programme”

and

“Cabinet approves new €200 million housing package”

are very likely the same story.

Meanwhile:

“Government announces €200m housing programme”

and

“Opposition calls for changes to Government housing programme”

may involve the same subject but represent a genuine new development.

That distinction is much easier to make semantically than with string matching.

Research before generation

I also wanted to avoid a system where an article is generated from a single headline.

That would be extremely easy to build, but the resulting reporting would be poor.

Instead, the system researches a story before generating the final article.

Where possible, it uses multiple sources to establish what happened and gathers information such as:

• the main event
• people and organisations involved
• dates and locations
• relevant figures or statistics
• additional context
• later developments

The final generated article is then based on that collected information.

This approach is important because AI-generated news has an obvious failure mode: confidently filling gaps with plausible-sounding information.

Giving the model a clearly defined body of source material greatly reduces the amount of inference required.

The model’s job becomes closer to:

“Write an article using these facts.”

rather than:

“Tell me what happened.”

That is a much safer architecture.

Keeping sources attached

Another important part of Echo Irish is maintaining the relationship between generated articles and their underlying sources.

The generated article is not intended to pretend that the information appeared from nowhere.

Internally, each story can retain the source material used during generation, allowing the platform to maintain traceability between the final article and the reporting behind it.

This also makes debugging considerably easier.

If the system produces a strange statement, I can inspect the sources that were available to the model at the time and determine whether the issue came from:

• poor source material,
• incorrect extraction,
• faulty reasoning,
• or the generation prompt itself.

For AI systems, observability like this becomes increasingly important.

Automated publishing

Once a story passes the checks, Echo Irish can publish it automatically.

That means the full pipeline can operate without somebody manually reviewing every candidate article.

This is also where safeguards become important.

Automation is useful only if the system is comfortable deciding not to publish.

A news scanner that produces ten stories every hour regardless of what happened would quickly become useless.

So rejection is a normal part of the pipeline.

Candidates can be discarded because they are:

• duplicates
• outdated
• irrelevant
• too minor
• insufficiently sourced
• or otherwise unsuitable

I keep logs of those decisions in the admin system.

That has been particularly useful while developing the project because it provides visibility into what the AI is doing rather than leaving the pipeline as a black box.

A discovery log can effectively show:

Story discovered
↓
Relevant to Ireland
↓
Compared against recent articles
↓
No duplicate found
↓
Enough reliable information available
↓
Accepted
↓
Article generated
↓
Published

Or alternatively:

Story discovered
↓
Matched existing article
↓
Rejected: duplicate

The admin system

Although most of Echo Irish is designed to operate automatically, I still wanted manual control.

The admin area allows me to inspect what the system is doing and intervene when necessary.

It includes tools for things such as:

• editing articles
• deleting articles
• managing comments
• removing comments
• viewing discovery logs
• seeing accepted stories
• seeing rejected stories
• inspecting the processing pipeline

This has turned out to be one of the most valuable parts of the project.

When developing AI systems, seeing only the final output hides most of the interesting failures.

The reasoning surrounding rejected candidates is often more useful than the articles that successfully publish.

Comments and authentication

Echo Irish also has a traditional application layer around the automated publishing system.

Users can authenticate using Google and participate in article discussions.

Comments are stored separately from the generated news content and support features such as replies and likes.

This part of the application is intentionally conventional.

One thing I have learned from building AI-heavy projects is that not everything needs AI.

Authentication, database relationships, moderation controls and comment systems are usually better solved using normal deterministic software.

The AI is used specifically where semantic understanding provides an advantage.

Running it in production

Echo Irish is deployed similarly to several of my other projects.

The built Node application runs through PM2, which handles process monitoring and restarts.

Nginx sits in front of the application and handles incoming web traffic.

The scanner itself runs independently on a schedule.

One advantage of separating the website from the scanner is fault isolation.

If a news scan fails because an external search request times out, the public website does not need to restart.

Likewise, deploying a new version of the website does not require restructuring the news ingestion process.

The architecture is roughly:

                    ┌──────────────────┐
                    │   News Sources   │
                    └────────┬─────────┘
                             │
                             ▼
                    ┌──────────────────┐
                    │ Discovery / AI   │
                    └────────┬─────────┘
                             │
                             ▼
                    ┌──────────────────┐
                    │ Deduplication    │
                    └────────┬─────────┘
                             │
                             ▼
                    ┌──────────────────┐
                    │ Research         │
                    └────────┬─────────┘
                             │
                             ▼
                    ┌──────────────────┐
                    │ Article Writer   │
                    └────────┬─────────┘
                             │
                             ▼
                    ┌──────────────────┐
                    │    MongoDB       │
                    └────────┬─────────┘
                             │
                             ▼
                    ┌──────────────────┐
                    │ SvelteKit Site   │
                    └────────┬─────────┘
                             │
                             ▼
                    ┌──────────────────┐
                    │ Nginx / Internet │
                    └──────────────────┘

There are plenty of additional details hidden behind those boxes, but that is essentially the flow.

The interesting part isn’t article generation

When people hear “AI news website”, the obvious assumption is that the difficult part is getting an AI model to write the article.

It isn’t.

Writing is probably one of the easiest parts.

The much more interesting engineering problems are:

• deciding what deserves an article
• recognising the same event across different publishers
• determining when a story has meaningfully changed
• collecting enough information before writing
• preventing hallucinated details
• deciding when not to publish
• keeping a useful audit trail
• and making the system reliable enough to run unattended

Those are orchestration problems rather than purely AI problems.

That is also where I think a lot of useful AI software is heading.

The model itself is only one component.

The real application is the surrounding system that controls what information the model receives, when it gets called, what it is allowed to do, and how its output is validated.

Where Echo Irish goes next

Echo Irish is still evolving.

There are several areas I want to improve further, particularly around story clustering and ongoing events.

Ideally, the system should build an understanding of a developing news event over time rather than treating every scan independently.

That opens up interesting possibilities.

A story could effectively have its own timeline:

09:12 - Initial incident reported
10:35 - Garda statement released
13:20 - New information confirmed
17:45 - Government response

The system could then understand that these are all developments belonging to one wider event.

That would make both deduplication and follow-up reporting significantly better.

I also want to continue improving the system’s ability to rank stories by importance rather than simply relevance.

There is a large difference between something being “Irish news” and something being important enough to place prominently on a national news site.

That is a surprisingly difficult judgement to encode.

Final thoughts

Echo Irish started as a fairly simple idea: build an Irish news website that uses AI.

It has gradually turned into a much more interesting engineering problem involving search, semantic comparison, automated research, scheduling, databases, moderation, observability and production infrastructure.

That is probably what I enjoy most about projects like this.

AI makes the application possible, but the interesting work comes from designing the system around it.

A single model call can generate an article.

Building a system that can decide when an article should exist in the first place is a much more interesting problem.

Echo Irish is live at echo.irish.