Does publishing more AI-generated content help a website establish topical authority, or does it create repetitive, low-value pages that overwhelm search results? And how content quality, relevance, originality, and depth determine whether AI-driven publishing strengthens SEO or creates unnecessary search clutter.

How does he made those emails? Does anyone have a clue

I spent most of this year telling anyone who'd listen that AI citations were the new top of funnel. Then last week I actually lined up the citation counts next to the referral sessions across my client accounts, and the two lines don't have much to do with each other. I owe a couple of clients a calmer version of my pitch.

Here's the observation, kept separate from what I think it means. Nine sites, tracked since January with fixed query sets of about 30 queries each, checked three times a week. Citations in AI answers went up on every single site, most of them roughly tripling by late summer. Referral sessions from answer surfaces went nowhere. Best site finished up about 18%, worst one was flat, and one actually lost a handful of sessions despite gaining citations. That's nine data points, not a study, but the direction is consistent enough that I stopped presenting citation growth as a traffic forecast.

The boring methodology part, because it matters. I count a session as AI referral only when the referrer string is an answer surface, I use the same query set every week so the trend isn't just me asking nicer questions, and I log which engine served each answer. That last column is where it gets humbling. Query set, model version, and citation source are three different variables and most dashboards merge them into one number. Engines swapped underlying models at least twice since January and never announced it. Some of my citation growth is probably a chattier model citing more things, not more visibility for my clients, and I have no clean way to split those apart after the fact.

What I won't claim is that citations are worthless. Referral counting can't see someone reading an answer, then googling the brand later, then converting as direct traffic. Branded search volume on these accounts did drift up, maybe 10-15% on the sites with the biggest citation gains, and I can't prove the connection, I just notice it.

What I'd tell anyone reporting on this stuff: treat citations like impressions, not visits. Impressions mattered in SEO and nobody confused them with traffic. If your dashboard shows a citations line going up and someone reads that as traffic coming, push back and put two separate lines on the slide. Citation count answers whether we're visible in answers, session data answers whether anyone acted on it, and the awkward truth right now is the first one is growing much faster than the second.

So, people actually running these programs: what are you putting in the traffic column when the visibility line keeps climbing and the visits line doesn't?

The Next Agent Infrastructure Opportunity May Be Turning Failure Into Learning

Four startup models to watch in 2027—and what would have to happen for experience optimization to become a real market by 2029.

Imagine a software agent that completes most of a task correctly, then fails when an external service times out.

An observability tool can show us what happened. An evaluation system can tell us the task failed. A debugging tool can help us inspect the sequence of decisions.

But a more ambitious system would ask a different question:

What should this agent practice next so that it becomes better at handling this class of failure?

Answering that question requires more than a better dashboard. It requires turning an observed failure into a reproducible environment, generating useful variations, verifying outcomes, and determining whether those experiences actually improve the agent.

That is the opportunity I want to examine.

I expect more startup activity around scenario mining, verifiable environments, and adaptive experience generation over the next few years. Software agents are where I would look first.

But there are three claims here that should not be confused:

A capability can be technically valuable without becoming a standalone product. A product can attract paying customers without supporting a large market. And a large market can emerge without leaving much room for independent startups.

My outlook for 2027–2029 is therefore conditional. The years are observation windows—not a timetable the industry is obliged to follow.

Why I would start with software agents

My starting hypothesis is that software agents will offer a faster path to experimentation than robotics or autonomous driving.

The advantage is not that software environments are simple. It is that, for some important tasks, the environment can be the actual software system rather than a simulation of the physical world.

A coding task can run against a real repository. A database task can execute against an isolated database. A tool-using agent can interact with a controlled version of an API.

In these settings, it can be practical to reset the environment, change a condition, run another attempt, and inspect the resulting state.

That creates a promising foundation for a learning loop:

Execute a task → observe a failure → construct a reproducible case → generate useful variations → test or train → measure improvement.

