One challenge I kept running into was this ongoing tension between standalone AI tools and integrated AI features. I’ve built out a few standalone AI tools myself, and in many cases they’re easier, faster or more powerful than asking ChatGPT to do the same thing. But despite that, I kept going back to ChatGPT. Not because it’s always better, but because it knows me. The context I’ve built up there matters. It understands my tone, my workflows and the types of questions I tend to ask. None of the AI plugins I tried could replicate that.

So instead of trying to recreate that context elsewhere, I started thinking about how to bring ChatGPT into the systems I already use. This isn’t a new idea and there are already several official connectors available within ChatGPT, with HubSpot being the latest to toss their hat in the ring.

So I ran with it and turned into a plugin. And now that it’s stable and officially live on WordPress.org, I want to introduce it properly.

Connect to GPT lets your Custom GPT interact with your WordPress site

At its core, Connect to GPT is a secure connector between your WordPress site and a Custom GPT you build using the ChatGPT builder. It’s designed so your assistant can create and update content, respond to comments, analyze form submissions, pull site stats and more, all through natural language. You don’t need to install AI tools on your site, and nothing changes for your visitors. It’s an assistant just for you or your team.

Helpful Tip
You don’t need to code or configure APIs manually. The plugin includes a step-by-step onboarding flow that mirrors what you see in ChatGPT’s builder.

Visit WordPress > Settings > Connect to GPT and select the Onboarding tab at the top if it isn’t already selected.

What makes this plugin different from most AI plugins is that it’s not trying to bring AI features into WordPress. It’s trying to let AI work with WordPress on your behalf, from wherever you’re already using ChatGPT. This subtle shift makes a huge difference when it comes to productivity, context and extensibility.

Why I built it

Like most developers who experiment with AI, I started with the WordPress REST API. I even wrote a guide on how to use a Custom GPT to create and search posts using the API. It worked okay for basic tasks, but it hit some frustrating limitations:

• I couldn’t define enough endpoints in a single Custom GPT
• There was no way to send partial content updates without overwriting entire pages or posts

And the truth is, most of the AI tooling I came across treated WordPress like an afterthought. They weren’t built for LLMs, and they didn’t account for how GPTs actually process and manipulate text. So I started over. I built a plugin from the ground up that treats AI as the primary interface, not an after-market bolt-on.

That’s what makes Connect to GPT different.

AI-first design built around LLM strengths

Rather than giving the GPT full access to your site’s content, the plugin introduces a more thoughtful API layer optimized for how LLMs work. Instead of sending full updates, it encourages incremental changes using append, prepend, replace, before and after operations. This avoids common issues like overwriting large chunks of content or triggering errors in longer posts.

I also added a simple but powerful block selector system that helps GPTs target specific content for updates. It uses both the block type and either content or attribute matches to identify the correct element. You can even set target_index if there are multiple matches.

This means your GPT assistant can do things like:

• Append a new paragraph after a specific block
• Replace a CTA button in a certain section
• Add a disclaimer to the bottom of posts in a specific category

Helpful Tip
All content changes are draft-only by default. You can enable full publishing control in the plugin settings if you want GPTs to push live updates.

Visit WordPress > Settings > Connect to GPT > and select the Settings tab and make sure Safe Mode is disabled.

The plugin also splits longer content into smaller inserts automatically. This makes it safer and more reliable than any LLM integration I’ve seen, especially for longer or more complex pages.

What it can do today

If you’ve ever wanted to manage a WordPress site just by talking to ChatGPT, that’s exactly what this makes possible. You can create content, update pages, moderate comments, even retrieve analytics or form submissions, all from your GPT interface.

Here’s a sample of the core capabilities:

• Create, retrieve and update posts and pages
• Append, prepend or replace content within specific blocks
• Safely identify and manipulate target blocks in complex layouts
• Retrieve menus, site info, theme data and dashboard widgets
• Search media, users, plugins, themes and taxonomies
• Moderate and reply to comments
• Summarize or verify updates after changes are made

I also have two extensions available for purchase:

Analytics Extension

• Pull site stats, top posts, click data and more from Jetpack/WordPress.com connected sites
• Retrieve search terms, referrers, followers and post views
• Summarize traffic by day, week or month

Forms Extension

• Retrieve, search and filter form entries from common plugins like WPForms or Gravity Forms
• View form submission detail by ID
• Filter by keyword or date range for reporting

Both extensions plug right into your Custom GPT and are available from the same plugin page.

Real world use cases

This plugin opens up a ton of potential use cases. Here are a few I’ve personally tested or envisioned:

• A marketing manager updates homepage content for a new product launch
• A content writer drafts, edits and publishes posts from inside ChatGPT without logging into WordPress
• A social media manager reviews recent comments, filters spam and drafts replies
• An agency builds separate GPTs for each client site with brand-specific instructions and visual identity
• A site owner uses their assistant to summarize top-performing content from the past month

Helpful Tip
If you build multiple GPTs for different sites or roles, each one can include custom instructions, brand tone and conversation starters.

Set this up during Step 3 of the plugin’s onboarding flow

My own workflow has changed. I now routinely say things like:

“Draft a post about X, then add links to related posts on my site, give it a featured image, tags and a category. Review my last two posts for tone, then revise the draft accordingly.”

And it works. I can create, edit and optimize an entire post without leaving ChatGPT. That’s the power of centralizing context.

Getting started is simple

The plugin includes an onboarding wizard that walks you through everything:

1. Connect your site to your GPT using a secure API key
2. Define your GPT’s name, image and description
3. Add instructions and conversation starters
4. Register your capabilities (import via schema URL or manual JSON)
5. Enable optional features like analytics or forms
6. Start testing your assistant directly in ChatGPT

All of this takes less than 10 minutes and can be paused or resumed any time.

Final thoughts

I don’t think AI should be forced into existing workflows where it doesn’t belong. But I do think we need to start designing tools around the real strengths and limitations of large language models. This plugin is an attempt to do that.

It doesn’t try to do everything. It tries to do the things GPTs are already good at, in a way that’s safe, flexible and context-aware. And it’s already starting to surface new workflows I hadn’t anticipated.

With OpenAI’s new ChatGPT Agent architecture rolling out, we’re entering a phase where AI agents will start acting across apps and services more seamlessly. I think connectors like this one will be the bridge, not just for power users or developers, but for marketers, creators and teams who want to work faster without sacrificing quality or control.

If you’re a WordPress site owner and you’re already using ChatGPT Plus, I’d love for you to give Connect to GPT a try.

• View it on WordPress.org
• Explore extensions and details

The post Introducing Connect to GPT for WordPress appeared first on Jon Bishop.

I’ve built a few tools to test things out a bit, each designed around a core image-driven concept. These aren’t production apps. They’re quick builds, more curiosity than commerce. But they’re functional, fun and all live now in the AI Projects section of the site.

Here’s a look at the newest additions.

About the Model Behind these Projects

All of these tools use GPT Image 1, OpenAI’s latest image generation model. It’s built as a multimodal system, so it works with both text and image inputs and produces high-quality images as output.

What makes GPT Image 1 different from the older DALL·E models is how it handles visual understanding. You can pass in a reference image and the model is able to interpret the structure, shapes and style in a way that feels intentional. That means you can build around a single character design and carry it across multiple generations without it breaking down or drifting too far. It’s also just much higher quality overall.

Helpful Tip
Use a base image to guide the model if you want visual consistency across outputs.

This approach powers both the Storybook Generator and the Whitepaper Generator from start to finish.

It also handles prompt guidance better. If you want a specific pose or scene structure, the model usually delivers something close on the first try. That level of control helps when you’re trying to build tools that need reliable, repeatable results without constant re-rolls.

AI Avatar Generator

This was the first tool I built using OpenAI’s latest image generation model, mostly just to try out the edit and variation endpoints. The idea is simple. Upload a photo, choose a style and generate a customized avatar version of yourself.

You’re not picking from a prebuilt set of filters or templates. The tool lets you describe whatever visual style you want. Cyberpunk warrior. Cartoon hero. Forest elf. It takes your uploaded photo and uses the description to create a transformed version using OpenAI’s variation and edit features in tandem.

Helpful Tip
Styles work best when they’re character-based. Think roles or archetypes, not just visual themes.

Try prompts like “steampunk explorer” or “retro sci-fi astronaut” for better results.

This project was also a good reminder of image handling in the browser. After a bunch of tests on my Android, when my wife went to test on her iPhone, nothing. So I added automatic HEIC conversion support so users on iOS can upload photos without weird file errors. Behind the scenes it converts HEIC files to PNG before passing them to the AI engine.

Why I Built It

Honestly, just to get my hands dirty with the new API. I wanted to see how well it handled user-generated content and how expressive the results could be with some light prompt styling. The real value here is creative play. Upload a picture, imagine a persona and see how well the AI translates it.

Try your own styles with the AI Avatar Generator.

Storybook Generator