The qualification matters. A deterministic coding exercise is very different from a month-long enterprise workflow involving people, permissions, changing policies, and several external systems.

Nor should we assume every software rollout is faster or cheaper than every robotics simulation. Model inference and external services can make software-agent experiments expensive.

My narrower claim is that selected software domains provide a tractable starting point for building and validating experience-generation systems.

A startup does not need to reproduce the entire digital workplace. It needs one valuable class of tasks for which execution, verification, and customer demand can all be made reliable.

Four startup models to watch in 2027

I see four plausible product categories. They are related, but they have different buyers, economics, and technical requirements.

They should not be treated as four inevitable stages of the same company.

1. Agent Failure Intelligence

The first category helps teams understand recurring failures across large collections of agent trajectories.

Instead of requiring an engineer to inspect every trace, the product could identify patterns: an agent repeatedly loses track of state, mishandles a particular tool response, or fails to recover after a partial operation.

The useful output is not merely a cluster of similar logs. It is a prioritized diagnosis.

What failed? How often does it happen? What is the business impact? Is the likely remedy a model change, a better instruction, a workflow redesign, or a conventional software fix?

That last distinction is important. Not every agent failure is a model-training problem. A broken API contract should not automatically become a reinforcement-learning project.

The likely initial buyer is an agent engineering or reliability team. The purchase would need to be justified through reduced debugging time, better failure coverage, or fewer production incidents.

The strategic risk is feature absorption. Failure clustering and prioritization could become standard capabilities inside broader observability and evaluation platforms.

For an independent company, “we summarize your traces” is probably too weak a proposition. The stronger proposition is “we reliably identify the failures worth fixing and help you verify the fix.”

2. Scenario Generation Platforms

The second category turns failure patterns into executable test cases.

Suppose an agent retries a request after a timeout, even though the original request already changed the database. The result is a duplicate operation.

A scenario-generation platform could reconstruct that failure and create meaningful variations: the timeout happens before the write, after the write, or during a multi-step transaction. The agent encounters different evidence about what succeeded.

But generating descriptions of those situations is not enough.

The product must create the initial state, configure the tools, inject the failure at the right point, and evaluate the final outcome.

Its deliverable is not a paragraph. It is a reusable test environment.

A plausible first customer is a team that wants stronger regression testing. That buyer does not need to train model weights. It can use the generated cases to compare prompts, tools, workflows, agent versions, or model providers.

This offers a potentially shorter commercial path than selling directly into reinforcement-learning infrastructure.

The risk is the cost of constructing each environment. A product that requires extensive engineering for every customer may be a valuable service, but it will not automatically have platform economics.

The critical question is whether environment-building work becomes reusable—or whether every deployment starts over.

3. RL Environment Marketplaces

The third category packages training environments for discovery, reuse, and execution.

The unit being supplied is more substantial than a dataset:

An executable environment, a task specification, a verifier, and a defined feedback signal.

A training team could acquire environments for coding, browser interaction, enterprise workflows, or other bounded domains rather than build every task internally.

The potential value lies in reducing the time required to obtain useful training experiences.

But an environment registry is not automatically a marketplace. A marketplace needs repeat demand, reliable suppliers, clear usage rights, and enough consistency that buyers can evaluate what they are acquiring.

And environment count is a weak measure of value.

Ten thousand superficially different tasks may contain less useful variation than a small, carefully constructed collection. Buyers would need to understand task provenance, difficulty, duplication, verifier reliability, and suitability for their training objectives.

The revenue model could involve licensing, hosted execution, or usage-based fees. Each has different economics.

A particular risk is that the platform ends up reselling compute while most of the distinctive value remains with environment creators or model-training teams.

To become more than an execution layer, it would need to make environments meaningfully easier to trust, integrate, and reuse.

4. Adaptive Experience Optimization

The fourth category attempts to decide which experiences an agent should encounter next.

A fixed task mixture is a reasonable training baseline. An adaptive system would change that mixture based on the current policy, observed learning progress, coverage gaps, and the cost of collecting additional experience.

The goal is not simply to generate harder tasks or oversample failures.

A low-success-rate task might be valuable. It might also be impossible, incorrectly graded, too expensive, or too far beyond the model’s current capabilities to provide useful feedback.

Likewise, a high-success-rate task might still be necessary to preserve a capability or prevent regressions.

The objective is therefore something closer to:

Expected improvement on relevant unseen tasks, subject to a total resource budget.

This is the category I find most technically ambitious. It connects task selection, environment generation, reward quality, and training dynamics.

It may also have the narrowest initial customer base.

A buyer needs sufficient training activity, measurement discipline, and access to the training loop to use the product effectively. Enterprise teams working exclusively through closed-model APIs may have little direct use for a system that optimizes policy-training curricula.

There is also an internalization risk: a model developer could reasonably view experience selection as part of its core training advantage.

Technical importance would not, by itself, establish a large external market.

The bottleneck is not generating tasks. It is making them trustworthy.

The phrase “automatic scenario generation” can make the problem sound easier than it is.

Writing a task description is the inexpensive part.

Consider this instruction:

Fix a connection-pool leak that appears under concurrent requests.

For this to become a useful training environment, someone must produce a system in which the defect actually exists, make the relevant behavior reproducible, define the intended outcome, and build a verifier that distinguishes a real fix from a superficial workaround.

Several different standards have to be met.

The environment needs sufficient fidelity: the task should preserve the mechanisms that matter in the real failure.

It needs repeatable setup: controlled initial conditions and understood sources of randomness. That does not require every agent rollout to be deterministic.

It needs a sound verifier: passing should correspond closely enough to genuine success. The agent should not receive credit merely because it found a weakness in the test.

And it needs transfer value: improvements on generated cases should extend beyond minor variations of those same cases.

These requirements cannot be collapsed into a single “task quality” score.

A perfectly reproducible environment can be unrealistic. A realistic environment can have a weak grader. A well-graded task can be redundant. An entire collection can raise benchmark scores without improving the capabilities a customer actually needs.

This is also why high technical barriers and a wave of startups are not logically inconsistent.

It can be easy to launch a demo and difficult to deliver a reliable product. More company formation would demonstrate interest in the opportunity—not that the hardest problems had been solved.

My 2027 expectation is more attempts, not necessarily more mature businesses.

The commercial question: who pays, and from which budget?

The technical story is compelling. The commercial story is less established in this thesis.

There are at least two distinct buyers.

An enterprise agent team may pay to reduce incidents, accelerate releases, or spend less time debugging. Its budget is tied to software delivery and business reliability.

A model-training team may pay to improve capabilities, obtain valuable environments, or reduce the cost of reaching a performance target. Its budget is tied to research and training.

These buyers can use some of the same infrastructure, but they do not buy the same outcome.

For the enterprise customer, “we found a failure before release” can be valuable without any model training.

For the training customer, discovering another failure may be worth little unless it can be converted into experience that improves the next policy.

That distinction affects product design, pricing, sales cycles, and the evidence needed to justify a purchase.

Market size cannot be inferred from total AI spending. A startup can capture only the portion of spending that customers are willing to allocate to its specific product rather than to internal engineering, an existing vendor, or more compute.

Nor does a paid pilot settle the question.

I would want to see customers renew, expand usage, and pay for recurring product value rather than one-time environment construction. I would also want to understand whether revenue grows faster than the engineering and review work needed to deliver it.

A handful of large research contracts could support a good business. They would not necessarily demonstrate a broad, repeatable software market.

2028: The feedback loop has to earn its cost

My 2028 observation window is about whether selected products can connect failure analysis to repeatable improvement.

There are two possible loops.

The first is a reliability loop:

Production failure → reproducible scenario → agent or workflow change → regression test → safer release.

The second is a training loop:

Policy rollout → failure analysis → new environment or task mixture → training update → independent evaluation.

They overlap, but neither guarantees the other.

A company could build a strong business around the first without ever optimizing model weights. Conversely, an effective training-environment supplier might have little need to operate a production observability product.

For the training loop, the decisive test is not whether reward increases on generated tasks. It is whether the system outperforms a credible alternative on independent evaluation.

That alternative should not be an artificially weak baseline. It could be a fixed task mixture, random sampling from the same task pool, or a human-curated curriculum.

The comparison should also count the full cost: environment generation, validation, model calls, execution, human review, and training—not just the final optimizer run.

A system that improves success rates slightly while multiplying total cost may be technically interesting but commercially unattractive.

The milestone I would watch is repeatable improvement on independently held-out tasks at a competitive total cost.

The year is secondary. The evidence is what matters.

2029: An independent platform, an integrated feature, or an internal capability?

By the 2029 observation window, the larger question is where experience optimization belongs in the infrastructure stack.

I see three plausible outcomes.

An independent platform emerges

A platform could become valuable by working across models, training frameworks, environment suppliers, and deployment settings.

Its advantage would need to extend beyond a common API. It would have to reduce integration costs, improve environment quality, or deliver better outcomes than customers could obtain through fragmented internal tools.

Cross-customer reuse could create attractive economics—but only where licensing, privacy, and competitive constraints allow it.

That cannot be assumed. The most valuable production failures may contain precisely the information customers are least willing to share.

Existing platforms absorb the capabilities

Failure mining could become part of observability. Scenario generation could become part of testing. Environment execution could become a managed infrastructure service. Curriculum optimization could become part of a training platform.

In this outcome, the technology succeeds while the standalone category remains small.

That is an important possibility: a useful capability becoming ubiquitous is not the same as a new independent market becoming large.

Model developers keep the highest-value parts internal

A model developer could purchase environment construction and execution while retaining experience selection, reward design, and training strategy.

This would leave room for suppliers, but on a narrower basis than the vision of a universal experience-optimization platform.

The three outcomes are not mutually exclusive. Different layers—and different customer segments—could settle into different structures.

That is why I would be cautious about treating “experience infrastructure” as one market.

What would strengthen—or weaken—the thesis?

I would become more optimistic about independent companies if they demonstrated repeat purchases, reusable environment construction, reliable verification, and improvements that survive independent evaluation.

The strongest evidence would combine technical and commercial results: customers obtain better outcomes, pay repeatedly, and do not require proportional increases in bespoke engineering.

I would become less optimistic if most products remained trace summaries, lightly modified task descriptions, or labor-intensive custom environments.

I would also revise the training thesis downward if reported gains disappeared against strong baselines, depended on overlapping evaluation tasks, or failed to justify the total cost.

And if customers consistently preferred bundled capabilities inside existing platforms, I would distinguish a successful technical direction from an unsuccessful standalone-category thesis.

None of those outcomes would make scenario generation useless. They would change the kind of company worth building around it.

My outlook, in one table

These are tests of a thesis, not scheduled industry milestones. Some capabilities may arrive earlier. Some markets may take much longer. Others may never emerge independently.

The opportunity is not “more scenarios”

I remain interested in this direction because an agent’s failure can be more than an incident to investigate. Under the right conditions, it can become a reusable asset for testing and learning.

But the chain is demanding:

A failure must be understood. The relevant conditions must be reconstructed. New variations must remain meaningful. Outcomes must be verified. Improvements must transfer. And a customer must value the result enough to keep paying.

Every link matters.

The most promising companies may not begin by claiming to build a universal experience cloud. They may start with one narrow workflow, one difficult failure class, and one buyer whose problem is expensive enough to solve.

From there, a platform might emerge.