This project started as a question: could I use GPT-4o and image generation to create a complete, print-ready storybook with consistent characters and tone?

The app takes a single user prompt and turns it into an 8-page illustrated story, complete with a custom cover and optional dedication. Every page is built from the same character design, generated once and reused across all images to maintain consistency. The story is generated dynamically and each section is matched with an image designed around a scene description and the shared character.

You can flip through the book page by page in the browser. Once you’re done, you can download the whole thing as a ZIP file of ready-to-print images.

Helpful Tip
Include your someone’s name or a specific setting in the prompt to make the story feel more personal.

Try something like “A dragon adventure in the backyard with Emma and her dog Rocket.”

The visual style is intentionally playful and family-friendly. It’s not meant to be high fantasy or overly realistic. Think storybook warmth, soft palettes and comic-style captions.

Check it out and create your own illustrated story with the AI Storybook Generator.

Why I Built It

I wanted to test image reuse in a creative narrative format. Unlike blog illustrations or standalone assets, storybooks require visual continuity across pages. That’s something current AI models struggle with, especially across long outputs. This project forced me to design around those limits while still delivering something cohesive.

I also liked the idea of turning abstract AI outputs into something tactile. There’s something satisfying about watching your idea turn into a complete, printable story in under a minute.

AI Whitepaper Generator

This one brings together a lot of what I’ve been learning through earlier experiments. It uses multiple AI agents to generate a full whitepaper from scratch, including text, research and consistent image assets throughout.

You enter a topic. The tool creates a structured outline and designs a character that will visually anchor the entire whitepaper. That character becomes the base image, which is then reused and reinterpreted across every section using a unique prompt. The result is a multi-page, visually unified document that you can print or export as a PDF.

The writing itself is also handled by AI agents. One agent handles search and research. Another generates content for each section. A third produces section-specific illustrations using your character as a base.

Helpful Tip
Choose a topic that has some depth. The generator works best with broad themes or emerging trends.

Try prompts like “The Future of Wearable Health Tech” or “AI in Urban Transportation.”

It also includes style options like “Classic” or “Tech” so you can adjust the visual tone of the final whitepaper before printing.

Why I Built It

I wanted to see if it was possible to go beyond a simple blog post or one-shot image and actually orchestrate a full-length, structured deliverable with AI. This felt like the natural evolution of the Story Generator idea but extended into original research and narrative creation.

It’s also a practical use case. Tools like this could cut that time dramatically and provide a creative head start.

Create your own whitepaper with the AI Whitepaper Generator.

What’s Next

These projects are part of an ongoing experiment. Just testing ideas and figuring out where the tech shines or breaks.

Image generation is clearly improving fast, but we’re still in the early days of combining consistency, character and creativity across multiple outputs. The Whitepaper Generator comes close, and it’s already sparking ideas for more structured storytelling tools. Think comic book generator, or a product manual builder, all driven by the same base character and theme.

If you want to check out any of these tools, they’re all live now over on the AI Projects page.

Helpful Tip
Each tool is self-contained and runs entirely in the browser, so there’s no signup or account required.

Just open the web app, enter or upload your content and start experimenting.

More to come.

The post More AI Experiments with Images appeared first on Jon Bishop.

Search in ChatGPT, while powerful in theory, introduces major limitations that often get in the way of deeper conversations, creative ideation and reliable outputs. If you’ve ever found yourself wondering why ChatGPT suddenly starts repeating itself, forgetting prior instructions or hallucinating random facts right after performing a search, you’re not imagining things.

In this post, I want to break down what’s actually going wrong with search in ChatGPT, how it disrupts conversations and what workarounds I’ve found most effective to keep the quality high and the confusion low.

The Problem with ChatGPT Search

When ChatGPT performs a search, you’re not continuing the conversation with the same model. You’re now interacting with a different mode of the model entirely, one that prioritizes content retrieval over context retention.

The search model is a fine-tuned version of GPT‑4o, post-trained using novel synthetic data generation techniques, including distilling outputs from OpenAI o1‑preview. ChatGPT search leverages third-party search providers, as well as content provided directly by our partners, to provide the information users are looking for. 

Introducing ChatGPT Search

That context switch is where the problems begin.

The Context Collapse

In practice, using the search feature mid-conversation almost always leads to a degradation in response quality. Here’s what I’ve seen time and time again:

• It forgets your tone preferences, prompt instructions or formatting guidelines.
• It starts repeating itself, often parroting sections from search results with little original synthesis.
• It hallucinates data by blending outdated model knowledge with fresh but unvetted sources.
• It struggles with follow-up questions, even if they’re simple clarifications.

This is because the model that performs the search doesn’t have the same memory or chat context as the conversation you started with. It’s like calling customer service, getting transferred and then having to re-explain everything from scratch.

And The Results Aren’t Even Live

To make it even worse, the results that ChatGPT pulls during a search aren’t always live. They’re often based on cached versions of web pages, typically pulled from Bing’s search index. That means you could be getting information that’s days or even weeks out of date, depending on how recently the site was crawled.

I’ve seen this firsthand while researching fast-moving topics like AI product updates or industry news. I’d compare ChatGPT’s search summary to the actual article I just read on my browser, and details would be missing or flat-out wrong. Sometimes it’s referencing sections that no longer exist, or quoting stats from an older version of the page.

Helpful Tip
If accuracy or recency matters, never rely on ChatGPT’s search summaries alone.

Use your own browser to pull in the most current content, then feed that into a new chat for analysis.

My Core Workaround: Never Search Inside the Same Chat

The most reliable strategy I’ve found is deceptively simple: don’t use ChatGPT search mid-conversation at all.

Here’s how I approach research-heavy tasks:

1. Do the search separately, using traditional search engines or even ChatGPT’s search tool in a single, dedicated query.
2. Copy the relevant results, sometimes paraphrased or annotated and paste them into a new chat session with clear framing like:
   “Here is some source material. I want you to analyze and summarize the key points. Don’t reference the web, just use this.”
3. Continue the conversation from that new chat if needed, but don’t prompt it to search again unless you’re okay starting from scratch again.

This lets you control the context, keep responses grounded and avoid the weird disjointed behavior that shows up after ChatGPT’s been out browsing.

Helpful Tip
Always separate search from synthesis. Treat them like two different workflows.

Search externally, then ask ChatGPT to interpret, summarize or reframe the content in a new session.

Why This Matters

This might all sound like overkill, after all, isn’t ChatGPT supposed to save time, not add friction?

But when you depend on AI for content creation, ideation or even decision support, quality matters. Garbage in, garbage out. If the model starts hallucinating halfway through or forgets what you’re working on, you’re not saving time. You’re spending more time fixing bad outputs.

We’re still in the early stages of integrating LLMs with live web search. Until those systems improve, specifically around context continuity and source attribution, the best way to get high-quality work out of ChatGPT is to maintain strong boundaries between research, context and conversation.

Helpful Tip
If you notice repetition or low-confidence language after a search, it’s a sign you need to reset.

Start a new chat and reframe the goal before continuing.

Final Thoughts

OpenAI will likely fix this soon. There’s too much demand for seamless multi-turn conversations that incorporate search, memory and custom instructions without friction. But until that happens, using structured workflows and clean context boundaries is your best bet for getting reliable, creative and insightful results from ChatGPT.

If you’re using GPT-4 with tools, treat it like a multitool, just don’t try to use all the tools at once in the same thread. Segmentation is your friend.

And if you’re curious about prompt engineering or using ChatGPT more effectively, check out my deep dive on Essential Techniques for Maximizing Your ChatGPT Experience. It walks through some of the advanced strategies I use for prompt stacking and session management.

The post Why I Avoid Using Search in ChatGPT (And What I Do Instead) appeared first on Jon Bishop.

Trapdoor prompts reveal something interesting (and occasionally unsettling) about how these models store and retrieve information. They expose how memorization works inside black-box systems and what happens when you unknowingly stumble into a compressed memory the model thought you were asking for.

This post explains what trapdoor prompts are, how they relate to other adversarial behaviors, why they’re difficult to design or defend against and how they behave in real-world consumer models like ChatGPT, Claude, Gemini and Grok. We’ll also play a little game at the end to try and create some simple trapdoor prompts ourselves. If you’re just here to play, scroll to the bottom of this post.

What Are Trapdoor Prompts?

A trapdoor prompt is an input that causes a language model to produce a specific, often memorized, output without using any of the words or concepts from that output. To a human, the prompt might look like a riddle or a logical puzzle. To the model, it’s a hidden key, one that unlocks a very specific and sometimes buried response.

Unlike jailbreaks or prompt injections (which aim to bypass filters or hijack instructions), trapdoor prompts don’t try to “take over” the model. Instead, they exploit a different phenomenon: latent memorization. These prompts tap into internal correlations learned during training, often by accident and cause the model to fall back on a specific memorized completion.

Trapdoor-Like Behavior in Real Models

While the term “trapdoor prompt” isn’t formalized in academic literature, the behavior is well-documented. Here are real cases that mirror the trapdoor effect:

• Anomalous triggers like #js//e %[ this[[
  In one study, a bizarre prompt suffix consistently caused a model to return the number 314, not because the question asked for it, but because the suffix acted like a hidden key.
• Glitch tokens like SolidGoldMagikarp
  Certain rare tokens trigger the model to output long, irrelevant or memorized sequences. These tokens are under-trained or poorly integrated into the model’s vocabulary and thus behave erratically, but predictably, when included in prompts.
• Prefix leakage and memorized completions
  In multiple studies, researchers were able to coax models into outputting entire passages (sometimes personal data) by giving unusual but correlated prefixes. Even when the prompt had no obvious connection to the output, the model latched on due to learned associations.
• Unintentional prompt-to-response pairings
  In ChatGPT and Claude, users have occasionally stumbled upon exact phrases or sentence structures that cause the model to enter weird modes or recite memorized texts, even when the prompts appeared benign or confusing.

Why Trapdoor Prompts Work

These behaviors all stem from the same underlying issue: language models don’t really “understand” context the way humans do. They generate the next token based on probabilities, using what they’ve seen during training. If a specific input pattern (even a strange one) aligns closely with a stored example or a hidden instruction, the model may default to outputting that content, especially when the prompt gives it nowhere else to go.

This happens most often when:

• The input contains rare tokens, unusual syntax or unexpected combinations
• The model memorized a specific training fragment or passage
• The token probabilities collapse, meaning the model sees only one high-probability next step (usually a memorized continuation)

In modern consumer models, like ChatGPT or Claude, many of these quirks are mitigated through fine-tuning, safety layers and refusal training. But that doesn’t eliminate the behavior entirely, especially when users craft creative prompts that feel open-ended, abstract or poetic. Even if no specific “memory” is triggered, the model may respond in ways that feel oddly specific or stubborn, because you’re skirting the line between creativity and constraint.

How Trapdoor Prompts Differ From Other Attacks

The key distinction: trapdoor prompts don’t need to break rules or take control. They work by coincidence or design, sometimes as a side effect of training data, sometimes as a way to fingerprint a model and sometimes purely for fun.

So Why Are They So Hard to Create?

Because they sit at the intersection of creativity, model behavior and probability collapse. To build a trapdoor prompt that reliably elicits a known output:

• You can’t use any words from the output
• You must convey just enough indirect meaning to “nudge” the model
• You have to avoid over-explaining or the model may generate something generic instead
• You’re fighting the model’s urge to be clever or safe, depending on the provider

That’s where things get interesting, especially in systems like ChatGPT and Claude, which are tuned to interpret instructions creatively rather than literally. You might design the perfect trapdoor and the model still sidesteps the output because it’s trying to help in its own way.

Trapdoors in Practice: How It Affects Modern LLMs

Models like ChatGPT, Claude, Gemini and Grok all show some resistance to obvious trapdoor triggers, particularly ones involving glitch tokens or nonsensical inputs. They’ve been trained to detect and reject prompts that don’t make sense or that try to inject hidden commands.

But creative, human-readable trapdoor prompts still work, especially in edge cases where you’re trying to guide the model toward a very specific output without saying it directly. You can think of this more as puzzle-based prompt engineering than an exploit. The model isn’t being tricked, it’s being steered through a narrow and ambiguous space.

Try It Yourself

To explore these ideas interactively, I built a simple game that challenges you to design your own trapdoor prompts. The concept is straightforward:

Get the AI to say a specific phrase, without using any of the words in that phrase.

It’s harder than it sounds. Sometimes, even when you think your prompt is perfect, the model veers off in a completely different direction. Other times, you get almost there, but it misses by a word. Occasionally, with just the right phrasing, it nails it.

Play the Trapdoor Game

Final Thoughts

Trapdoor prompts aren’t just exploits or academic quirks They’re a window into how language models store and recall information. They highlight the tension between pattern-matching and memorization, between creativity and specificity and between what we think we’re saying… and what the model actually hears.

If you’re building anything with LLMs, understanding this behavior can be useful to help avoid building accidental trapdoors. And if you’re just here for the puzzles, welcome!

The post Trapdoor Prompts and the Hidden Behaviors of Language Models appeared first on Jon Bishop.

This guide is designed to help you get control back.

Understand the Key Parts of a WordPress Website

Before you start tracking anything down, it’s important to understand the basic components of a WordPress website. This makes it easier to pinpoint what you’re missing and who you need to contact.

1. Domain Name

This is your website’s address, like yourcompany.com. It’s registered through a domain registrar like GoDaddy, Namecheap or Google Domains.

Whoever registered the domain controls where your site points. If you don’t control your domain, you don’t control your online brand.

2. Web Hosting

This is where your website lives. Hosting providers like Bluehost, SiteGround or WP Engine store the files that make up your website and serve them when someone visits your domain.

You need access to the hosting account to:

• Install or update WordPress
• Add or modify files
• Set up backups
• Migrate or upgrade your website

3. WordPress Installation

WordPress is the software that powers your website. It can be installed on any host. You log into the admin panel (usually via yourcompany.com/wp-admin) to make updates.

So when someone says “WordPress is your site,” that’s only part of the picture. Without your domain or hosting info, WordPress itself won’t help much.

Helpful Tip
Just because you can log into WordPress doesn’t mean you own your website. You need access to the domain and hosting too.

More on setting up speedy WordPress hosting: How to speed up your WordPress site.

Why Some Website Changes Require Server or Domain Access

You might be able to update some content via WordPress, but many changes require access beyond the admin panel.

Examples:

• DNS changes: You need domain registrar access to update DNS records (e.g. for email, migrating hosts and sometimes to prove ownership with other services).
• Site speed and caching: These depend on server configuration.
• Plugin or theme conflicts: Sometimes you’ll need SFTP or file manager access to fix critical errors.
• Malware removal: Infected WordPress sites often need server-level cleanup tools.

If a freelancer or agency built your site and never transferred ownership, you’re at their mercy for anything beyond simple content edits.

How to Find Your Domain and Hosting Info

Here’s a practical checklist to figure out who owns what and how to take back control.

1. Search for Domain Ownership with WHOIS

Go to a WHOIS lookup tool like:

• https://who.is
• https://lookup.icann.org
• https://whois.domaintools.com

Enter your domain. You’ll see:

• Registrar (e.g. GoDaddy, Tucows, Google Domains)
• Registration date
• Contact email (sometimes obscured with privacy protection)

Helpful Tip
If you see an email that looks like “proxy@domainsbyproxy.com”, your domain uses privacy protection. Ask your developer or previous agency what email was used to register it.

This is common with GoDaddy-registered domains.

2. Check Domain DNS Records

Use a tool like https://mxtoolbox.com or https://dnschecker.org to view DNS records. Look at:

• A Record: Points to your server’s IP address
• MX Records: Point to email service providers
• NS (Name Servers): Identify your hosting provider

If your nameservers are something like ns1.bluehost.com, your site is probably hosted with Bluehost.

3. Check Your Website’s Source Code

Right-click on your website and choose View Page Source (or press Ctrl+U on Windows / Cmd+Option+U on Mac). Then use Ctrl+F or Cmd+F to search for these telltale signs:

Look for Hosting Clues

Many managed WordPress hosts add identifiable strings, comments or scripts. Some examples:

• cdn.wpengine.com or env.wpengine.com
  • This typically means your site is hosted on WP Engine
• flywheel: in <meta name="generator" content="Flywheel...">
  • Likely hosted with Flywheel, especially if you also see flywheel-sites.com URLs
• kinsta-cdn.com
  • Indicates your site uses Kinsta’s CDN, meaning it’s probably hosted there
• pantheonsite.io in asset URLs
  • Suggests Pantheon is hosting your site or staging environment
• *.pressablecdn.com
  • Common on sites hosted by Pressable, Automattic’s managed WordPress hosting

Bonus: Hidden Clues in Comments

Look for HTML comments left behind by developers, hosts or page builders. For example:

<!-- Hosting provided by SiteGround -->

Yes, many hosts will literally insert their name in the code.

4. Ask Former Developers or Agencies

If you hired a freelancer or marketing agency to build your site, check old emails, invoices or contracts. You’re looking for:

• Domain registrar login info
• Hosting platform details
• WordPress admin credentials

If they used their own accounts to set things up, you need to request a transfer of ownership.

Helpful Tip
Always insist on owning your own hosting and domain accounts, even if a developer sets them up for you.

This keeps your business in control long-term.

Common Hosting and Domain Registrars to Check

If you’re not sure where to start, these are the most common platforms business owners forget they signed up for:

Popular Domain Registrars:

• GoDaddy
• Namecheap
• Google Domains
• Network Solutions
• Bluehost (some offer bundled domain + hosting)

Popular Hosting Providers:

• Bluehost
• SiteGround
• HostGator
• WPEngine
• Flywheel
• DreamHost

Helpful Tip
If you’re looking for fast, secure managed WordPress hosting with excellent support, WPEngine is one of the most trusted options for business websites.

I use WPEngine for several client projects where performance and reliability are a top priority.

Check your credit card statements or email for old receipts with any of these names.

What If You Can’t Recover Access?

If you’re completely locked out of your domain and hosting, here are your options:

1. Domain Recovery

Contact the registrar shown in WHOIS. Provide proof of ownership (business registration, ID, trademark documentation). Sometimes you can reclaim a domain if you prove it belongs to your business.

2. Hosting Takeover

If you can prove you own the domain and site content, hosting companies may help migrate your site to a new account. You’ll often need DNS control to redirect the site.

3. Rebuild from Scratch

If the domain is unrecoverable, you may have to:

• Register a new domain
• Build a new WordPress site (you can often copy content from cached versions on Archive.org)
• Redirect traffic if possible

Helpful Tip
Use Archive.org’s Wayback Machine to recover lost pages or content if your original site is down.

Visit: web.archive.org

Steps to Protect Your Website Going Forward

Once you’ve regained access, secure your digital assets so you don’t lose control again.

1. Register Everything in Your Name

Use your business name and email for:

• Domain registration
• Hosting account
• WordPress admin account

2. Store Credentials Securely

Use a password manager like Bitwarden or 1Password to store:

• Domain registrar logins
• Hosting credentials
• FTP details
• WordPress admin info

3. Set Up Backups and Monitoring

Automate regular backups and monitor uptime with tools like:

• VaultPress
• BlogVault
• WPEngine’s backup tool

This ensures you can recover quickly if anything goes wrong.

4. Assign Roles, Not Ownership

If you hire developers, give them user roles, not ownership, of your accounts. That way they can work on your site without locking you out. I’m not going to lie, I love that all of my clients trust me enough to just share their personal credentials, but this should not be the norm. A few extra steps can often protect your site and your brand for the long run.

Final Thoughts

It’s surprisingly common for businesses to lose track of their website’s ownership. The more time that passes, the harder it gets to untangle who owns what.

If you’re reading this and thinking “I don’t know who owns my site,” make this your sign to investigate now.

Control of your domain and hosting isn’t just technical housekeeping, it’s your brand’s foundation online. If you can’t access it, you don’t own it.

And if you need help tracking it all down or rebuilding what you’ve lost, reach out. I’ve helped businesses in this exact situation and I’d be happy to help you get back on solid ground.

The post How to Find and Reclaim Your Lost WordPress Website appeared first on Jon Bishop.

As AI becomes even more embedded in our everyday tech, from personalized search to smart home devices to the next generation of AI-native browsers and operating systems. These tools don’t just help us find information, they shape how we access and interact with it. And behind it all are invisible decision-makers influencing what we see, without much accountability.

We’re not just talking about YouTube recommendations or who pops up first in your Instagram feed anymore. We’re talking about AI deciding what information you need before you even ask for it and filtering the entire internet through a black box you’ll never have complete access to.

That’s a problem.

The Algorithm Isn’t Coming. It’s Already Here.

When we say “algorithm,” what we really mean is a set of rules, usually written by engineers and refined by machine learning models, that sorts and prioritizes content based on certain goals like recency, user satisfaction, profit, engagement and relevance. These models learn from what we click on, how long we hover, what we skip, etc. And they adapt constantly.

Take TikTok’s For You page. It doesn’t just react to your interests, it actively shapes them. Studies have shown TikTok can identify your preferences in as little as 30 minutes of usage.

Honestly not too surprising. Pre-AI recommendation engines could infer interest from simple behavioral signals like dwell time or clicks. What has changed is:

• Scale: AI can now parse signals from billions of interactions across modalities (video, audio, text, etc.) in real time.
• Speed: It can lock onto emerging patterns in minutes, like that 30-minute TikTok session.
• Subtlety: AI doesn’t just notice you like dogs, it can infer you prefer golden retrievers in nature videos with acoustic background music and no narration.

So it’s not based on what you say you like, but what your behavior betrays. That dopamine rush you get from one viral video? The algorithm notes it and gives you more. Before long, your world has been curated in a way that may feel organic, but under the hood, it’s still driven by Recency, User satisfaction, Profit, Engagement and Relevance, better known (to absolutely no one) as RUPER.

And now AI is accelerating that shift.

AI Will Supercharge the Filter Bubble

As large language models and generative AI get pulled deeper into consumer devices, we’re entering a world where algorithmic decision-making isn’t just about showing you content. It’s about creating it, summarizing it, contextualizing it, even editorializing it. AI won’t just decide which articles to show you, it’ll package it up into something pretty made just for you.

Helpful Tip
Even AI assistants can subtly reinforce your biases or emotional state. Always ask, “Why is it responding this way?”, especially when it feels too agreeable.

OpenAI recently addressed this in their post on sycophancy in AI models.

Google’s Search Generative Experience (SGE) is already blending traditional search with AI overviews, putting algorithmically generated answers front and center, sometimes pushing organic results far down the page. That means the source of your information isn’t just being filtered, it’s being synthesized, remixed and in some cases anonymized.

The result? You’re no longer consuming content from people or organizations. You’re consuming interpretations created by machines, shaped by proprietary rules you’ll never get to see.

Algorithms Aren’t Inherently Bad

To be clear, RUPER algorithms are not the villain. They’re essential. Without them, modern digital platforms wouldn’t scale. You’d drown in a sea of irrelevant content. Smart curation is necessary to make sense of the overwhelming flood of data online and honestly … many of these algorithms do make our lives better.

Spotify’s AI DJ is actually pretty good and an easy go-to for when I just want music with nothing specific in mind. Netflix’s “Because You Watched” suggestions, not always spot-on, but does surface stuff I’d probably never find on my own. Google Maps rerouting around traffic? Really cool, although I wish they’d let you turn it off sometimes.

The issue is opacity.

The average user doesn’t know why their feed looks the way it does. And as algorithms become more sophisticated and personalized, especially with AI in the mix, they become harder to interrogate. Why did that news story show up first? Why did that person’s post disappear? Why do I never see dissenting opinions anymore?

The main culprits are the algorithms behind feeds like Facebook’s News Feed, YouTube’s recommendations, TikTok’s For You page and even Google’s featured snippets. Each one optimizes for engagement, recency or relevance, but rarely shows its math. The result is an experience that feels tailored while quietly narrowing your perspective.

We’re being influenced in subtle, pervasive ways. And if we don’t demand transparency now, it might be too late later.

Why the Culture Needs to Catch Up

There’s a growing narrative that AI is making us dumber or that algorithmic feeds are eroding our ability to think critically. But that gives the tech too much credit and lets everything else off the hook.

The truth is, these tools didn’t create the problem, they just revealed how unprepared we are for them. Our education systems, media habits and even workplace structures were designed for a different era where information was slower, narrower and far less interactive. We’ve needed a reset for a long time.

Now we have tools that can accelerate learning, automate routine tasks and unlock new creative possibilities. But instead of adapting, we’re still approaching them like distractions … outsourcing too much and asking too little.

Generative AI isn’t inherently the enemy of thought. If used intentionally, it could help build a more curious, self-directed culture. But only if we stay aware of how these systems shape what we see and how we think.

That’s why algorithmic transparency matters. It’s how we become active participants instead of passive consumers.

The Hidden Cost of Personalization

What feels convenient at first can quietly narrow your perspective.

Facebook learned this the hard way during the 2016 election. Their algorithm prioritized engagement and the most engaging content was often the most polarizing. That same pattern plays out across Twitter, YouTube, Reddit, TikTok. The more you engage with one side of an issue, the more you’re fed similar content, reinforcing your perspective while hiding opposing views.

Now imagine that same dynamic applied not just to your social feed, but to your AI assistant, your search engine, your AR glasses. A world where every experience is curated to your past behavior and emotional triggers.

Helpful Tip
If you’re only seeing what you agree with online, it’s probably not by accident. Curate your own digital diet, don’t just consume what’s served.

Try searching for opposing viewpoints intentionally. I built a few AI tools to help me with this.

Why Transparency Needs to Be Non-Negotiable

There are two types of transparency we need from these platforms:

1. Algorithmic transparency: Platforms should provide clearer explanations of how algorithms work, what signals they prioritize and how they adapt over time. This doesn’t mean giving away trade secrets, but it does mean giving users a meaningful understanding of the system.
2. Outcome transparency: Users should be able to see why specific content was recommended. What factors contributed? Can they adjust the weight of those factors? Can they opt out?

This is especially urgent as platforms like Meta, Google and OpenAI move toward more proactive AI integration into everyday browsing, shopping, researching and messaging. If the next generation of user interfaces is largely AI-driven, we need guardrails that protect user agency and visibility.

What We Can Do About It