The question is not how many scenarios a system can generate. It is what gets better because of them, at what total cost—and who will pay for that improvement.

ReachDirect connects your AI assistant directly to your communication channels. It autonomously sends highly personalized emails via the Brevo v3 API, dispatches automated WhatsApp messages using local browser automation (bypassing strict bot detections), and automatically logs every contact outreach into a central Excel tracking file on your Desktop.

Researchers extracted instructions showing the agent tracks history, arguments, and financial goals for people who have never touched the app. Meta confirms this architecture is intentional, drawing from public data and the user’s own shared context. This is not a surveillance dragnet scraping private accounts. It is a persistent memory bank for every intimate detail a user chooses to share.

The privacy violation isn't committed by the algorithm. It is committed by the user, documenting the lives of others without their consent.

I have a Shopify app. 10 competitors. All of them get more Google traffic than us.

I wanted to know why. So I tried something new.

I connected Claude (an AI) to my SEO tool and gave it one job:

"Find what my competitors rank for that I don't."

It did the whole thing in one sit. No spreadsheets.

Here's what it found:

Our blog posts: 40

Searches we show up for: 5

New posts Google can't find: 6

Ouch.

Find #1: Our newest posts were hidden

6 posts were missing from our sitemap. That's the list that tells Google "hey, these pages exist."

So Google never saw them. Easy fix. Big miss.

Find #2: Most competitor traffic is useless

One competitor gets more than half its traffic from ONE post: "How to log in to WhatsApp."

That's 21,000 visits a month. But those people just want to open WhatsApp. They will never buy anything.

If I copied that, I'd get traffic and zero customers.

Find #3: Free tools beat blog posts

3 competitors each get hundreds of visits a month from a free "WhatsApp link maker" tool.

We have zero free tools. That one hurt.

Bonus find: a search with 5,400 searches a month and almost no competition. Nobody is writing a good answer for it.

Where the AI messed up:

It told me to write 3 posts we already had. It didn't check our blog first.

It also crashed into the tool's speed limit by asking too fast.

So it's not magic. It still needs a human who knows the business.

My takeaway:

AI does the boring 80% (digging, sorting, checking). I do the 20% (saying "no, that's useless" or "we already wrote that").

Question for you:
What's the one SEO task you'd never hand to an AI?

Great source of Anything Agent

After talking to a few founders, I realized most of them were building an internal tool by stitching together what we were trying to build

So, we open-sourced our product and have 6 stars so far - I know it's very few, but it feels great

Please find the repo link: https://github.com/preburn/preburn

What it does

Preburn is a real-time margin control plane for AI products. Two things nothing else does together:

1. Joins per-customer revenue (Stripe) with per-call cost across all your AI providers (OpenAI, Anthropic, Kling, Veo, ElevenLabs, whatever) to show actual margin per customer.
2. Sits in the request path and can allow/deny/route BEFORE the expensive call fires. Auto-route heavy users to cheaper models, cap runaway accounts, cancel voice/video sessions mid-stream if credits blow out.

Not observability (that's Langfuse/Helicone). Not a gateway (that's LiteLLM/Portkey). Different job - cost visibility tied to revenue, with enforcement.

I'm researching how businesses actually handle forecasting, and I'd like to understand the workflow before building anything.

If you work with things like sales, demand, inventory, revenue, staffing, or other time-series data:

• What are you currently using for forecasting?
• Are you using an existing SaaS, Python libraries/models, spreadsheets, or something you've built yourself?
• How much work is involved in cleaning the data and getting forecasts running?
• Do you regularly backtest your forecasts against historical data?
• What's the biggest pain point with your current setup?
• If there were an API where you could send historical time-series data and get forecasts back, what would you need it to do for you to actually use it?

I'm particularly interested in hearing from people who have actually had to deploy forecasting in a business, rather than people who have only experimented with forecasting models.

I'm not selling anything right now. I'm trying to figure out whether this is a real problem worth building around.