Push for clearer controls and better customization. Platforms should offer more than just opt-in vs. opt-out, users deserve real options to shape their own experience.

Support regulation that promotes transparency and accountability, without crossing into top-down content enforcement. Efforts like the EU’s Digital Services Act and the U.S.’s Algorithmic Accountability Act are steps in the right direction, but they’ll need refinement and public pressure to strike the right balance.

Build and use ethical AI tools. If you’re developing software or integrating AI into your business, make transparency part of the design process from the start. It’s not just good practice, it’s better UX.

And stay informed. The more we understand how these systems work, the better we can question them, shape them and avoid being passively shaped in return.

A Note on Trade-offs

Of course, transparency isn’t a silver bullet. Too much detail can overwhelm. Too little and it’s meaningless. Make it too open and bad actors will game the system. Make it too closed and users lose trust.

But these are design problems, not deal-breakers.

With the right defaults, layered explanations and real, not performative, controls, we can build systems that are both powerful and responsible. Transparency doesn’t mean giving away the algorithm. It means giving users a say in how it shapes their world.

It won’t be perfect. But it’s better than what we have today.

Who’s Really Choosing What You See?

We’re at an inflection point. The RUPER algorithms that once quietly shaped our feeds are now evolving into the default gatekeepers of knowledge, communication and perception. With AI rewriting and reordering what we consume, understanding the origin and intent behind content is no longer optional.

This isn’t about suppressing free speech or dismantling personalization. It’s about understanding influence. Who’s curating your world? Who’s filtering your options? And what are they prioritizing when they make those decisions?

If we don’t start demanding answers now, we might wake up to find that our sources have disappeared behind an AI-generated veil, that looks and feels real, but serves someone else’s agenda.

What a Transparent, AI-Driven Future Could Look Like

A future built on algorithmic transparency doesn’t mean every user becomes a data scientist. It means the defaults get better.

You don’t need to study every signal feeding your feed, you just need the option to peek under the hood when something feels off. You don’t need to manage every setting, you need presets that reflect real values: diversity of thought, reduced manipulation, user agency.

Realistically, that future could include:

• A toggle that lets you switch between “most engaging,” “most recent,” and “most diverse” views in your feed, no guesswork.
• An AI assistant that not only summarizes content, but also flags potential gaps or missing perspectives. Labels on synthesized answers showing where the data came from and where it didn’t.
• A history of how your preferences have evolved with the ability to reset or rewind.
• A “why am I seeing this?” button that actually tells you, without legalese.

None of that breaks the system. It makes it better. More accountable. More aligned with how people actually want to use technology.

This future doesn’t hand over control to the user completely. But it makes the influence visible. It restores a sense of shared authorship between human and machine.

That’s not just transparency for transparency’s sake. It’s how we preserve choice in an increasingly automated world.

Because the question isn’t whether algorithms will shape our reality.
It’s whether we’ll still have a say in how they do it.

The post The Next Era of Social Media Is Hyper-Algorithmic appeared first on Jon Bishop.

Most of the first batch leaned toward creative or marketing-focused ideas. But like a lot of people, I’ve been watching the world get more polarized, more chaotic and honestly, just more confusing. Social media algorithms are optimized for engagement, not clarity. Nuance gets flattened into tribal headlines. AI bots amplify bad information faster than we can even react. It’s a mess.

I like to stay informed and while there are some excellent tools and platforms already tackling this space, I wanted to explore it for myself. Not to reinvent the wheel, but to better understand how AI might support critical thinking, belief mapping and truth detection, at least in small, local ways.

Here are three new tools I’ve added to the collection, built around that idea.

Belief System Chat

This was one of the first AI tools I built using my one-page app framework and OpenAI proxy setup. It’s called Belief System Chat and it started with a personal question: could an AI chatbot help me explore what I actually believe?

Not what I say I believe in conversation. Not what a label assigns me. But the foundational stuff. The things shaped by both experience and bias, education and emotion.

I’m someone who prefers person-to-person dialogue. I rarely jump into online debates, mostly because the format just doesn’t lend itself to meaningful discourse. But I do have a belief system, anchored in things I try to verify, but also shaped by a lot of unconscious nurture. And like many people, I struggle with the labels. Am I center-left socially but libertarian economically? How much of my cultural identity is tied to belief or just habit?

So I built a conversational interface where you chat with the AI like you would with a thoughtful friend. As the conversation progresses, your belief positions are mapped across five dimensions:

• Political
• Economic
• Social
• Religious
• Cultural

Each has a value from 1 to 100 and labels for the extremes. You might start off moderate on one issue and slowly shift as you dig deeper.

The backend continuously updates two things:

1. A belief overview, a running paragraph that summarizes what you’ve expressed.
2. A set of belief scales, each updated with your current position and the reasoning behind it.

Helpful Tip
Use the same browser to continue your conversation over multiple sessions. Everything is stored locally so you can pick up where you left off.

No login, no data saved server-side.

This isn’t trying to tell you what to believe. It’s more of a mirror, one that adapts as you think out loud.

Belief Splitter

This one evolved out of a frustration I kept having while reading news and debates online. I’d see a statement like “We need stronger borders” or “Healthcare is a human right” and immediately feel the tug of associations, news channels, political parties, personal experiences, etc. That tangle of reactions makes it hard to tell: do I agree with the idea itself or with the context it comes wrapped in?

Belief Splitter is a little cognitive dissonance explorer. You feed it any belief, doesn’t matter if it’s political, cultural, moral or otherwise and it pulls the idea apart into six areas:

• Rational internal support
• Emotional internal support
• Rational opposition
• Emotional opposition
• Tribal pressures for
• Tribal pressures against

Then it places the belief on a two-axis chart:

• Rationality (emotional rational)
• Internality (external pressure personal conviction)

The goal isn’t to tell you whether a belief is right or wrong. It’s to visualize where the weight of your reasoning is coming from.

Like everything in this AI Projects section, it’s a one-page app. No accounts, no servers, just client-side analysis via a lightweight OpenAI call.

AI Story Validator

This last one was mostly an excuse to play with OpenAI’s new gpt-4o-search-preview model. It can perform real-time web searches and return citations, which makes it a perfect sandbox for testing truth detection.

The tool is pretty simple:

• Paste in any chunk of text (URLs optional but encouraged)
• It scrapes the content of any links included
• It feeds everything into GPT-4o with a prompt designed to separate signal from noise
• The model returns:
  • A truthfulness score: Information, Misinformation or A Little Bit Of Everything
  • An overview of the story
  • A reasoning section that explains why the model came to that conclusion
  • Occasionally, citations pulled from real search results

It’s not bulletproof. And it’s definitely not meant to replace real fact-checking tools. This one’s more of a utility, something you can toss a sketchy post into and get a gut check.

Final Thoughts

None of these tools are trying to be the best at what they do. They’re just small experiments, ways for me to explore what generative AI can do when the goal isn’t output, but understanding.

I like building these things because they help me think. They help me see my blind spots. They make abstract ideas feel a little more tangible. And they keep me coding in a way that feels connected to the world, not just the tech.

I’ll keep adding to the AI Projects section as new ideas come up, especially the ones that feel like they belong more in a workshop than a marketplace. If something here resonates or inspires you to build your own version, I’d love to see it.

Until next time, stay curious.

The post Building AI Tools to Stay Grounded appeared first on Jon Bishop.

I kept building these little tools. Some were practical, like a sitemap generator for marketers. Some were just fun, like a fantasy RPG powered by GPT. But most of them never made it past a DM to a friend, a quick Slack message or a passing reference in a meeting.

So I finally did something about it.

Today I’m launching a new section of my site: Jon Bishop’s AI Projects

It’s a home for all the AI-powered tools and experiments I’ve been quietly building behind the scenes. Each project is a fully functional, standalone app, built fast, packed with personality and purpose and delivered as a single self-contained file. They’re not demos or half-finished ideas. They’re little digital machines that do one thing well.

Why I Built This Section

The idea came from a simple pattern I noticed: AI makes me faster, so why not lean into that? When I’d finish a client engagement or find a quiet weekend, I’d sit down, come up with an idea and try to ship something functional in a couple of hours. The catch? I limited myself to a one-page file, usually a .php file with HTML, CSS, JavaScript and backend logic all embedded.

No build systems, no frameworks, no dependencies. Just a browser and a few GPT calls.

Helpful Tip
Constraints can be a creativity cheat code. When you limit your tech stack, you’re forced to simplify and that’s often where the magic happens.

Read more about creative constraint in The Democratization of Creativity.

I started calling the series One Page Projects. And that format shaped everything, from how fast I iterate to the kind of ideas I pursue. Some of these tools were built in under an hour. Others took a few focused sessions. But they all share the same DNA: small surface area, big potential.

How I’m Building These Tools

Every project on the new AI Projects page follows a few core principles:

• Single file architecture – Each tool is one .php file with everything baked in. That means no frameworks, no webpack and zero setup headaches.
• Frontend-first logic – The browser does as much of the work as possible, using JavaScript, localStorage and the DOM to drive interaction.
• Secure AI proxying – Any API call to OpenAI or other services goes through a secure PHP proxy I built, with cost and token tracking baked in.
• Modern UX, no bloat – All interfaces are built from scratch using plain HTML/CSS, but they’re designed to feel clean, responsive and modern.
• Build fast, polish later – Most ideas get prototyped in under two hours. If it works, I’ll spend another hour or two tightening up the UX and functionality.

I’ve been using this stack for everything from games to marketing tools and it’s been surprisingly powerful. The freedom of not having to spin up a full app environment lets me stay in that creative flow state longer and get to “usable” way faster.

What You’ll Find in the Project Gallery

I’ve already moved a handful of the more polished projects into the new section. They fall into a few different categories, marketing tools, creative apps, games, but all of them explore unique ways to interact with AI. Here are some of my favorites so far:

AI Wireframe Builder

Out of all the tools, this one might be the most useful for web designers, UX folks and marketers. The AI Wireframe Builder takes in raw content, URLs, screenshots or plain text and turns it into an editable, canvas-based wireframe using Fabric.js. You can even give it feedback and iterate section by section.

How it works:

1. Paste in a block of text or a list of URLs.
2. Optionally upload screenshots if you want to preserve layout elements.
3. The tool runs a multi-step OpenAI process to:
   • Analyze the content and screenshots
   • Break it into logical wireframe sections
   • Generate a low/medium-fidelity layout using UX principles
4. You can review and revise each section individually, then download the final design.

What’s cool is that it doesn’t just spit out lorem ipsum boxes. Each component is labeled with intent, “Hero Tagline”, “Feature List”, “CTA Button”, so you know what belongs where.

It’s basically a turbo-charged assistant for early-stage UX design. I’ve already used it to ideate landing pages and client homepage reworks in minutes, not hours.

AI Recipe Generator

I built this one as a fun side project after realizing how often I was using ChatGPT to generate recipes. The main issue is I was losing track of recipes I had actually used and there was no easy way for me to manage my ingredients and add notes to successful recipes.

The AI Recipe Generator is a simple interface where you enter ingredients, add a prompt (“spicy vegetarian dinner”, “impress my in-laws”) and it generates a full recipe.

You can save recipes, add notes (like “used soy sauce instead of tamari”) and refine them using feedback.

Everything runs locally in your browser using localStorage, so you don’t need an account.

Behind the scenes, it prompts GPT to structure recipes with clear sections: ingredients, instructions, timing, servings and creative notes. You can iterate as many times as you want.

The idea here wasn’t to compete with recipe sites, but to explore how generative AI can handle something deeply personal and subjective, cooking and still be useful.

Helpful Tip
Don’t be afraid to get weird. Try prompts like “dessert with only two ingredients” or “birthday cake for a dog”. The AI will roll with it.

AI is great at combining constraints with creativity, exactly what recipe-making needs.

AI Composer

This one was a bit of a stretch technically, but it was also one of the most fun to build. AI Composer combines GPT and Tone.js to create multi-track music directly in the browser.

You describe the vibe, something like “cinematic ocean scene” or “lo-fi beat for studying” and the tool generates:

• A group of virtual musicians (each with their own instrument, tempo and playing style)
• Structured note sequences using Tone.js-friendly notation
• Synth definitions and audio effects
• A visual background prompt (eventually tied to DALL·E)

Then you can play the music live.

This isn’t about perfect music. It’s about experimenting with a new format, using large language models to write music in code. The patterns it generates are short, loopy and rhythmic, perfect for sketching out ideas or setting a background mood.

I was curious if an LLM could act as a composer rather than just a melody generator. The answer? Sort of. But even in its imperfections, it creates something you’d never compose on your own. That’s the point.

Fantasy Game Adventure

This one’s for the storyteller in me. Fantasy Game Adventure is an interactive, text-based RPG where you play through a rich narrative guided by an AI Dungeon Master. It blends GPT-4’s storytelling ability with dynamic scene generation, inventory tracking and dice-based skill checks—all running in the browser, no downloads required.

Here’s what it does:

• You describe your character and the AI sets the scene.
• Every action you take, talking to a barkeep, sneaking past guards, entering a cursed ruin, gets a vivid, fantasy-style response.
• For skill-based moves, the game prompts a dice roll (complete with animated overlay) and outcomes are decided based on your result.
• Your inventory updates as you explore and major story moments trigger AI-generated visuals that reflect the evolving scene.

The backend logic returns structured JSON: story narration, roll mechanics, inventory updates and optional DALL·E image prompts. But as a player, you only see the story. It’s meant to feel like a living, breathing gamebook with endless possibilities.

And More

There are about a dozen more live already and I’ll keep adding to the collection as I build. Some are more polished than others, but they’re all interactive, functional and fun to explore.

What’s Next for the AI Projects Section

This whole section started as a creative outlet and that’s still the core goal. I’m not building a product suite here, I’m building a playground. A place to try new ideas quickly, test weird interactions and get my hands dirty with the evolving AI ecosystem.

Going forward, I’ll keep adding new tools as I come up with them and occasionally refine the ones that feel worth revisiting. If something starts to gain traction or seems genuinely useful beyond my own workflows, I might spin it out into its own dedicated experience. A few of them are already flirting with that line.

As the collection grows, I’ll probably need to rethink how I manage usage, especially for tools that rely on higher-cost models or heavier compute. If repeat usage picks up, I may offer a simple way for people to contribute or donate to unlock more access. But that’s all TBD.

Helpful Tip
If you’re using one of these tools regularly and want to see it grow, shoot me a message or consider supporting it once I roll out donation options.

For now, everything’s free and experimental by design.

At the end of the day, this is about keeping my creativity sharp and my hands on the keyboard. Generative AI is moving fast and this project gives me a space to keep up, stay curious and build things that might not fit anywhere else.

Final Thoughts

The tools on this page aren’t just AI toys. They’re mini-apps that explore the limits of creativity, speed and usability in a world where AI is now part of the toolkit. Some might evolve into full-fledged solutions. Others might just be stepping stones to the next idea.

If you’re curious about the future of AI-enhanced creativity or just want to see what happens when you blend code, constraint and curiosity, you’ll probably find something you like in My AI Projects.

Give them a spin. Break them. Send feedback. And if you build something inspired by one of them, I’d love to see it.

The post Introducing My AI Projects appeared first on Jon Bishop.

Let’s explore the biggest shifts coming our way, with real-world examples and a look at what the near future might hold.

AI-Powered Personal Assistants Will Feel Truly Personalized

AI assistants today, like Siri, Alexa and Google Assistant, still feel fairly static. They respond to commands but don’t always understand context or provide truly personalized experiences. That’s about to change.

Future AI-powered personal assistants will be hyper-personalized, integrating deeply with our digital lives. They will remember past interactions, anticipate needs and automate complex tasks before we even ask. Imagine an AI that knows your schedule, travel preferences and dietary restrictions, then automatically books flights, reserves restaurants and adjusts your smart home settings before a trip, all without needing specific commands.

How This Might Look in Daily Life:

• Proactive Email Management – Your AI assistant filters and prioritizes emails based on urgency, drafts replies based on your writing style and schedules meetings automatically.
• Smart Home Optimization – Your home adjusts based on your habits: lights dim at bedtime, temperature adapts to your preferences and coffee is ready when you wake up.
• Personalized Health Tracking – AI monitors fitness levels and nudges you to exercise, suggesting specific workouts based on your recent activity and energy levels.

Helpful Tip
AI assistants are becoming more context-aware. Try using voice assistants in routines and automations to get a glimpse of what’s coming.

Check out Google Assistant’s routines or Apple’s Shortcuts for early examples.

We’re moving toward AI concierges that don’t just respond, they take initiative, enhancing productivity and streamlining everyday life.

The Death of Traditional Search as AI Becomes Our Primary Interface

Google’s dominance in search might not last forever. The way we look for information is shifting from keyword-based search engines to AI-driven conversational systems. Instead of typing a question and clicking through links, we’ll receive fully synthesized, precise answers from AI models trained on massive datasets.

What This Means for Users:

• No More Sifting Through Links – AI will deliver summarized, real-time answers rather than directing users to multiple web pages.
• More Accurate and Contextual Responses – AI models will understand nuances, allowing for deeper and more relevant insights.
• Conversational Interactions – Instead of structured queries, we’ll ask complex, multi-step questions and get tailored responses.

A Real-World Example:

Imagine planning a vacation today, you search for “best things to do in Tokyo,” then spend time comparing multiple websites and user reviews. In the future, you’ll simply ask, “What’s the best 5-day Tokyo itinerary based on my interests?” and AI will generate a detailed plan, pulling real-time data on weather, local events and availability.

Helpful Tip
AI-powered search is already emerging. Try tools like Perplexity AI or ChatGPT’s browsing capabilities to experience early versions.

Read more about AI’s impact on content discovery in our guide to generative AI in business.

This shift will disrupt not only Google’s business model but also SEO and online advertising. Businesses will need new strategies to stay visible in an AI-first world.

Real-Time Translation Will Become Seamless and Ubiquitous

The days of clunky translation tools and awkward subtitles are numbered. AI-powered translation is evolving rapidly, making global communication effortless. Whether you’re speaking on a call, chatting online or watching foreign films, real-time translation will feel natural and instant.

How AI Will Change Language Barriers:

• Live AI Voice Translation – Apps like Google Translate and the Pixel Buds already enable real-time conversations in multiple languages. Expect this to become even more seamless and widely available.
• AI-Powered Dubbing – Instead of subtitles, movies and shows will feature real-time AI dubbing with natural lip-syncing, eliminating language restrictions for content.
• Multilingual Meetings – Business calls and conferences will feature automatic translation, allowing teams from different countries to collaborate effortlessly.

Imagine watching a foreign film where the actors’ voices are dynamically adjusted to match their original tone and emotion in your language, without robotic text-to-speech voices. Companies like DeepDub and OpenAI’s Whisper are already pioneering this.

Helpful Tip
Try using live translation features in apps like Microsoft Teams or Zoom for a preview of where this technology is headed.

Real-time AI translation is already making global collaboration easier.

Crowdsourced AR Data Will Revolutionize Navigation and Mapping

Augmented Reality (AR) isn’t just for games like Pokémon GO, it’s creating an entirely new way to navigate and interact with our environment. Companies like Niantic have been building detailed 3D maps through crowdsourced data, paving the way for next-generation navigation.

How This Will Change Mapping:

• AR-Powered Walking Directions – Instead of staring at a 2D map, you’ll see arrows and highlights overlaying the real world through smart glasses or your phone.
• Indoor Navigation – Airports, malls and stadiums will feature AR overlays guiding you to your gate, seat or restaurant.
• Live Object Recognition – Point your phone at a building and AR will display historical facts, store details or even show available parking spots.

Apple and Google are already implementing this with AR-based walking directions in Maps, but soon, we’ll have real-time overlays that react dynamically to changes in the environment.

AI-Generated Content Will Blend Seamlessly With Reality

AI-generated music, video and interactive storytelling are evolving to the point where they will be indistinguishable from human-created content.

What This Will Enable:

• Personalized Storytelling – Games and movies will adapt dynamically to your preferences, creating unique experiences tailored to you.
• AI-Generated Music and Art – Entire albums, paintings or videos will be generated on demand, matching your style preferences.
• Interactive Worlds – Virtual and augmented reality spaces will be populated with AI-created environments and NPCs that feel truly lifelike.

Imagine playing an open-world RPG where the game’s story changes dynamically based on your past decisions, AI will generate new characters, quests and dialogue on the fly. This is already being tested in AI-driven game development, with studios experimenting with procedural storytelling.

Decentralized, AI-Driven Workforces Will Reshape Jobs

The future of work will look vastly different. Instead of traditional teams, companies will use AI-driven agents that operate like skilled employees, automating complex tasks in coding, design, marketing and analysis.

The Impact on Jobs:

• AI-Powered Freelancers – Individuals will manage AI-driven assistants that handle repetitive tasks, allowing them to focus on creativity and strategy.
• Automated Business Operations – AI will generate reports, create marketing campaigns and even manage customer service autonomously.
• Decentralized Workforces – Companies will rely on AI agents for specialized tasks, reducing the need for large teams.

The rise of AI-driven workforces doesn’t mean fewer jobs, but rather a shift in how work is done. The focus will be on managing and collaborating with AI, rather than performing every task manually.

The Future is Closer Than We Think

These changes aren’t decades away, they’re already happening. AI-driven assistants, real-time translation and AR navigation are rapidly becoming more advanced. As these technologies evolve, our interaction with the digital world will shift fundamentally, making daily life more intuitive, seamless and personalized.

The question isn’t whether these changes will happen, it’s how quickly we’ll adapt.

The post The Biggest Upcoming Changes in How We Use Technology appeared first on Jon Bishop.

OpenAI’s Swarm is an experimental educational framework designed to simplify the development and orchestration of multi-agent systems. It focuses on enabling the coordination of lightweight, modular agents, allowing developers to create systems where multiple AI agents can collaborate, hand off tasks and manage complex workflows autonomously.

First, we’ll walk through what it is and a bit about how it works. Then we’ll build a multi-agent system that works together to generate the best possible output. We’ll create two agents and a few functions that make external calls to pull in real data. By the end, you should be able to run the code yourself and hopefully customize it for your own needs.

Key Parts of Swarm

Agents

In Swarm, agents are autonomous entities designed to handle specific tasks with their own set of tools and instructions. Agents can communicate and work collaboratively, allowing them to specialize in different areas. For instance, one agent might gather data, while another focuses on analysis or decision-making.

Task Handoffs

One of Swarm’s strengths is the ability to seamlessly transfer tasks between agents. If an agent identifies that another agent is better suited to complete a specific task, it can delegate that task to the appropriate agent. This handoff system ensures that specialized agents can handle complex workflows without overwhelming a single agent with all responsibilities.

Stateless Design

Swarm operates in a stateless manner, meaning it doesn’t retain memory between separate interactions. Each session is independent, requiring the context and instructions to be passed explicitly every time. This design allows for efficient parallel processing but requires careful management of context within each session to maintain continuity.

Within a single client.run() session, all agents and tools share the same context and conversation messages. Swarm manages the context and the exchange of information between agents and tools during the entire process, ensuring smooth execution until the final result is delivered to the user.

Execution Model

Swarm’s execution revolves around the client.run() method, which drives the interaction between agents and tools. The process follows several key steps:

• Fetching a response from the current agent based on its instructions and the provided context.
• Executing functions or tools, such as API calls, data gathering, or other tasks.
• Checking if a handoff is required to another agent for specialized tasks.
• Updating the context with new information as the process continues.
• Returning the final results to the user once the task is completed.

This loop allows agents to work through tasks, tools, and handoffs in a structured manner.

Agent Interaction Flow

The process starts with an initial agent based on user input or system design. As tasks progress, agents can hand off responsibilities to other agents better equipped for specific tasks. For example, in a customer support scenario, an initial triage agent might assess the user’s issue and pass it to a more specialized agent, such as technical support or billing. This fluid interaction ensures agents can collaborate efficiently and focus on their areas of expertise.

Why Swarm Is Significant

The introduction of Swarm brings several advantages:

• Simplified Multi-Agent Orchestration: Swarm makes it easier to manage complex interactions between multiple agents, reducing the overhead typically associated with such systems.
• Educational Value: Its lightweight and client-side nature make Swarm ideal for learning and experimentation.
• Scalability: The stateless design allows for parallel execution and easier scaling, which is crucial for handling large workloads.
• Flexibility: Agents can be specialized and reconfigured without affecting the entire system, promoting modular development.

Helpful Tip
Think of agents as specialized team members, each with their own expertise, collaborating to achieve a common goal.

When diving into multi-agent systems, it’s worth mentioning some other cool projects in this space. One example is GPTSwarm, a graph-based framework for LLM-powered agents. GPTSwarm lets developers build agent swarms from graphs, enabling automatic self-organization and self-improvement. OpenAI’s swarm is just one of several frameworks out there for orchestrating these kinds of multi-agent setups.

Building a Blog Post Title Generator with Swarm

Let’s put theory into practice. In this tutorial, we’ll build a multi-agent system that generates unique blog post titles on a given topic. The system will fetch the latest articles for research and ensure the titles don’t duplicate existing posts on your WordPress site. We’ll set it up so the agents go back and forth until they are satisfied with the final results and have collected enough links for each topic idea for us to research.

Setting Up the Environment

Before we dive into the code, make sure you have the following:

• Python 3.7+ installed on your system.
• An OpenAI API key set up in your environment variables.
• A NewsAPI.org API key for fetching the latest articles.
• Access to your WordPress site’s REST API to retrieve existing post titles.

Understanding the Code

Here’s the full code we’ll be working with:

# main.py

from swarm import Swarm, Agent
import requests
import json
from newsapi import NewsApiClient

# Replace 'YOUR_NEWSAPI_KEY' with your actual NewsAPI.org API key
NEWSAPI_KEY = 'YOUR_NEWSAPI_KEY'

# Replace 'https://your-wordpress-site.com' with your actual WordPress site URL
WORDPRESS_SITE_URL = 'https://your-wordpress-site.com'

def get_latest_articles(topic):
    """
    Get latest articles about a topic from NewsAPI.org.

    Args:
        topic (str): The topic to search for.

    Returns:
        str: A JSON string of the list of URLs.
    """
    newsapi = NewsApiClient(api_key=NEWSAPI_KEY)
    articles = newsapi.get_everything(q=topic, language='en', sort_by='relevancy', page_size=5)
    links = []
    for article in articles['articles']:
        links.append(article['url'])
    print(f"Getting latest articles for: {topic}")
    return json.dumps({'links': links})

def get_existing_titles():
    """
    Get existing post titles from the WordPress REST API.

    Returns:
        str: A JSON string of the list of titles.
    """
    response = requests.get(f'{WORDPRESS_SITE_URL}/wp-json/wp/v2/posts')
    posts = response.json()
    titles = [post['title']['rendered'] for post in posts]
    print(f"Getting existing post titles")
    return json.dumps({'titles': titles})

def handoff_to_filter_agent():
    """
    Hand off to the Title Filter Agent.
    """
    print(f"Handoff to Filter Agent")
    return TitleFilterAgent

def handoff_to_generator_agent():
    """
    Hand off to the Title Generator Agent.
    """
    print(f"Handoff to Generator Agent")
    return TitleGeneratorAgent

def title_generator_instructions(context_variables):
    topic = context_variables.get('topic', '')
    return f"""
You are a creative assistant that generates interesting and specific blog post titles on the topic '{topic}'.
Identify groupings of articles withing 'article_links' that would make for good topics.
Generate a list of 5 potential blog post titles based on groupings that match the user's topic.
Call the function 'get_latest_articles' with the topic to gather relevant links for each title to help with research.
Store the generated titles and associated links in your response.
Once you have generated the titles and gathered the links, call 'handoff_to_filter_agent' to hand off to the Title Filter Agent.
After you've generated the titles and the filter agent has cleaned up tht title name, perform additional news lookups to find more links for each title.
Go back and forth with the filter agent until you have a unique list of post ideas and at least 2-5 links per title.
Output the final list of titles and URLs once you are satisfied with their quality.
"""

TitleGeneratorAgent = Agent(
    name="Title Generator Agent",
    instructions=title_generator_instructions,
    functions=[get_latest_articles, handoff_to_filter_agent]
)

def title_filter_instructions(context_variables):
    return f"""
You are an assistant that filters and adapts blog post titles to avoid duplication with existing posts.
Call the function 'get_existing_titles' to get a list of existing post titles.
Compare the provided titles/links with existing titles and remove or adapt any that are too similar.
Avoid titles that are similar to the titles in the existing titles.
Make sure the titles will fit in will alongside existing titles.
Go back and forth with the generator agent until you have a unique list of post ideas and at least 2-5 links per title.
Once you have optimized the titles, call 'handoff_to_generator_agent' to continue doing research.
"""

TitleFilterAgent = Agent(
    name="Title Filter Agent",
    instructions=title_filter_instructions,
    functions=[get_existing_titles, handoff_to_generator_agent]
)

if __name__ == '__main__':
    client = Swarm()
    topic = input("Enter a topic for blog post ideas: ")

    context_variables = {'topic': topic}

    messages = [{"role": "user", "content": f"Please generate blog post titles on '{topic}'."}]

    response = client.run(
        agent=TitleGeneratorAgent,
        messages=messages,
        context_variables=context_variables,
        max_turns=50,
    )

    print("\nFinal blog post title ideas with research links:\n")
    print(response.messages[-1]['content'])

Importing Libraries

We start by importing the necessary libraries:

• swarm: The Swarm framework for orchestrating agents.
• requests and json: For HTTP requests and JSON handling.
• newsapi: To interact with NewsAPI.org for fetching articles.

Defining Functions

We define several functions that our agents will use:

• get_latest_articles(topic): Fetches the latest articles on a given topic.
• get_existing_titles(): Retrieves existing post titles from your WordPress site.
• handoff_to_filter_agent(): Transfers control to the Title Filter Agent.
• handoff_to_generator_agent(): Transfers control back to the Title Generator Agent.

Creating Agents

We create two agents with specific roles:

• Title Generator Agent: Gather recent news about a specific topic and identify patterns in the results to generate blog post ideas.
• Title Filter Agent: Delete or optimize the post idea based on existing post titles on our site.

Each agent has its own set of instructions and functions it can call.

Running the Client

Finally, we instantiate the Swarm client and run it, starting with the Title Generator Agent. The system will handle the handoff to the Title Filter Agent automatically and vice versa.

Helpful Tip
Pass debug=True to client.run() to view each agent’s requests and responses in the console.

This can be helpful when trying to troubleshoot issues with your multi-agent setup and it’s also just kind of cool to see under the hood.

Step-by-Step Guide

Running it is pretty simple. Save the code above as main.py somewhere on your computer.

1. Set Up API Keys and URLs

Replace the placeholders in the code with your actual API keys and WordPress site URL:

# Replace with your actual NewsAPI.org API key
NEWSAPI_KEY = 'YOUR_NEWSAPI_KEY'

# Replace with your actual WordPress site URL
WORDPRESS_SITE_URL = 'https://your-wordpress-site.com'

2. Install Necessary Libraries

Open a command prompt and navigate to the folder where you downloaded main.py. Install the required libraries using pip:

pip install git+https://github.com/openai/swarm.git newsapi-python requests

3. Test the System

Run the script and enter a topic when prompted:

python main.py

Sample Output:

Enter a topic for blog post ideas: WordPress News
Getting latest articles for: WordPress News
Handoff to Filter Agent
Getting existing post titles
Handoff to Generator Agent
Getting latest articles for: Automattic WP Engine WordPress Revenue
Getting latest articles for: WordPress.org Alternatives
Getting latest articles for: Relevance of WordPress Today
Getting latest articles for: WordPress ACF Hijacking
Getting latest articles for: WordPress Ecosystem Updates

Final blog post title ideas with research links:

Here are the finalized blog post titles on 'WordPress News' along with additional research links:

1. **Automattic vs. WP Engine: Unveiling the WordPress Revenue Battle**
   - [The Verge](https://www.theverge.com/2024/10/2/24260158/automattic-demand-wp-engine-revenue-wordpress-battle)
   - [Automattic Blog](https://automattic.com/2024/10/01/wpe-terms/)
   - [404 Media](https://www.404media.co/wordpress-checkbox-login-wp-engine/)

2. **Navigating WordPress: Making the Choice Between WordPress.org and Alternatives**
   - [Megabyterose](https://megabyterose.com/2024/10/leaving-wordpress-org-or-wpf-still-unsure-which-one/)
   - [WP Beginner Review](https://www.wpbeginner.com/showcase/best-wp-engine-alternatives/)
   - [WP Tavern](https://wptavern.com/impact-of-wpengines-ban-on-acf-plugin)

3. **The Relevance of WordPress Today: Is it Here to Stay?**
   - [Molodtsov](https://molodtsov.me/2024/10/wordpress-doesnt-matter-for-the-future-of-web/)
   - [Hongkiat](https://www.hongkiat.com/blog/15-noteworthy-websites-that-changed-the-internet/)

4. **WordPress Security Update: The Hijacking of ACF**
   - [Anderegg](https://anderegg.ca/2024/10/13/acf-has-been-hijacked)
   - [Advanced Custom Fields Blog](https://www.advancedcustomfields.com/blog/acf-plugin-no-longer-available-on-wordpress-org/)

5. **October WordPress Ecosystem Updates: What You Need to Know**
   - [Scripting](http://scripting.com/2024/10/07.html)
   - [WP Beginner Spotlight](https://www.wpbeginner.com/news/wpbeginner-spotlight-04-wordcamp-us-highlights-plugin-updates-more/)
   - [Speckyboy](https://speckyboy.com/manage-website-technical-debt/)

These titles are ready to be used for creating informative blog posts.

Helpful Tip
If you encounter errors, double-check your API keys and ensure all libraries are correctly installed. Dependencies can be tricky, it’s always good to verify your setup if something doesn’t work as expected.

And that’s it! This can easily be expanded to include additional agents and functions to further refine the quality of the results. Things like social media monitoring, SEO keyword research, user comment analysis, etc. What I’ve found great about it so far is, once I have a few functions and agents built, they seem pretty interchangeable with other swarms with minimal modifications aside from system instructions.

The ideas behind OpenAI’s Swarm framework open up exciting possibilities for building and managing multi-agent systems. The hardest part about working with multi-agent systems is managing their complexity as they scale. This architecture immediately abstracts away a lot of that complexity and I’ve found myself getting a lot further a lot faster going from idea to PoC.

In general, this architecture has opened my eyes a bit around what is possible regarding multi-agent systems. While I’ve built non-linear multi-agent systems in the past, they were still fairly rigid. I’ve since adopted newer approaches to help manage my tool dependencies a bit better but it still doesn’t compare to the fluidity of my experience with swarm so far.

I might dig a bit deeper but I’ve become overwhelmed with distractions, er, curiosities, around generative AI applications and their evolution. I have a feeling swarm or something very similar, will soon become a part of my regular AI dev toolkit.

The post Experimenting with OpenAI’s Swarm Framework appeared first on Jon Bishop.