The post Ep. 35 – Best Tech for a Deserted Island… appeared first on WEBNET Hosting.

If you work with Linux servers, ls is probably one of the first commands you run after logging in. For most users, the command stops at ls -l or ls -la.

That is usually enough until you need to find the newest release archive in a directory full of versioned files, check when a configuration file was created, or pass filenames to a script without breaking on spaces or special characters.

The good news is that GNU ls, included in GNU coreutils, already provides options for handling these tasks. In many cases, you don’t need to combine it with sort, awk, or stat to get the information you need.

In this guide, we’ll explore 10 useful ls options that can make everyday Linux administration easier. The examples were tested with GNU coreutils 9.4 and are applicable to common Linux distributions, including Rocky Linux, AlmaLinux, RHEL, Debian, and Ubuntu.

One important exception is Ubuntu 26.04, which uses the Rust-based uutils coreutils implementation by default rather than GNU coreutils.

Although many familiar options behave similarly, some newer features may be unavailable or behave differently. We’ll highlight compatibility considerations where necessary.

Before trying the examples, check whether your system uses GNU coreutils:

ls --version

Output:

ls (GNU coreutils) 9.4
Copyright (C) 2023 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later .
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Written by Richard M. Stallman and David MacKenzie.

This confirms that the system uses GNU coreutils 9.4.

How ls Decides What to Show

Before exploring the 10 options, it’s worth understanding three things that control how ls displays directory contents: which timestamp it uses, how it sorts entries, and how it arranges the output. Each option covered in this guide changes one or more of these behaviors.

By default, ls sorts entries alphabetically by name. When using a long listing (-l), it displays the modification time (mtime). When writing directly to a terminal, it arranges filenames in columns.

However, when its output is redirected to a file or piped to another command, it automatically switches to one entry per line. This is why ls | wc -l can count entries correctly even when the same directory appears in multiple columns on your screen.

To demonstrate these options, we’ll use a sample project directory on our test server (192.168.122.248), logged in as the tecmint user. The directory contains several release tarballs, a database dump, a shell script, a symbolic link, and two subdirectories.

1. Show Timestamps in a Readable Format with –time-style

By default, ls -l displays timestamps differently depending on a file’s age. Recent files show the time, while older files show the year. This inconsistent format makes it harder to compare timestamps at a glance, especially when managing files across multiple releases.

The –-time-style option solves this problem by letting you choose a consistent timestamp format for every entry.

The long-iso style is particularly useful for system administrators because it displays the date and time in a predictable YYYY-MM-DD HH:MM format:

ls -l --time-style=long-iso

Output:

total 2064
-rw-r--r-- 1 tecmint tecmint       0 2026-10-27 10:25 app-1.10.tar.gz
-rw-r--r-- 1 tecmint tecmint       0 2026-10-27 10:25 app-1.9.tar.gz
-rw-r--r-- 1 tecmint tecmint 2097152 2026-10-27 10:25 backup.sql
-rwxr-xr-x 1 tecmint tecmint      10 2026-10-27 10:25 deploy.sh
drwxr-xr-x 2 tecmint tecmint    4096 2026-10-27 10:25 docs

If you need more precise information, including seconds, nanoseconds, and the time zone offset, use the full-iso style. You can also use the --full-time shortcut, which produces the same timestamp format:

ls -l --time-style=full-iso notes.txt

Output:

-rw-r--r-- 1 tecmint tecmint 6 2026-10-27 10:25:45.772729598 +0530 notes.txt

You can also define a custom timestamp format by prefixing a date-style format string with +, useful when you want timestamps to match the format used in your team’s reports or administrative scripts:

ls -l --time-style=+'%d %b %Y %H:%M' notes.txt

Output:

-rw-r--r-- 1 tecmint tecmint 6 27 Oct 2026 10:25 notes.txt

GNU ls supports several built-in timestamp styles:

• full-iso – Displays the full date, time with nanoseconds, and time zone offset.
• long-iso – Displays the date and time in YYYY-MM-DD HH:MM format, making it a practical choice for everyday administration.
• iso – Displays MM-DD HH:MM for recent files and YYYY-MM-DD for older files.
• locale – Uses your system’s locale settings to format timestamps.
• +FORMAT – Accepts custom format specifiers, similar to the date command, such as %Y, %m, %d, %H, and %M.

If you regularly use long-iso, you don’t need to specify it every time. GNU ls reads the TIME_STYLE environment variable, so you can add the following line to your ~/.bashrc file to make it the default for your shell:

export TIME_STYLE=long-iso

After saving the file, reload your shell configuration:

source ~/.bashrc

From now on, ls -l will display timestamps using the long-iso format automatically.

2. Show File Creation Time with –time=birth

After learning how to display timestamps consistently, the next step is understanding which timestamp you’re looking at. Linux tracks several timestamps for each file, but ls -l displays the modification time (mtime) by default, which changes whenever the file’s contents are modified.

Sometimes, however, you need to know when a file was originally created on the filesystem. For example, you might want to determine when an unfamiliar configuration file first appeared on a server.

GNU ls can display a file’s birth time, also known as its creation time, using the --time=birth option:

ls -l --time=birth --time-style=long-iso notes.txt

Output:

-rw-r--r-- 1 tecmint tecmint 6 2026-10-27 10:25 notes.txt

The --time option accepts several values, allowing you to choose which timestamp appears in a long listing:

• --time=birth (or creation) – Displays when the file was created on the filesystem.
• --time=atime (equivalent to -u) – Displays when the file was last accessed or read.
• --time=ctime (equivalent to -c) – Displays when the file’s metadata, such as permissions, ownership, or link count, last changed.
• --time=mtime – Displays when the file’s contents were last modified. This is the default.

Keep in mind that birth-time availability depends on the filesystem, kernel, and system interfaces used to retrieve the timestamp. If a birth time is unavailable, GNU ls displays a placeholder rather than a valid creation date.

You can verify whether a file has a recorded birth time using stat command:

stat -c '%w' notes.txt

If the command returns a timestamp, the birth time is available. If it returns -, the system cannot provide one for that file.

One more thing to remember: copying a file with cp or extracting it from an archive creates a new filesystem object. Its birth time generally reflects when the new copy was created, not when the original file was first created.

3. Sort Release Files Correctly with -v (Version Sort)

Once you’ve learned to work with timestamps, another common problem is sorting files with version numbers in their names. By default, ls sorts filenames alphabetically, comparing characters from left to right.

This means app-1.10.tar.gz appears before app-1.9.tar.gz because the character 1 comes before 9, even though version 1.10 is newer.

The -v option, also available as --sort=version, solves this by recognizing numeric sequences within filenames and sorting them in natural version order:

ls -1 -v app-*

Output:

app-1.9.tar.gz
app-1.10.tar.gz

This is particularly useful when managing directories containing kernel images, rotated log files such as messages.1 through messages.12, or backups named with build and version numbers.

You can also combine version sorting with tail command to retrieve the highest version number, which is useful in shell scripts:

ls -1 -v app-* | tail -n 1

Output:

app-1.10.tar.gz

This approach works well when filenames follow a consistent version-numbering pattern, making it easier to identify the latest numbered release without using sort -V.

4. Sort Files by Size, Time, or Extension with –sort

Version sorting is useful for release files, but system administrators often need to answer other questions, such as which files are taking up the most space or which ones were modified most recently.

GNU ls provides the --sort option for choosing how directory entries are ordered. Many sort options also have shorter command-line equivalents.

For example, to list files and directories by size, with the largest entries first, use -S:

ls -lhS

Output:

total 2.1M
-rw-r--r-- 1 tecmint tecmint 2.0M Oct 27 10:25 backup.sql
drwxr-xr-x 2 tecmint tecmint 4.0K Oct 27 10:25 docs
drwxr-xr-x 2 tecmint tecmint 4.0K Oct 27 10:25 scripts
-rwxr-xr-x 1 tecmint tecmint   10 Oct 27 10:25 deploy.sh

Here, -h displays file sizes in a human-readable format, while -S sorts entries by size, placing the largest first.

The most useful sorting options include:

• --sort=size (or -S) – Sorts entries by size, with the largest first. Useful for identifying large files that may be consuming disk space.
• --sort=time (or -t) – Sorts entries by modification time, with the newest first. When combined with --time, it can also sort by the selected timestamp.
• --sort=extension (or -X) – Groups files by their extensions, making it easier to find related file types such as .gz, .sql, and .csv. Files without extensions appear first.
• --sort=width – Sorts entries by filename length, from shortest to longest. This can help identify unusually long filenames. This option was introduced in GNU coreutils 9.1, so it is unavailable in older versions.
• --sort=none (or -U) – Disables sorting and displays entries in the order they are returned by the filesystem. This can improve performance when listing directories containing very large numbers of entries.

You can reverse any of these sorting orders with -r. For example, combining -t with -r lists the oldest modified files first and the newest at the bottom:

ls -ltr

This is particularly handy when checking recently updated logs, configuration files, or application releases because the newest entries appear at the end of the listing.

5. List Directories Before Files with –group-directories-first

When working in directories containing many files and subdirectories, finding a particular folder can become difficult because ls normally sorts everything together alphabetically.

The --group-directories-first option solves this by displaying directories before regular files, while preserving the selected sort order within each group.

For example:

ls -F --group-directories-first

Output:

docs/  
scripts/  
app-1.10.tar.gz  
app-1.9.tar.gz  
archive.tar.gz  
backup.sql  
data.csv  
deploy.sh*  
latest-notes@  
notes.txt  
report.pdf

This option is particularly useful when managing application directories, deployment files, and backup locations where you frequently switch between folders and files.

If you prefer this layout every time you use ls, you can create a shell alias in your ~/.bashrc file. You can also combine it with the TIME_STYLE setting from the first example:

export TIME_STYLE=long-iso
alias ll='ls -lh --group-directories-first'

After saving the file, reload your shell configuration:

source ~/.bashrc

One important limitation is that --sort=none (or -U) disables directory grouping because entries are no longer sorted into separate groups. If directory-first output matters, avoid combining these options.

6. Identify File Types with -F (–classify)

You may have noticed the /, *, and @ characters appearing after filenames in the previous output. These are file-type indicators added by the -F option, also known as --classify.

This option appends a character to each entry to identify its type, making it easier to distinguish directories, executable files, and symbolic links without using colors or a long listing.

For example:

ls -F

Output:

app-1.10.tar.gz  app-1.9.tar.gz  archive.tar.gz  backup.sql  data.csv  deploy.sh*  docs/  latest-notes@  notes.txt  report.pdf  scripts/

GNU ls uses the following indicators:

• / – Identifies a directory.
• * – Identifies an executable file.
• @ – Identifies a symbolic link.
• | – Identifies a named pipe (FIFO).
• = – Identifies a socket.
• > – Identifies a door, a file type used on some Unix systems such as Solaris, but not normally found on Linux.

It’s important not to confuse -F with -p. The -p option adds a trailing / only to directory names, while -F adds the appropriate indicators for several file types.

Recent GNU coreutils versions also support --classify=auto, which automatically enables classification only when output is directed to a terminal. This is useful when you want file-type indicators for interactive use without adding characters to redirected output.

For example:

ls --classify=auto

This makes ls more convenient for interactive use, although you should still avoid parsing ordinary ls output in scripts. For reliable filename handling, use find command or shell globbing instead.

7. Print Filenames as a Comma-Separated List with -m

Sometimes you don’t need a traditional column or long listing. For example, you might want to copy a list of filenames into a support ticket, email, or chat message.

The -m option, equivalent to --format=commas, displays filenames separated by commas and arranges them across as few lines as possible:

ls -m

Output:

app-1.10.tar.gz, app-1.9.tar.gz, archive.tar.gz, backup.sql, data.csv,
deploy.sh, docs, latest-notes, notes.txt, report.pdf, scripts

GNU ls also supports several other output formats through the --format option:

• --format=commas – Equivalent to -m, displaying filenames separated by commas.
• --format=long (or verbose) – Equivalent to -l, displaying detailed file information.
• --format=single-column – Equivalent to -1, displaying one filename per line, even when output is directed to a terminal.
• --format=across (or horizontal) – Equivalent to -x, filling rows from left to right.
• --format=vertical – Equivalent to -C, displaying entries in columns from top to bottom. This is the default layout when output is sent to a terminal.

These formats are useful when you want to change how filenames are presented without changing which entries are listed.

8. Control Output Width with -w (–width)

By default, ls determines the available output width from the terminal and arranges filenames accordingly. This usually works well, but the layout can change when working in narrow terminal windows, tmux panes, or remote SSH sessions.

The -w option, also available as --width, lets you specify the output width in characters. For example, setting the width to 80 characters gives ls a fixed width to work with:

ls -w 80

This is useful when you want a predictable column layout regardless of the terminal’s actual width. Setting the width to 0 removes the width limit, allowing ls to display all filenames on a single line:

ls -w 0

Output:

app-1.10.tar.gz  app-1.9.tar.gz  archive.tar.gz  backup.sql  data.csv  deploy.sh  docs  latest-notes  notes.txt  report.pdf  scripts

One older option you may encounter is --tabsize, which controls the number of columns used for tab characters in output. Modern GNU ls generally uses spaces for column alignment, so this option has limited practical value in everyday terminal use and can usually be ignored.

9. Display Numeric UID and GID with -n

File ownership is particularly important when transferring files between Linux servers, working with shared storage, or troubleshooting container permissions.

By default, ls -l displays usernames and group names by resolving the numeric user ID (UID) and group ID (GID) associated with each file. The -n option displays these numeric IDs instead, making it easier to identify the actual ownership values:

ls -ln notes.txt

Output:

-rw-r--r-- 1 1000 1000 6 Oct 27 10:25 notes.txt

Here, both the owner and group have the numeric ID 1000.

This is particularly useful when transferring files between servers using rsync or tar, working with NFS shares, or troubleshooting permissions inside containers.

For example, UID 1000 might belong to one user on your source server and a completely different user on the destination server. While ls -l displays the username resolved on the current system, ls -ln shows the numeric UID and GID without relying on those name lookups.

This makes -n a useful option when investigating ownership mismatches across systems.

10. Produce Null-Terminated Filenames with –zero

The previous options focus mainly on making directory listings easier to read. However, when using filenames in shell scripts or passing them between commands, ordinary ls output can create problems.

For example, a filename such as my report.txt contains a space. If a script or command splits filenames on whitespace, it may incorrectly treat this as two separate names.

GNU coreutils 9.0 introduced the --zero option, which separates filenames using a null character (

The post 10 Useful ‘ls’ Command Tricks for Linux Users appeared first on WEBNET Hosting.

Agentic ecommerce is online shopping and store management where AI agents can independently complete several steps of a task for you, such as comparing products, building a cart, updating prices, or preparing a promotion.

Instead of giving a single answer and stopping, the AI agent checks current store information, works through the decisions needed to complete the task, and uses the store tools it has permission to access.

For shoppers, that can mean getting help from product discovery through checkout. For merchants, it can mean handing off parts of store management, such as catalog updates, promotions, inventory checks, and order handling.

What separates agentic ecommerce from traditional automation is that the agent can change its approach when new information appears instead of following one fixed sequence. That flexibility also makes accurate data, reliable checkout, and clear limits on what the agent can do more important.

What makes ecommerce agentic?

Ecommerce becomes agentic when AI can work toward a goal using current store data, decide what to do next, and take permitted actions in the store.

The agent doesn’t need unrestricted control to do that. It needs enough information and access to move the task forward within the limits set by the shopper or merchant:

• A clear goal. A shopper might ask for running shoes under $120 with arch support in their size. Those requirements give the agent a specific result to work toward.
• Current store information. The agent checks live prices, stock, shipping options, and product details so its decisions reflect what the store can offer now.
• A way to plan and adjust. Instead of merely returning one answer or applying a fixed rule, agentic AI can choose the next tool or action based on what it has learned, subject to its instructions and permissions.
• Access to store tools. The agent can search products, prepare a cart, update a listing, or perform another store action it has permission to take.

How does agentic ecommerce differ from other AI in ecommerce?

Agentic ecommerce is one type of AI in ecommerce. Unlike many other ecommerce AI tools that handle one defined task, an ecommerce agent can use the result of one step to decide what to do next and continue working toward the same shopping or store-management goal.

A fraud-detection system, for example, assesses a payment’s risk, while a recommendation system suggests products based on shopper data. Those are useful AI capabilities, but neither alone is an agent that can plan and act across a larger commerce task.

An ecommerce agent can use those results as part of a longer task. For example, the agent could check the order details and send the order for review instead of continuing with fulfillment if a payment is flagged.

Agentic ecommerce vs. traditional ecommerce automation

Traditional ecommerce automation follows rules you set in advance, while agentic ecommerce can adjust its actions based on the information it finds.

A normal automation might send an email 24 hours after someone abandons a cart or send a restock alert when inventory falls below 10 units. You decide what triggers the workflow, which action follows, and what happens next.

An agent can start with a broader goal, such as “recover abandoned-cart sales.” It could check whether the products are still in stock, review the cart value, and decide whether to prepare a discount or contact the shopper. The agent can adjust without you defining every possible path in advance if something changes during the task.

Buyer-side vs. merchant-side ecommerce agents

Ecommerce agents can help shoppers make purchases or help merchants run their stores.

The difference comes down to who assigns the task and which store information and tools the agent has permission to access.

Buyer-side agents

Buyer-side agents help shoppers find, compare, and buy products. A shopper might use one through a retailer’s website, a marketplace, or an AI shopping service.

For example, a shopper could ask:

“Find a waterproof jacket under $150 in size M that arrives by Friday.”

The agent could search available products, compare prices and features, check which jackets are in stock in size M, and remove any that would arrive too late.

With cart access from the retailer or shopping service, the agent could add the shopper’s chosen jacket. Where checkout is supported, and the shopper has authorized the purchase, it could also complete the order within the approved product, delivery, and spending limits.

The agent can’t simply do anything it wants on the store. What happens after the product search depends on the access the retailer and payment system provide.

Merchant-side agents

Merchant-side agents help businesses manage their stores. The merchant might use one inside the ecommerce dashboard or through another AI tool connected to the store.

Imagine the same store sells several waterproof jackets. The merchant could ask:

“Find waterproof jackets with high stock and no sales in the last 60 days, then prepare a 10% promotion for the ones that still have enough margin.”

The agent could check sales, inventory, and pricing data, identify the jackets that meet those conditions, and prepare the promotion.

The merchant decides how much control the agent gets. It might be allowed to update product details and prepare discounts but require approval before changing prices or publishing a promotion.

How agentic ecommerce works

Agentic ecommerce works by allowing an AI agent to use store information and permitted tools across connected ecommerce systems to complete a shopper or merchant task across multiple steps.

The request starts in the AI tool the person is using. That could be a shopping assistant on a retailer’s website, an AI shopping service, or a merchant tool connected to the store dashboard.

The exact task can vary, but the same agentic workflow applies. Here’s what it could look like when a shopper uses an AI shopping assistant:

1. The agent receives the goal. A shopper enters: “Find a science gift for a 10-year-old under $40 that arrives by Saturday.” The agent uses the age, budget, interest, and delivery date as conditions for the search.
2. The agent checks current information. It compares suitable products using current prices, stock, age recommendations, and delivery dates. A $35 chemistry set won’t arrive until Monday, so the agent removes it from the options and continues searching.
3. The agent requests an action. It finds a $38 science kit that is in stock and can arrive by Friday, then asks the store to add it to the shopper’s cart. The ecommerce platform creates the cart and calculates the current checkout details.
4. The agent checks the result. It confirms that the product is still available at the expected price and delivery date. If something has changed, such as the item selling out, it can return to the remaining options and choose another product.

Agentic ecommerce use cases

Agentic ecommerce use cases include helping shoppers discover and compare products, build carts and complete purchases, track orders and get support, and helping merchants manage inventory, product listings, and promotions.

Product discovery, comparison, cart building, and selected merchant operations already work in deployed tools. Checkout and automated reordering are available in certain supported services and markets; cross-store autonomous purchasing, refunds, and broad merchant integrations remain more limited. Not every store or AI service supports these actions.

Product discovery and comparison

AI shopping tools can compare a shopper’s requirements with current product information and narrow down suitable choices.

A shopper searching for a dishwasher might ask for one under $600 that runs quietly and has a quick-wash cycle.

The agent can turn those needs into specific criteria, compare suitable products, and check current prices and stock before returning the matches that still fit.

Current shopping assistants already support parts of this process. Google’s AI shopping features help shoppers discover and compare products, while Amazon’s Alexa for Shopping can help customers research products and narrow down choices.

For merchants, accurate product details give these tools enough information to understand when a product matches what the shopper is asking for.

Cart and checkout

Agent-assisted checkout goes further because the system must know exactly what the shopper has approved and how the payment should be handled.

Google’s Universal Cart began rolling out in the U.S. across Search and the Gemini app in October 2026. It saves products from multiple retailers and offers checkout through the Universal Commerce Protocol (UCP) with participating merchants, or transfers items to the merchant’s cart. The shopper still completes the checkout steps.

These systems work through supported shopping and payment flows. They don’t give an AI open permission to buy anything from any website.

That distinction matters for merchants: product discovery can work from accessible product data, while purchasing requires much tighter connections between the agent, merchant, customer account, and payment system.

Fulfillment and customer support

Agents can handle order and support questions when they have access to the information needed to answer them.

A shopper asking “Where is my order?” doesn’t need a support agent to find and copy a tracking number. An ecommerce agent with access to the order can return the latest shipping status directly.

The same approach works for checking whether an order is still within its return period or whether it can be canceled.

Issuing a refund is different because it moves money and may be irreversible. The agent should verify the order, refund eligibility, amount, and customer identity, then request explicit approval unless the merchant has granted a narrowly scoped, auditable refund policy.

Merchant operations

Merchant-side agents can handle jobs that normally require checking several parts of the store.

A merchant could ask:

“Find products with more than 90 days of inventory, check their margins, and prepare a promotion for the slowest sellers.”

With access to inventory, sales history, product costs, and pricing, the agent could identify suitable products and draft the promotion. It should flag missing cost data rather than guess whether the discount leaves enough margin.

This can save the merchant from checking each system separately, while the store still controls which changes the agent is allowed to make.

What infrastructure does agentic ecommerce need?

Agentic ecommerce depends on accurate store data, reliable software connections, working checkout and payments, clear business rules, and controls over what an agent can access or change.

Product information needs to be stored in a form that software can understand. For example, instead of mentioning “waterproof” only in a jacket description, the store can save “waterproofing” as its own product field. This is called structured product data.

The store also needs a controlled way to share that information and allow specific actions. AI agent integrations provide those connections and determine what the AI can read or change. One integration might allow stock checks without inventory edits, for example, while another could allow order updates.

One common way to create this connection is an application programming interface (API). An API lets one system ask another for information or request an action, such as “Is size 9 in stock?” or “Create this cart.”

Different stores and AI platforms also need to agree on how those requests are structured. A commerce protocol provides shared rules for those interactions.

Shared protocols can reduce the need for separate integrations with each AI platform. The Universal Commerce Protocol (UCP) supports catalog search, carts, checkout, and order management. OpenAI and Stripe’s Agentic Commerce Protocol (ACP) provide another approach to connecting agents with merchant checkout systems.

The specific standards will continue to develop. The practical requirement for merchants stays the same: outside software needs a dependable and controlled way to read store data and request supported actions.

Benefits of agentic ecommerce for merchants

Agentic ecommerce helps merchants reach shoppers through AI tools, spend less time on routine store tasks, and manage work across connected systems. Agents can also adjust their actions when store information changes.

• Reach shoppers through AI tools. Customers can discover and compare products through AI services without visiting your store first. Accurate product descriptions, prices, and stock information help these tools recommend relevant products. This is part of broader ecommerce trends changing how people shop online.
• Spend less time on repetitive tasks. Agents can check stock before a promotion or update multiple product listings, saving you from making the same checks and changes manually.
• Work across different store tools. Instead of checking inventory, sales, and orders separately, you can have an agent use information from connected systems to complete a task.
• Adapt when things change. When a product sells out or a price changes, an agent can use the new information to decide what to do next. Traditional automation relies on rules defined in advance.

For straightforward tasks with predictable steps, traditional automation is still the simpler choice.

Limitations of agentic ecommerce

The main limitations of agentic ecommerce are its reliance on accurate store data, the need for clear purchase approvals and access restrictions, and reduced merchant control when customers shop through third-party AI services.

Without proper safeguards, agents can recommend unavailable products, make purchases shoppers didn’t approve, or change store settings beyond their assigned tasks.

• Inaccurate product data leads to unreliable decisions. AI agents rely on product details, prices, and inventory information from retailers or connected services. Outdated data can lead to incorrect recommendations, misleading prices, or failed purchases.
• Unclear approval rules can lead to unwanted purchases. Shopping agents need limits on what they can buy, how much they can spend, and when they must request confirmation. Without these rules, shoppers risk paying more than expected or receiving items they didn’t intend to purchase.
• Excessive access increases the risk of mistakes and attacks. Agents with more permissions than their tasks require can make unintended changes to prices, refunds, or other store settings. Attackers can also exploit those permissions through prompt injection, which uses malicious instructions hidden in content the agent reads.
• Third-party shopping can reduce brand control. External AI platforms may influence which products appear, how features and prices are summarized, and when shoppers reach a merchant’s own site. Merchants should monitor product-feed accuracy and ensure critical product and policy details remain consistent across channels.

How to make an ecommerce store agent-ready

Make your ecommerce store agent-ready by checking product and inventory data, testing store integrations and checkout, reviewing store policies, and limiting what AI agents can access or change.

1. Check product, pricing, and inventory data

Check that your product details, prices, and inventory records are accurate, starting with products that have variants, discounts, or frequently changing stock.

Make sure details such as size, color, material, dimensions, product codes, price, and availability are stored in the correct fields rather than buried only inside descriptions.

Then compare the information shown on the product page with the record in your store dashboard. The variant, price, promotion, and stock status should match.

Pay particular attention to values that make sense to a person but not necessarily to software. If a color is listed as “Midnight,” for example, add a standard color such as navy where your store supports it.

2. Test how other systems reach your store data

Test whether your store’s API or other integration returns accurate data by retrieving one product variant. Use approved test credentials to check a test order separately, and confirm that only the authorized customer or merchant can access its details.

The values should match. Differences mean an agent could make decisions using outdated or incomplete information.

Merchants who don’t work with APIs directly can ask their developer or integration provider to run this check.

Hostinger Ecommerce maintains products, stock, carts, orders, payment settlements, and connected sales channels in a centralized Store Manager. Its Custom sales channel and Ecommerce API can give supported integrations a consistent commerce backend.

3. Test checkout and store rules

Test checkout and store rules using sample orders, with a test payment method or sandbox checkout where available to avoid charging a real customer.

Check that the price, discount, shipping charge, tax, availability, and final order stay consistent throughout the process. If the agent sees one price and checkout calculates another, the workflow isn’t reliable enough yet.

Test store policies the same way. Pick one order that qualifies for a return and another that doesn’t. Your written return, refund, cancellation, and shipping rules should make the correct outcome clear in both cases.

4. Limit access and start with a reversible task

Limit the agent’s access to what its first task requires, and choose a task that’s easy to review and undo.

Updating a small group of product descriptions is easier to review and reverse than issuing refunds or changing prices across the whole catalog.

Test the limits as well. Ask the agent to perform an action outside its permissions, such as changing a price when it only has content access. It should refuse the request or require the approval your workflow specifies.

Once the agent handles the narrow task reliably, expand its access one function at a time.

How does Hostinger support agent-ready commerce?

Hostinger supports agent-ready commerce by combining store data and operations in Hostinger Ecommerce with tools for AI-assisted management and custom sales channels.

Merchants can use Hostinger Agent for supported tasks inside Hostinger, while developers can connect compatible AI coding assistants through Hostinger Connector or build custom storefronts using the Public Sales Channel API.

These tools don’t automatically enable purchases through third-party AI shopping assistants, which require a separate, compatible checkout integration.

Where should merchants start with agentic ecommerce?

Start with a dependable store setup rather than trying to connect every new AI shopping tool. Your product details, prices, stock, and checkout information need to match across the places you sell. Good ecommerce inventory management helps keep availability accurate as orders come in.

Once that foundation is reliable, give an agent one small task you can review, such as preparing updates for a few product listings. Use the checklist to prepare for agentic commerce, then verify that changes are accurate, unauthorized actions are blocked, and you can stop the agent before giving it more responsibility.

All of the tutorial content on this website is subject to

Hostinger’s rigorous editorial standards and values.

The author

Alma Fernando

Add Hostinger as a preferred source on Google

Alma is an AI Content Editor with 9+ years of experience helping ideas take shape across SEO, marketing, and content. She loves working with words, structure, and strategy to make content both useful and enjoyable to read. Off the clock, she can be found gaming, drawing, or diving into her latest D&D adventure.

The post What is agentic ecommerce? appeared first on WEBNET Hosting.

The post Apple Made a MacBook for ME appeared first on WEBNET Hosting.

Most of us learn a way to perform a Linux task and stick with it for years because it works, and there’s rarely a good time to look for a better approach. You might create a directory, change into it, create another directory, and repeat the process. Or you might copy a tarball into /opt just to extract it there.

These habits aren’t wrong, but they add unnecessary steps. Across multiple servers, those extra commands add up. They also make shell scripts longer and introduce more opportunities for typos.

In this guide, we’ll explore five practical techniques that replace repetitive, multi-step routines with simpler commands. We’ve tested the examples on Ubuntu 26.04 LTS and Rocky Linux 10. They should also work on other Linux distributions, unless a section notes otherwise.

Difference Between Shell Features vs. Command Options

Before diving into the examples, it’s worth understanding that these techniques fall into two categories: shell features and command options. Knowing the difference helps explain how they behave, especially in scripts.

The first category includes shell features, such as brace expansion and heredocs, Bash handles these before executing a command.

For example, when you use brace expansion with mkdir, Bash expands the braces into a list of paths before passing them to mkdir. The command itself never sees the braces. Because these features depend on the shell, their behavior can vary when you use a different shell or run a script with a different interpreter.

The second category includes command options, such as tar -C and the process-matching options available in pgrep and pkill. These are implemented by the respective utilities rather than by the shell, so their behavior doesn’t depend on which shell launches them.

1. Create a Nested Directory Tree with mkdir -p and Brace Expansion

Setting up a directory structure is a common task when deploying a new application. Suppose you’re deploying an app called myapp in the tecmint user’s home directory and need separate directories for binaries, configuration files, logs, data, and scripts.

The traditional approach is to run multiple mkdir commands, one for each directory. A quicker approach combines mkdir -p with Bash brace expansion to create the entire directory tree in a single command:

mkdir -pv ~/myapp/{bin,config/{nginx,systemd},logs,data/{uploads,cache,backups},scripts}

The -p option creates missing parent directories as needed, while -v (verbose) prints a message for each directory created. Together, they let you build the structure and verify the results in one step.

Output:

mkdir: created directory '/home/tecmint/myapp'
mkdir: created directory '/home/tecmint/myapp/bin'
mkdir: created directory '/home/tecmint/myapp/config'
mkdir: created directory '/home/tecmint/myapp/config/nginx'
mkdir: created directory '/home/tecmint/myapp/config/systemd'
mkdir: created directory '/home/tecmint/myapp/logs'
mkdir: created directory '/home/tecmint/myapp/data'
mkdir: created directory '/home/tecmint/myapp/data/uploads'
mkdir: created directory '/home/tecmint/myapp/data/cache'
mkdir: created directory '/home/tecmint/myapp/data/backups'
mkdir: created directory '/home/tecmint/myapp/scripts'

The exact wording and ordering of verbose messages may vary by implementation, but the intended directory structure remains the same.

Here’s how Bash expands the braces in this command:

• {a,b,c} expands into separate paths for each item. For example, {logs,scripts} becomes logs and scripts.
• Nested braces, such as config/{nginx,systemd}, generate multiple paths under the same parent directory: config/nginx and config/systemd.
• Avoid spaces after commas. Writing {bin, logs} prevents Bash from recognizing the expression as intended, leaving the braces in the resulting argument.

Display the Directory Tree

To verify the resulting structure, use the tree command. It may not be installed on minimal Linux systems, so install it first if necessary.

On Ubuntu and Debian, run:

sudo apt install -y tree

On Rocky Linux, AlmaLinux, and RHEL, use:

sudo dnf install -y tree

Once installed, display the directory structure:

tree ~/myapp

Output:

/home/tecmint/myapp
├── bin
├── config
│   ├── nginx
│   └── systemd
├── data
│   ├── backups
│   ├── cache
│   └── uploads
├── logs
└── scripts

10 directories, 0 files

Preview Brace Expansion Before Creating Directories

Long brace expressions are easy to mistype. A misplaced comma can produce an unexpected path, so it’s useful to check the expansion before creating anything, because Bash expands braces before executing a command, you can use echo command to preview the resulting paths without modifying the filesystem:

echo ~/myapp/{bin,config/{nginx,systemd},logs}

Output:

/home/tecmint/myapp/bin /home/tecmint/myapp/config/nginx /home/tecmint/myapp/config/systemd /home/tecmint/myapp/logs

Brace Expansion Doesn’t Work in /bin/sh Scripts

One important limitation is that brace expansion is a Bash feature, not part of the POSIX shell standard. On Ubuntu and Debian, /bin/sh typically points to dash, which does not support Bash-style brace expansion.

As a result, a script beginning with #!/bin/sh may pass an expression such as {bin,config} to mkdir literally instead of expanding it into separate directory names.

If your script relies on brace expansion, use a Bash shebang:

#!/bin/bash

This ensures the script runs under Bash, where the expansion works as expected. If you need POSIX shell compatibility, use separate path arguments or a loop instead.

2. Create a File with Content Using a cat Heredoc

Once the directories are in place, the next step is usually to create a configuration file. The traditional approach involves creating the file, opening it in an editor, entering the content, and saving it. That works well for occasional tasks, but it becomes tedious when you’re configuring multiple servers or automating deployments.

A heredoc (short for here document) lets you pass multiple lines of text directly to a command using a designated closing marker. Combined with cat and output redirection, it creates a file and writes its contents in one step.

For example, let’s create an environment file in the config directory from the previous example:

cat << 'EOF' > ~/myapp/config/app.env
APP_NAME=myapp
APP_PORT=8000
LOG_DIR=/home/tecmint/myapp/logs
EOF

To verify the contents, run:

cat ~/myapp/config/app.env

Output:

APP_NAME=myapp
APP_PORT=8000
LOG_DIR=/home/tecmint/myapp/logs

Here’s how the command works:

• << 'EOF' starts the heredoc. EOF is a delimiter you choose; any marker works as long as the closing line matches it exactly.
• The quotes around EOF prevent Bash from expanding variables and command substitutions in the heredoc body. For example, PATH=$HOME/bin is written literally rather than expanded. This is a useful default when creating configuration files.
• > ~/myapp/config/app.env redirects the text into the file, replacing any existing contents. Use >> instead to append the text.
• The closing EOF must appear on a line by itself, without leading or trailing spaces, unless you use a heredoc variant that explicitly permits indentation.

Expand Variables Inside a Heredoc

Sometimes you want Bash to insert dynamic values into the file, such as the current username, hostname, or deployment date. In that case, leave the delimiter unquoted so Bash expands variables and executes command substitutions before passing the text to cat.

For example:

cat << EOF > ~/myapp/DEPLOYED.txt
Deployed by: $USER
Host: $(hostname)
Date: $(date +%F)
EOF

Read the file to see the expanded values:

cat ~/myapp/DEPLOYED.txt

Example output:

Deployed by: tecmint
Host: server1
Date: 2026-10-27

The output will vary depending on the user, hostname, and date when you run the command.

Write to Root-Owned Files with sudo tee

Heredocs are also useful for creating system configuration files under directories such as /etc. However, a common mistake is to assume that prefixing a command with sudo also grants elevated permissions to its output redirection.

For example, this command fails for a regular user who lacks permission to write to the destination:

sudo cat << 'EOF' > /etc/sysctl.d/90-tecmint.conf
vm.swappiness = 10
EOF

You may see an error similar to:

bash: /etc/sysctl.d/90-tecmint.conf: Permission denied

The reason is that your shell processes the > redirection before running sudo cat. The shell attempts to open the file using your regular user’s permissions, so the operation fails before cat can run with elevated privileges.

The solution is to use sudo tee, which opens and writes the destination file with root privileges:

sudo tee /etc/sysctl.d/90-tecmint.conf > /dev/null << 'EOF'
vm.swappiness = 10
EOF

The > /dev/null redirection suppresses tee’s normal output, keeping the configuration text from being printed to the terminal. To append content instead of replacing the file, use sudo tee -a.

3. Extract a Tarball into Another Directory with tar -C

Once the application directories and configuration files are ready, the next step is often installing software distributed as a tarball. A common approach is to move the archive to its destination, change into that directory, and extract it. Alternatively, you might extract it in ~/Downloads and move the resulting directory afterward. Both approaches involve unnecessary steps.

The -C option tells tar to change to a specified directory before extracting the archive. This lets you leave the downloaded archive where it is and extract its contents directly into the intended location.

The official Go installation method provides a practical example. Go’s Linux archive can be extracted directly into /usr/local:

wget https://go.dev/dl/go1.25.3.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.25.3.linux-amd64.tar.gz

The rm -rf /usr/local/go command removes an existing Go installation before extraction. The Go project recommends this approach because extracting a new version over an existing installation can leave obsolete files behind.

After extraction, the Go binaries are available in /usr/local/go/bin, even though you never changed your working directory:

ls /usr/local/go/bin

Output:

go  gofmt

Let tar Detect the Compression Type

Traditionally, you might use different tar options for different compression formats, such as -z for gzip, -j for bzip2, and -J for xz. When extracting archives, GNU tar can automatically detect common compression formats, so you generally don’t need to remember the corresponding option.

For example, the following command extracts an xz-compressed archive directly into /opt:

sudo tar -xf archive.tar.xz -C /opt

The same basic approach works with gzip, bzip2, xz, and Zstandard-compressed tar archives, provided the required decompression support is available. For .tar.zst archives, install the zstd package if it’s missing:

On Ubuntu and Debian:

sudo apt install zstd

On Rocky Linux, AlmaLinux, and RHEL:

sudo dnf install zstd

Common Mistakes with tar -C

The destination directory must already exist because tar -C changes into that directory but doesn’t create it and if the directory is missing, extraction fails with an error similar to:

tar: /opt/node: Cannot open: No such file or directory
tar: Error is not recoverable: exiting now

You can avoid this problem by combining mkdir -p with tar -C. Another common issue is that archives often contain a versioned top-level directory, such as node-v24.11.0-linux-x64/. If you want the files inside that directory to land directly in your destination, use --strip-components=1 to remove the first path component:

sudo mkdir -p /opt/node
sudo tar -xf node-v24.11.0-linux-x64.tar.xz -C /opt/node --strip-components=1

Before extracting an unfamiliar archive, inspect its contents to understand its directory structure:

tar -tf archive.tar.xz | head

This displays the first few paths in the archive, helping you determine whether --strip-components=1` is appropriate. Removing too many components can flatten the directory structure incorrectly or discard useful path levels.

4. Find and Kill Processes by Name with pgrep and pkill

Eventually, you’ll need to stop a running process, whether it’s a test server, a stuck script, or an application that’s no longer responding. The traditional approach is to run ps -A | grep -i apache2, identify the relevant PIDs, and pass them to kill manually. Although this works, it takes extra steps and can produce confusing results when `grep` matches its own command line.

A simpler approach is to use pgrep to find processes and pkill to signal them by name or command-line pattern.

Let’s start a small test process so you can practise safely. Python’s built-in HTTP server is available on both Ubuntu and Rocky Linux, and the & operator runs it in the background:

python3 -m http.server 8000 &

Use pgrep to find the running process. The -a option displays each matching PID alongside its full command line, making it easier to identify the correct process:

pgrep -a python3

Example output:

4821 python3 -m http.server 8000

Your PID will differ. Once you’ve confirmed which process you want to stop, use pkill to send it a signal without copying its PID:

pkill -e -f "http.server"

Example output:

python3 killed (pid 4821)

The -f option matches the full command line, allowing pkill to find the Python server even though its process name is simply python3. The -e option reports the process name and PID for each process signaled.

Here are some useful pgrep and pkill options to remember:

• -f matches against the full command line instead of just the process name. Use it when multiple programs share the same executable name, but make sure your pattern identifies only the intended process.
• -x requires an exact match for the process name. For example, pkill -x ssh matches a process named ssh, not one named sshd.
• -u tecmint restricts the search to processes owned by the tecmint user, helping avoid unintended matches on shared servers.
• -HUP or --signal HUP sends SIGHUP instead of the default SIGTERM. SIGTERM requests a graceful shutdown, whereas SIGKILL (-9) forcibly terminates a process without giving it an opportunity to clean up.

Before using pkill with a broad pattern, preview the matches with pgrep -a using the same pattern and relevant filters. This helps you identify the processes that could be affected before sending a signal.

Stop System Services with systemctl Instead of pkill

You may see older examples that use pkill apache2 to stop a web server. For services managed by systemd, however, the recommended approach is to use systemctl stop.

Killing a service process directly can cause problems. If its systemd unit has a restart policy configured, systemd may start it again. Otherwise, the service may enter a failed state or leave systemd’s recorded service status inconsistent with your intentions.

On Ubuntu and Debian, the Apache service is named apache2:

sudo systemctl stop apache2

On Rocky Linux, AlmaLinux, and RHEL, it is named httpd:

sudo systemctl stop httpd

Reserve pkill for processes you intend to manage directly, such as your own test servers, stuck scripts, or unwanted commands running in another terminal. For systemd-managed services, use systemctl to stop the service cleanly and let the service manager handle its lifecycle.

5. Wait for a Process to Finish with pidwait

The final tip builds on pgrep and pkill but solves a different problem: waiting for a process to finish before running the next command. For example, you might want to start a package upgrade only after a long-running backup has completed.

A common workaround is a while loop that repeatedly checks for the process with pgrep and pauses with sleep. The pidwait command, provided by the procps-ng package, offers a simpler alternative by waiting for matching processes to terminate.

For example, to wait for an rsync process to finish before printing a completion message, run:

pidwait -x rsync && echo "Backup finished at $(date +%T)"

The -x option matches the process name exactly, while && ensures that the completion message is printed only if pidwait exits successfully. The message includes the current time.

One important detail is that pidwait waits for processes it successfully identifies when it starts. If no matching process exists, it returns immediately rather than waiting for a future rsync process to appear. Also, matching by process name alone can be ambiguous if multiple rsync processes are running.

pidwait availability depends on the installed procps-ng version and distribution packaging. Check whether it is available on your system with:

command -v pidwait

If it isn’t installed, you can use a polling loop as a fallback:

while pgrep -x rsync > /dev/null; do
    sleep 5
done
echo "Backup finished at $(date +%T)"

This loop checks every five seconds until no process named rsync remains. Like the pidwait example, it returns immediately if no matching process is running when the loop begins.

It also checks only for the process name, not whether a particular backup job completed successfully, so use a more specific process check or an explicit job-status mechanism when that distinction matters.

Pro Tips for Using These Commands Safely in Scripts

Now that you have all five tricks, a few habits make them safer when you move them from the terminal into scripts that run on many servers.

The biggest risk with pkill -f is a pattern that’s too broad. A pattern like pkill -f python stops every Python program running as your user, including tools you didn’t know were Python-based. Always test the pattern with pgrep -a first, and add -u to limit it to the user who owns the job.

For heredocs in scripts, quote the marker (<< 'EOF') unless you specifically need variable expansion. An unquoted heredoc that contains a $ meant for the config file, such as a password or a Nginx variable like $host, gets silently replaced with an empty string, and the result is a config file that looks fine but doesn’t work.

Finally, remember that mkdir -p only applies the -m permission option to the last directory it creates, while the parents get your default permissions.

If you need a whole path created with specific permissions and ownership, install -d -m 750 -o tecmint -g tecmint /path/to/dir is the more predictable choice.

Conclusion

You now have five commands that each replace a multi-step routine: mkdir -p with brace expansion for directory trees, heredocs with cat or sudo tee for files, tar -C for extracting archives anywhere, pgrep and pkill for finding and stopping processes by name, and pidwait for running a command once a process finishes. Each one makes your scripts shorter and removes chances for a typo along the way.

If you’d like to build more habits like these, our 100+ Essential Linux Commands course on Pro TecMint covers the everyday commands sysadmins rely on with practical examples.

When you’re ready to turn tricks like heredocs and brace expansion into full scripts, Bash Scripting for Beginners walks through scripting from the first line to error handling.

We’d love to hear which of these tips you already use and which one is new to you. Do you have your own one-liner that replaced a long routine on your servers?

Have you ever been caught by a pkill -f pattern that matched more than you expected? Share your favourite command-line shortcuts in the comments below.

The post 5 Useful Linux Commands Every Sysadmin Should Use appeared first on WEBNET Hosting.

To check your PHP version, open your hosting control panel or WordPress Site Health for a live website, or run the php -v command in a terminal on a server or your own computer. There are five main methods.

• Hosting control panel. Open the PHP information page, such as PHP Info in Hostinger dashboard.
• WordPress. Go to Tools → Site Health → Info → Server.
• phpinfo() file. Upload a one-line PHP file to your site and open it in a browser.
• Command line. Run php -v in a terminal (the app where you type commands).
• Local development environment. Run the PHP program that comes with your local tools.

Your live website, a server you manage remotely, and your own computer each have their own PHP, and the version a terminal shows doesn’t always match the one serving your site.

Once you know your version, compare it with the PHP versions that still receive security fixes and with your host’s security notices. Confirm that your site supports a newer version, such as 8.4, before you switch away from an outdated one.

We tested every method on October 22, 2026, on a Hostinger Unlimited web hosting plan with WordPress 7.1.3, a CloudPanel virtual private server (VPS) running Ubuntu 22.04, and a Mac.

How to check your PHP version in a hosting control panel

To check your PHP version in a hosting control panel, open the PHP information or PHP version page for your website. Hostinger users can follow the PHP Info instructions, while other hosting providers may use different menu names or provide separate PHP settings for each website.

Control panels read the version straight from the hosting server becausePHP (Hypertext Preprocessor) is a server-side scripting language that runs on the server, not in your visitor’s browser. This makes the panel a quick check that needs no code or commands.

PHP version numbers typically have three components. For example, in PHP 8.3.35, 8 is the major version, 3 is the minor version, and 35 is the patch release. Together, 8.3 identifies the PHP branch, while 35 identifies the specific release containing bug fixes and security updates.

Hostinger dashboard and cPanel (a third-party panel) keep the version in different menus.

Check your PHP version in Hostinger dashboard

In Hostinger dashboard, go to the PHP Info section of your website management, and the PHP version appears at the top of the page. You cancheck the PHP version in Hostinger this way for every website on your plan, except those built with Hostinger AI Builder.

1. Open Websites and click Dashboard next to your site.
2. In the sidebar, go to Advanced → PHP Info, or type PHP Info in the sidebar search.
3. Check PHP Version at the top of the page. A few rows below, Build Date shows when this copy of PHP was built.

In the same Advanced menu, PHP Configuration shows only the branch you selected, such as PHP 8.3. Use PHP Info when you need the exact release and build date, for example, to confirm that a security fix reached your site.

For WordPress sites, WordPress → Overview shows the branch on the PHP Version card, so you can check it without opening the WordPress admin dashboard. When Hostinger recommends a newer version, the card shows it with a Change button.

See how to check and change your PHP version in Hostinger dashboard in this video:

Subscribe For more educational videos!
Hostinger Academy

Subscribe

Check your PHP version in cPanel

In cPanel, check your PHP version under Software → MultiPHP Manager or Software → Select PHP Version, depending on which tool your hosting provider enables.

• MultiPHP Manager. Lists each domain in your account next to its PHP version. Inherited means the domain takes its PHP version from an .htaccess settings file in its folder or a parent folder. The domain uses the server’s default when no file sets one.
• Select PHP Version. Shows the PHP version selected for your cPanel account in the Current PHP version dropdown menu. A domain uses this version only when its MultiPHP Manager setting matches the server’s default. Hostinger’s cPanel hosting uses this tool, which comes with the CloudLinux server operating system.

Both tools list versions by branch, such as 8.3, and neither shows a build date. For the exact release, open a phpinfo() file in the website’s folder.

How to check your PHP version in WordPress

To check your PHP version in WordPress, open Site Health from the Tools menu, where the Server section lists the PHP version that runs your site. We tested these steps on WordPress 7.1.3.

1. Log in to the WordPress admin dashboard with an administrator account, because only administrators can open Site Health.
2. Go to Tools → Site Health and open the Info tab.
3. Expand the Server section and find the PHP version row.

The PHP version row shows the exact release, such as 8.4.26. It doesn’t show the build date, so use PHP Info or a phpinfo() file when you need it.

Site Health reads these values from the PHP that loads your dashboard, so they match your live website. The PHP SAPI row confirms it by naming the Server Application Programming Interface (SAPI), which is how PHP connects to your web server, such as litespeed or fpm-fcgi.

The Status tab on the same screen also flags outdated PHP versions and lists a version that no longer receives security updates as a critical issue.

WP-CLI, WordPress’ command-line tool, reports a different PHP: its wp cli info command shows the PHP WP-CLI runs on. On our test site, the command-line PHP version was 8.3.35, while Site Health showed 8.4.26.

How to check your PHP version in a web browser using phpinfo()

To check your PHP version with phpinfo(), upload a one-line PHP file to your website’s folder and open it in a browser. The PHP Version line sits at the top of the page.

phpinfo() is a built-in function of the PHP scripting language that prints your PHP settings. It works on any host that lets you upload and run PHP files, unless the host turns the function off. Use it as a fallback when your hosting panel doesn’t show PHP information, or when you need to check a folder or subdomain that runs its own PHP version.

1. Open your website’s folder, such as public_html, in your host’s File Manager or a File Transfer Protocol (FTP) client.
2. Create a phpinfo file and add random characters to its name, such as info-7f3k.php. Avoid common names like info.php or phpinfo.php, because automated scanners look for them. Add this code:

<?php
phpinfo();

3. Open https://domain.tld/info-7f3k.php in your browser, replacing domain.tld with your domain.
4. Check PHP Version at the top and Build Date in the table under it.
5. Delete the file.

To print only the version number, use this code instead:

<?php
echo PHP_VERSION;

The page then shows a single line, such as 8.3.35, without your server’s settings. Delete this file after the check as well.

How to check your PHP version using SSH or the command line

To check your PHP version using Secure Shell (SSH) or the command line, run php -v in a terminal on your computer or in an SSH session on your server:

php -v

The first line of the output shows the version, how PHP is running, and the build date, for example, PHP 8.3.35 (cli) (built: Oct 21 2026 00:00:00). Here, cli stands for command-line interface (CLI), the PHP program your terminal runs.

On a remote server, connect through SSH first, which gives you an encrypted command line on that server. On Hostinger web hosting, search for SSH Access in your website’s sidebar, turn it on, and copy the IP address, port, and username shown there.

Then connect from your terminal, replacing the placeholders with those values, and run php -v:

ssh -p port-number username@server-ip

Turn on SSH Access before connecting; otherwise, the connection closes right after you enter your password with the message “/sbin/nologin: No such file or directory.” We ran into this during testing, and enabling SSH Access fixed it.

To print only the version number, for example in an automated task, use this command instead:

php -r 'echo PHP_VERSION, PHP_EOL;'

Both php -v and php -r check only the command-line PHP. Tools like Composer (which installs PHP code libraries) and WP-CLI use the same PHP, as do scheduled tasks that run a PHP command.

Your website doesn’t necessarily use the same PHP. A separate program called a PHP handler serves your website’s visitors by running PHP for your web server. Tasks triggered through a web address use it too.

Examples include PHP-FPM (short for FastCGI Process Manager) and the LiteSpeed Web Server’s own PHP, which Hostinger web hosting uses. The handler and the CLI are separate programs, so each runs its own PHP version.

Servers often keep several PHP versions side by side: our CloudPanel VPS had 10, and our Hostinger web hosting server had 17. On Debian and Ubuntu (two Linux systems for servers), list the PHP settings folders, then run a specific version by name to confirm it’s installed:

ls /etc/php
php8.4 -v

To run a specific version on Hostinger web hosting, use its full folder path. The folders in /opt/alt list the extra PHP versions installed on the server:

ls /opt/alt | grep php
/opt/alt/php84/usr/bin/php -v

Check the PHP version your web server uses on a VPS

On a VPS that runs PHP-FPM, find which PHP-FPM version your site’s web server settings point to, then run that version with -v to see its exact release. That version, not the command-line PHP, runs your website.

This matters on servers with several PHP versions installed. On our test VPS, which runs the CloudPanel control panel, php -v returned 8.2.31, while the website ran on PHP-FPM 8.0.30, a branch that no longer receives security fixes from the PHP project.

These steps apply to Debian or Ubuntu servers where the nginx web server connects to PHP-FPM on the same machine, as in our test VPS.

1. Find which PHP-FPM address nginx uses by searching your site’s nginx settings for the fastcgi_pass line. The sudo prefix runs a command with administrator rights:

sudo grep -RHn '^[[:space:]]*fastcgi_pass' /etc/nginx/sites-enabled/

The result is either a socket file, such as /run/php/php8.3-fpm.sock, or a local address and port number, such as 127.0.0.1:15001. A socket file is how nginx and PHP-FPM talk on the same machine. Some setups use a server name or a group of servers instead.

Run sudo nginx -T to print all nginx settings and find your site’s fastcgi_pass line if the first command returns nothing for your site. That happens when the configuration file is located outside /etc/nginx/sites-enabled.

2. Match that address to a PHP-FPM version. For a socket, the default names on Debian and Ubuntu include the branch, such as php8.3-fpm.sock. For a port, run this command, replacing 15001 with your port number:

sudo ss -ltnp 'sport = :15001'

The process name in the result shows your branch when it includes a version, such as php-fpm8.0. Check the site with a phpinfo() file instead if the name has no version or your socket has a custom name.

3. Check the exact release of the installed PHP-FPM program:

php-fpm8.0 -v

These commands read the server’s settings and installed programs. To see the version your pages actually run on, open a phpinfo() file in the site’s folder.

How to check your PHP version in a local development environment

In a local development environment, run php -v with the PHP program that comes with your local stack (the tools that run websites on your computer), such as C:xamppphpphp.exe -v for XAMPP. XAMPP, MAMP, and Docker containers set up for PHP each come with their own copy, separate from any PHP installed on the rest of your computer.

A “command not found: php” message on macOS, or “‘php’ is not recognized as an internal or external command” on Windows, means PHP isn’t installed or its folder isn’t in your PATH.

According to thePHP manual’s macOS installation page, macOS hasn’t included PHP since macOS 12 Monterey. Our test Mac returned the same “command not found” message.

A local version tells you nothing about the PHP on your live website. Check the hosting side separately before you publish code that needs a newer branch.

Which PHP version is your website actually using?

Your website uses the PHP version your web server runs, which is the one your hosting panel, WordPress Site Health, or a phpinfo() file shows, not always the one php -v reports.

Each environment needs its own check:

• A live website. Use your hosting panel, WordPress Site Health, or a phpinfo() file.
• A server you manage. Run php -v for the CLI, then check the PHP handler configured for your website, such as PHP-FPM.
• Your computer. Run the PHP program from your local stack, such as XAMPP’s php.exe.

Only three methods show both the exact release and the build date, the two details that help you confirm a security fix.

In our Hostinger web hosting test, three checks reported PHP 8.3.35 with the same build date, but each used a different server API.

SSH showed Command Line Interface, the dashboard’s PHP Info showed CGI/FastCGI, and the phpinfo() file showed lsapi V8.3 CloudLinux 1.3, which is LiteSpeed’s connection. Of these three, only the phpinfo() file went through the same connection as your visitors, making it the closest check of how your live site runs.

Why does the PHP build matter for security patches?

The PHP build matters because security fixes don’t always change the PHP version number your server displays. On some hosts and Linux distributions, the build date or installed package version is the only sign that a fix is in place.

For example, php2shell is the name for two critical PHP security flaws disclosed on October 21, 2026. The public Common Vulnerabilities and Exposures (CVE) list tracks them as CVE-2026-109618 and CVE-2026-109619.

According to the PHP project’s security advisory, PHP 8.5.12, 8.4.27, 8.3.36, and 8.2.35 fix both flaws, and every PHP installation that serves web pages is at risk until it runs a fixed build. How you confirm the fix depends on where your PHP comes from.

On Hostinger web hosting, the build date is the detail to check. Our test site ran PHP 8.3.35, one release below the PHP project’s fix, and its Build Date read Oct 21 2026, the day the PHP project released the fix. The server’s PHP 8.4.26 build showed the same date.

According to Hostinger’s php2shell update, managed hosting received the fix in each existing version, and a build date of October 21, 2026, or later confirms this.

Ubuntu’s own PHP packages work the same way. According to Ubuntu’s php2shell notice, the fixed package for Ubuntu 24.04 is version 8.3.6-0ubuntu0.24.04.13, so php -v on a patched server still shows 8.3.6.

This command lists newer PHP packages available from your software sources on a Debian or Ubuntu server you manage. The list doesn’t say which updates contain a fix, so compare their versions with the security notice:

sudo apt update && apt list --upgradable 2>/dev/null | grep php

On our CloudPanel VPS, the list showed 8.2.35, 8.3.36, 8.4.27, and 8.5.12 waiting to be installed. Those are the PHP project’s fixed releases. Nothing appeared for the website’s PHP 8.0.

After installing an update, restart PHP-FPM so its running processes load the new build, replacing 8.3 with your branch:

sudo systemctl restart php8.3-fpm

Then check the version through your website again, because php -v alone doesn’t confirm what your pages run on.

What to do if your PHP version is outdated

To update an outdated PHP version, confirm that your site supports a newer branch, then switch to a branch that still receives security fixes.

According toPHP’s supported versions page, four branches receive security fixes from the PHP project as of October 2026:

PHP 8.2 stops receiving security fixes on December 31, 2026, so moving to PHP 8.3 or newer gives you more time before the next upgrade.

For WordPress sites, theWordPress requirements page recommends PHP 8.3 or greater.

Check four things before you switch branches:

• CMS core. Update WordPress or your other content management system (CMS) to its latest version.
• Themes and plugins. Check each developer’s documentation or release notes for support of your target branch. The Requires PHP field on WordPress.org only lists the minimum version.
• Custom code. Check the PHP requirement in your project’s composer.json file, where Composer lists it, and any code written for an older branch.
• Backup. Back up the site and, where possible, test the new branch on a staging copy (a private duplicate of your site).

Once these checks pass,change your PHP version in your control panel, or install the newer branch’s packages on a VPS.

On Hostingerweb hosting, PHP Configuration offers PHP 8.2 to 8.5, and the version you select applies to every website on your hosting plan except those built with Hostinger AI Builder.

The dashboard warns that switching stops all running processes on your site and takes 1–2 minutes to complete.

Hostinger installs security fixes, such as the php2shell patch, for your current version on every plan except VPS, but updating to a newer branch is up to you. On a VPS, you install all PHP updates yourself.

After switching, check the version again using Site Health, PHP Info, or a phpinfo() file to confirm that your website is running the new branch.

All of the tutorial content on this website is subject to

Hostinger’s rigorous editorial standards and values.

The author

Bruno Santana

Add Hostinger as a preferred source on Google

Bruno is a Content Writer at Hostinger, focused on creating and optimizing helpful, engaging articles about web development and marketing. With a background in journalism, he combines storytelling with practical insights to make complex topics easier to understand. He has also contributed to publications like MacMagazine and Jornal A Tarde. Outside of work, Bruno enjoys exploring art, cooking, and technology.

The post How to check your PHP version appeared first on WEBNET Hosting.

Please note that the features presented in this blog post are a preview. They’re still being worked on and are planned for the next version of Linux Mint.

Release Strategy and Development Cycle

This is the first time we’ve taken a full year to develop Linux Mint. Going from a 6-month release schedule to a yearly one was a tough decision to make, but we’re really starting to see it pay off. We’re taking on projects and implementing changes which would previously have been considered too large or ambitious. We’ve got time. We don’t feel rushed. Development feels solid and the OS keeps getting better.

I’ve been working on Linux Mint for more than 20 years now. I don’t think I’ve ever seen so many changes and new features implemented for a single release. It’s really exciting and it scares me a little bit because that also means we’re going to be very busy during the beta phase 🙂

Aside from new features, we’ve been fixing a huge number of bugs. We’ve also been working on Wayland compatibility, improving our processes and internal tools, and prototyping new editions.

Linux Mint 27 “Adrien”

Our next release is scheduled for Christmas, and it will be called Linux Mint 27 “Adrien”. 

I’ve really enjoyed using girls’ names since 2006. They gave each release an identity and made it feel much warmer than just a number. From “Ada” at the very start to “Zena” last year, we’ve now reached the end of the alphabet. It’s funny how this happened just as we’re moving to a new release schedule. I want to continue this tradition with the new series. This time we’re using boys’ names 🙂

As you can see, the release number represents the upcoming year. We’ll no longer use point releases, so the release after that will be 28. You’ll upgrade from 27 to 28 to 29, and so on.

Linux Mint 27 “Adrien” will be based on Ubuntu 26.04. It will be available in at least three editions: Cinnamon, Xfce and MATE.

Alarms

Alongside the new calendar, we’ve developed an application to manage alarms.

The application takes inspiration from Android, both in its interface and how it works.

It’s intuitive and really easy to use.

You can set recurring alarms, choose custom sounds, and receive notifications even when the application isn’t running.

This application is called “Clocks”. It is part of the Clockenstein project.

Alarm notifications are handled by the Clockenstein daemon and notification agent.

Other News

There’s a lot going on behind the scenes.

We’ve been working hard on three other projects, and we’re putting the finishing touches on them.

Next month we’ll talk about Superlight, Unfold, and Velocitty.

Sponsorships:

Linux Mint is proudly sponsored by:

A total of $13,824 were raised thanks to the generous contributions of 443 donors:

$580 (2nd donation), Christian S.
$250, Douglas R.
$232, Thorsten G. aka “JETI GMBH“
$200, Ranodhi S.
$174 (8th donation), Flavio Silva Pita Correia
$140, CHRIS P.
$140, flutttr
$116 (9th donation), Marco van den Berg
$116 (9th donation), Michael J.
$116 (4th donation), Jean-yves B.
$116 (3rd donation), Klaas M.
$116, B.A.J. S.
$116, Cristiano M.
$116, lars S.
$116, Radulescu V. G.
$116, Slavomír K.
$116, Thomas P.
$116, Ulrich R.
$104 (10th donation), Jorge R. R.
$100 (23rd donation), James F.
$100 (7th donation), Harrison W.
$100 (4th donation), David D.
$100, Chris H.
$100, DOUGLAS B. C.
$100, Joseph M.
$100, Logan E.
$100, Marcia A.
$100, Robert D.
$100, wayne G.
$93, Sebastian H.
$70 (6th donation), Marcus A.
$68, Zdzislaw K.
$64 (2nd donation), Mark W.
$58 (15th donation), Hermann W.
$58 (7th donation), António Salsinha – Graphic Designer
$58 (3rd donation), Andre B.
$58 (3rd donation), Christian G.
$58 (3rd donation), Simon D.
$58 (2nd donation), Dirk H.
$58 (2nd donation), Guido S.
$58 (2nd donation), Martin J.
$58 (2nd donation), Michel O.
$58 (2nd donation), Nima M.
$58,
$58, André B.
$58, anonymous
$58, Bernhard S.
$58, Bjorn H.
$58, Bodo S.
$58, DIEGO I. C.
$58, Emmanuel M.
$58, Felix
$58, Gerrit B.
$58, Giacomo B.
$58, Graham T.
$58, HANS H. H.
$58, hermann A.
$58, Loic A.
$58, Martin L.
$58, Martin Z.
$58, Matthias K.
$58, P.Knipe aka “pk21”
$58, Phil G.
$58, Pierre S.
$58, RENE G.
$58, Rene W.
$58, Robert S.
$58, roberto L.
$58, spaceghost2
$58, Stefan B.
$58, Steffen K.
$58, Sven G.
$58, Valentin B. aka “Vale”
$50 (24th donation), Mothy
$50 (20th donation), Anthony C. aka “Ciak”
$50 (16th donation), Robert D. aka “MacDhai“
$50 (9th donation), Derek S. aka “Corky357”
$50 (5th donation), Benjamin aka “bglamadrid”
$50 (5th donation), Mark H.
$50 (5th donation), Richard H.
$50 (5th donation), Sheila S.
$50 (4th donation), John M.
$50 (3rd donation), Michael R.
$50 (3rd donation), Mitchell L.
$50 (2nd donation), aka “dust788”
$50 (2nd donation), Andrew M.
$50 (2nd donation), Donald E.
$50 (2nd donation), Peter G.
$50, Alex K.
$50, Allan M.
$50, Doug M.
$50, Fred A. M.
$50, Fred M.
$50, Grey
$50, Harpreet S.
$50, Ian M.
$50, Janis A.
$50, Jeremy C.
$50, JOHN D.
$50, kevin K.
$50, kevin M.
$50, Robert S.
$50, Steve
$50, william R. S.
$50, William V.
$46 (2nd donation), Brian K.
$46, François L. H.
$46, Ulrik A.
$42 (2nd donation), Frank D.
$40 (7th donation), Peter J, aka “Dr Peter”
$40 (3rd donation), Chad B.
$35 (8th donation), Andrew E.
$35 (4th donation), Martin B.
$35 (2nd donation), Mark G.
$35, Dominique B.
$35, Dr. M. S.
$35, Egbert D.
$35, Mark V. L.
$35, Richard B.
$35, Stefan S.
$34 (9th donation), Olaf Bousche aka “Bushman”
$34 (4th donation), CercLL d’Entraide et Réseau Coopératif Autour des Logiciels Libres (LUG of Marseille, FR)
$34, Arnd W.
$30 (37th donation), Aimee W.
$30 (13th donation), Orlando O.
$30 (5th donation), John H.
$30, András P.
$30, Brent H.
$30, Javier R. P.
$30, Raleigh Y.
$30, Randy B.
$29 (3rd donation), Ruurd T.
$29 (2nd donation), Raul V.
$29, Joe aka “BeppePass”
$29, Mogg
$29, mr C. C.
$29, Myron A. S. A.
$29, Vincent M.
$28 (2nd donation), Paul S.
$25 (67th donation), Linux Mint Sverige
$25 (20th donation), Donna B.
$25 (20th donation), John N.
$25 (10th donation), Leela A.
$25 (9th donation), Oleksandr N.
$25 (7th donation), Nicholas B.
$25 (5th donation), Robert W.
$25 (5th donation), Theron K.
$25 (4th donation), Frank F.
$25, larry P.
$25, Patrick D.
$23 (81st donation), Bryan F.
$23 (75th donation), Peter E.
$23 (42nd donation), Stefan W.
$23 (37th donation), Benjamin W. aka “UncleBens”
$23 (15th donation), Wolfgang N.
$23 (14th donation), Provisorisch
$23 (13th donation), Joerg B.
$23 (10th donation), Harold H.
$23 (8th donation), Gunnar A.
$23 (7th donation), Robert J.
$23 (7th donation), Santiago
$23 (6th donation), Emil N. P.
$23 (6th donation), Haris A.
$23 (6th donation), Henning P.
$23 (6th donation), Jeff Daniels
$23 (6th donation), Kiaran Smyth.
$23 (5th donation), Matthias K.
$23 (5th donation), Reinhard R.
$23 (5th donation), Volker S.
$23 (4th donation), Drew C.
$23 (3rd donation), Markus S.
$23 (3rd donation), Michael C.
$23 (3rd donation), Sebastian M.
$23 (2nd donation), Franz F.
$23 (2nd donation), Klaus G.
$23 (2nd donation), Marco C.
$23 (2nd donation), Martin G.
$23 (2nd donation), Milan M.
$23 (2nd donation), Peter N.
$23 (2nd donation), Rachel
$23 (2nd donation), Robin Rijke aka “R²”
$23 (2nd donation), Thomas K.
$23, André C.
$23, Andrew C.
$23, Anthony K.
$23, Bodo I.
$23, David L.
$23, David R.
$23, dian I.
$23, Dirk S.
$23, Dr J. G. A.
$23, EDM
$23, Gediminas S.
$23, Johannes S.
$23, Luis D. F. C.
$23, Marcel H.
$23, moritz-markus U.
$23, Nándor H.
$23, Oliver A.
$23, Pawel
$23, Phil T. aka “archmintphil”
$23, Rainer K.
$23, REMI B.
$23, Renaud D.
$23, Rene M.
$23, Roland B.
$23, Rüdiger H.
$23, Thomas W.
$23, Timo S.
$23, Urs F.
$23, Vlad C.
$23, Wolfgang F.
$20 (122nd donation), Johann J.
$20 (56th donation), Stefan M. H.
$20 (32nd donation), Denis D.
$20 (22nd donation), Arvis Lācis aka “arvislacis“
$20 (17th donation), Michel S.
$20 (11th donation), Daniel V. M.
$20 (11th donation), Eric H.
$20 (9th donation), James N.
$20 (6th donation), Timothy A.
$20 (5th donation), Angel Cruz aka “Angel”
$20 (5th donation), Theodore K.
$20 (3rd donation), TMCC
$20 (2nd donation), eric E.
$20 (2nd donation), Keith S.
$20 (2nd donation), Kevin P. M.
$20 (2nd donation), Scott B.
$20, ADEBAYO I.
$20, Ali S.
$20, Andre P.
$20, Brian F.
$20, brian M.
$20, Chris P.
$20, christian S.
$20, David A.
$20, David K.
$20, Farrell P.
$20, GEORGEL P.
$20, Howard E.
$20, iain K.
$20, Jorge G.
$20, Jose V.
$20, Kevin H. aka “kjh7796“
$20, louis V.
$20, Malcolm T.
$20, Maros J.
$20, Matthew B.
$20, Michael M.
$20, Michael R. M.
$20, Michael S.
$20, Monica R.
$20, Pete W.
$20, Richard C.
$20, Sidney E. D.
$20, Simon K.
$20, Thomas S.
$20, Timothy C.
$20, Tristan C.
$17 (96th donation), Andreas S.
$17 (12th donation), Ivan Stamenov
$17 (5th donation), Christoph D.
$17, Ivan P. I.
$17, Luca D.
$17, Tomasz S.
$15 (2nd donation), Russell R.
$15, Ashton C.
$15, Dmitrii S.
$15, Nieminen M.
$14 (30th donation), aka “AsciiWolf”
$14, Florian J.
$14, Viktor B.
$13 (22nd donation), Alessandro S.
$13, Luca S.
$13, Zodiac M.
$12 (53rd donation), Tugaleres.com
$12 (52nd donation), Thomas Rehm
$12 (21st donation), Abe Z.
$12 (19th donation), Artem Ignatyev aka “ZaZooBred”
$12 (17th donation), Gabriele I.
$12 (9th donation), Iker P. M.
$12 (9th donation), Sergei Petrov
$12 (8th donation), Lyuben R.
$12 (8th donation), Marcos P. G.
$12 (7th donation), Claudio A.
$12 (7th donation), Kai Uwe Joppich
$12 (6th donation), Alf-ivar O.
$12 (6th donation), Olivier R.
$12 (6th donation), Tomasz S.
$12 (4th donation), Koski M. K. aka “Wintageman“
$12 (4th donation), MAH aka “Myne”
$12 (4th donation), Patrick B.
$12 (3rd donation), Bojan M.
$12 (3rd donation), David K.
$12 (3rd donation), Georgi P.
$12 (3rd donation), Hamish M.
$12 (3rd donation), Hans-peter W.
$12 (3rd donation), Jarmo K.
$12 (3rd donation), Jose Vicente M.
$12 (3rd donation), persson M.
$12 (2nd donation), Andrea Corinti aka “Xab“
$12 (2nd donation), Bartosz W. aka “barthossius”
$12 (2nd donation), Fenyvesi K.
$12 (2nd donation), Johann K.
$12 (2nd donation), Massimo D.
$12 (2nd donation), Michal L.
$12 (2nd donation), Patric E.
$12 (2nd donation), Viktor S.
$12 (2nd donation), Vlad M.
$12, Adrian Z.
$12, aldo L.
$12, Anders K.
$12, antonello B.
$12, ATHOS R. J.
$12, Berth V. D. H.
$12, Charles S.
$12, Coun P.
$12, Erwin G. W.
$12, Fernando L.
$12, Francesc J. M. M.
$12, Francesco L.
$12, Fredrik G.
$12, Gavino G. B.
$12, George W.
$12, Gianni G.
$12, Hartmut L.
$12, J K.
$12, Jacek G.
$12, Jack A.
$12, Jan B.
$12, Joana B.
$12, laas
$12, Lars M.
$12, Luuk D. V.
$12, Marc M.
$12, Mátyás H.
$12, Micha S.
$12, Murat Y.
$12, PapelDigital
$12, Paulo S. C.
$12, Peter K.
$12, Peter W.
$12, Rauno S.
$12, Reimund J.
$12, Vasilis G.
$12, Walter R.
$12, Wojciech G.
$10 (126th donation), Thomas C.
$10 (67th donation), Philip Woodward
$10 (21st donation), Thevirtua
$10 (17th donation), Mariusz B.
$10 (11th donation), Korora Solutions
$10 (11th donation), Tomasz K.
$10 (8th donation), Michał K. aka “PoldekPL”
$10 (7th donation), Jordan S.
$10 (4th donation), William P.
$10 (3rd donation), Grace Faith Jack
$10 (3rd donation), Saeed R.
$10 (2nd donation), Ann S.
$10 (2nd donation), Cephus Jones aka “Cephus”
$10 (2nd donation), Clay
$10 (2nd donation), MARCELO F. D. F.
$10 (2nd donation), matthew V.
$10 (2nd donation), Reynaldo M. M.
$10, Caeden S.
$10, Christopher Y.
$10, Clinton H. E.
$10, Diego F.
$10, Hassan A.
$10, Joel L.
$10, John S.
$10, K P.
$10, Leonardo A.
$10, Levente T.
$10, Maome G.
$10, Nikhilesh B.
$10, Olivia J.
$10, Pedro M.
$10, Peter B.
$10, sanjay S.
$10, Scott K.
$10, Taxestoday aka “Shafi Afridi“
$10, THOMAS K.
$10, Walt B.
$10, Walter G. V.
$10, William W.
$9, Kristýna V.
$7 (2nd donation), M. B. S. aka “Meni”
$7, Diego A. O.
$7, Todd H.
$197 from 51 smaller donations

If you want to help Linux Mint with a donation, please visit https://www.linuxmint.com/donors.php

Patrons:

Linux Mint is proudly supported by 2,408 patrons, for a sum of $5,227 per month.

To become a Linux Mint patron, please visit https://www.patreon.com/linux_mint

The post Monthly News – September 2026 appeared first on WEBNET Hosting.

If you have used an AI chatbot for Linux work, you have probably had it tell you exactly which nmcli command to run, and then you still had to open a terminal and type it yourself.

The assistant understands the task, but it has no way to reach into the system and carry it out, so you end up doing the last and most important step by hand.

That gap is exactly what openKylin 3.0 is trying to close, which is an open-source Linux distribution developed in China, incubated and operated by the OpenAtom Open Source Foundation, and this release puts an AI agent inside the operating system itself.

It introduces KylinBot, an AI agent framework, and Xiao K, an AI assistant that can control system settings like Bluetooth, Wi-Fi, display brightness, and input devices via voice or text commands.

What makes this more than another chatbot is the way the agent talks to the desktop, means agents call desktop capabilities through the MCP protocol instead of simulating clicks, where MCP (Model Context Protocol) is an open standard that lets an AI model call tools in a structured and predictable way.

In this review, we will look at how that works, install the release, test the agent the way a sysadmin would test any new automation tool, and then decide whether it deserves the “smartest AI Linux desktop” label.

How openKylin 3.0’s AI Agent Works

Before installing anything, it’s worth understanding how the AI pieces connect to the system, because that explains both what the agent can do well and where you should be careful with it later in the review.

KylinBot is the agent framework that does the reasoning, and Xiao K is the graphical assistant you type or speak to. According to the project, KylinBot can understand requests through voice and text, keep context across multiple rounds of conversation, and use system capabilities to carry out tasks.

To reach those capabilities, it integrates Kylin-CUA, a computer-use automation tool that gives it access to system settings and device management.

The desktop side of the connection is handled by UKUI (Ultimate Kylin User Interface), openKylin’s own desktop environment. UKUI 4.24 standardizes the APIs across its modules and integrates KACP (Kylin Agent Control Protocol), so KylinBot can reach underlying desktop capabilities through unified APIs.

The layout below shows how a request travels from you down to the system.

Because the agent works through these APIs, openKylin can let other agents plug into the same layer such as KylinBot, WorkBuddy, OpenClaw, and Raccoon Work can all run on openKylin 3.0, and the project says third-party agents get the same system access as its own.

Each specific task the agent can perform is packaged as a skill, which is a small, self-contained description of one job and the system interfaces it needs, and we will look at those skills directly in the hands-on section.

What’s New in openKylin 3.0 Beyond the AI Agent

The AI agent sits on top of a heavily updated base system, and those lower layers matter just as much if you plan to build software or run scripts on this release.

• openKylin 3.0 moves the kernel from Linux 6.6 straight to Linux 7.0, along with GCC 15, glibc 2.42, LLVM 22, and JDK 25, and more than 180 core components upgraded around the new kernel.
• The release integrates the three NIST post-quantum cryptography standards (ML-KEM, ML-DSA, and SLH-DSA) through the openHiTLS cryptography suite.
• With UKUI 4.24, you can make a fist to take a screenshot, wave your hand to turn pages or adjust volume, and use global voice input to issue commands, and Kylin uses the webcam to capture those hand gestures.
• kylin-time replaces the legacy time utility, kylin-wget replaces the classic wget, and kylin-ki18n replaces ki18n, all rewritten in Rust to reduce memory-safety bugs such as buffer overflows.

We will check how these replacements are installed in Example 4, since a rewrite can behave slightly differently from the tool your scripts expect.

Install openKylin 3.0 or Upgrade From the Beta

Now that you know what the release contains, the next step is getting it onto a machine, and the first thing to plan for is the download size. The ISO is a little over 7 GB, mainly because the OS comes with pre-installed AI models, so you will need a USB stick of at least 8 GB and some patience on a slower connection.

For a first look, a virtual machine is the safest place to start, and we gave ours 4 CPU cores, 8 GB of RAM, and 60 GB of disk, since the bundled models and the agent run alongside the desktop.

Keep in mind that a virtual machine has no real Wi-Fi or Bluetooth radio, so the network and Bluetooth skills are best tested on a laptop, which is why Example 2 later runs on real hardware.

If you plan to install on bare metal, check your hardware first, because the project publishes hardware compatibility lists for x86, ARM, LoongArch, and RISC-V in its download page.

Verify and Write the ISO to a USB Drive

Once you have downloaded the x86_64 desktop ISO from the openKylin download center, it’s a good idea to confirm the file isn’t corrupted before writing it, since a damaged 7 GB download usually fails halfway through the installer with no clear error.

Generate its checksum with sha256sum and compare the long string in the output with the SHA256 value published on the download page.

sha256sum openKylin-3.0-*.iso

With the ISO verified, find your USB drive’s device name with lsblk and write the image with dd.

lsblk
sudo dd if=openKylin-3.0-*.iso of=/dev/sdX bs=4M status=progress oflag=sync

Replace /dev/sdX with your USB device, such as /dev/sdb. If you prefer a graphical tool, balenaEtcher or GNOME Disks do the same job.

During installation, we created the user tecmint and placed the VM on a host-only network at 192.168.56.20, which lets us run checks from the host later if needed.

Upgrade an Existing 3.0 Beta Installation

If you are already running the 3.0 Beta, you can skip the reinstall entirely, because openKylin uses the familiar APT and dpkg package tools and the project documents a standard APT upgrade for Beta users:

sudo apt update
sudo apt upgrade

The Update page in System Settings does the same thing if you prefer the graphical route.

Testing openKylin 3.0 From a Sysadmin’s Point of View

With the system installed, we can start testing, and the approach here is the same one you would use for any new automation tool, which is to give it a task and then confirm the result independently from the terminal.

The first example doesn’t involve the AI at all, since it’s worth confirming the base system before trusting anything built on top of it.

Example 1: Confirm the Linux 7.0 Kernel and Toolchain

Open a terminal on the freshly installed system and check the release and kernel version:

cat /etc/os-release
uname -r

The os-release file should identify the system as openKylin 3.0, and the kernel string from uname -r should start with 7.0. The exact suffix after that varies with the build and any updates you have applied, so don’t worry if it doesn’t match another system exactly.

Since the new toolchain matters for anyone compiling software, check the compiler and C library next:

gcc --version
ldd --version

Look for GCC 15 on the first line of the gcc output and glibc 2.42 on the first line of the ldd output. This has one practical consequence worth remembering, which is that a binary you compile here and copy to an older distribution may refuse to start with an error like version 'GLIBC_2.42' not found, because programs linked against a newer glibc can’t run on systems with an older one.

Example 2: Let Xiao K Change Network and Bluetooth Settings

The first example confirmed the foundation, so now we can test the feature that sets openKylin apart. For this one, we moved to a laptop, because the skills involved need real radios. Among the built-in skills, there is deep integration with NetworkManager to manage Wi-Fi, Ethernet, and VPNs, plus Bluetooth toggling, device discovery, and automatic audio device pairing.

Before asking the assistant to do anything, record the current state of both radios, so you have something to compare against once the agent has finished:

nmcli radio wifi
bluetoothctl show | grep Powered

Now open Xiao K and type a plain request such as “Turn off Bluetooth and switch Wi-Fi off“. Once the assistant reports that it has finished, run the same two commands again.

If the agent did its job, nmcli radio wifi now prints disabled and bluetoothctl reports Powered: no. It’s worth doing this check every time you try a new skill, because an assistant saying it changed something and the system actually changing are two separate things, and the terminal is the reliable witness.

If you are testing in the VM instead, you can try the same idea with the wired connection by asking Xiao K to disconnect it and then running nmcli device status. Do this from the VM’s own console rather than over SSH from 192.168.56.1, since disconnecting the network will also cut your SSH session.

Example 3: Explore and Customize Skills From the openKylin-skills Repository

The agent in Example 2 relied on built-in skills, and since those skills are shared in a public Git repository, you can read how they work before letting the agent run them on your system.

Clone the repository from Gitee and look at its layout:

git clone https://gitee.com/openkylin/openkylin-skills.git
cd openkylin-skills
ls

Each skill describes what the agent is allowed to do and which system interfaces it calls, so this is the best place to learn the format before writing your own.

The project encourages this, since developers can build skills with a unified AI SDK and submit them to the openKylin-skills repository. One limitation to expect is that the repository is in Chinese, so you may need a translation tool to follow the skill descriptions for now.

To customize the agent for your own environment, a sensible first skill is something narrow and read-only, such as reporting disk usage with df -h or listing failed services with systemctl --failed.

Starting with read-only skills lets you learn how the agent interprets requests before you give it anything that can change the system, in the same way we verified its changes in Example 2.

Example 4: Check Which Tools Were Replaced by Rust Versions

The earlier examples focused on the AI features, but the Rust rewrites mentioned earlier can quietly affect scripts you bring over from other distributions. To see what wget actually points to on this system, follow any symlinks to the real binary and then ask dpkg which package owns it:

readlink -f "$(which wget)"
dpkg -S "$(readlink -f "$(which wget)")"

If the owning package is kylin-wget rather than the classic wget package, test your download scripts carefully, since a rewrite can differ in rarely used options and in the exact wording of error messages that some scripts parse.

Verdict: Is openKylin 3.0 the Smartest AI Linux Desktop Yet?

After testing the base system, the agent, and the skills, the answer depends on what you mean by “smartest“. For letting an AI agent change real system settings through proper desktop APIs, openKylin 3.0 is the most complete option available on Linux right now, and the fact that third-party agents get the same access makes it more open than a single-vendor assistant.

The weaker points are practical ones. The skill ecosystem is mostly documented in Chinese, the 7 GB ISO is heavy, and the Token Center login raises fair questions about where your prompts go.

For privacy-focused users or production servers, a mainstream distribution with a local model that you control is still the safer choice, while openKylin 3.0 is well worth a weekend on a spare laptop if you want to see where desktop AI is heading.

We’d love to hear how you would use an AI agent that can change your system settings. Would you give it access to network and Bluetooth controls on a work laptop, or keep it limited to read-only skills?

Have you tried writing a custom skill for KylinBot yet? And if you installed openKylin 3.0 on real hardware, feel free to share your machine model and any errors you ran into in the comments, so other readers can learn from them.

The post openKylin 3.0 Review: Is This the Smartest AI Linux Desktop Yet? appeared first on WEBNET Hosting.

The best AI for solopreneurs includes Hostinger Agent for covering several business functions, ChatGPT for general assistance, Perplexity for source-backed research, and Zapier for straightforward workflow automation. Notion AI and Fathom fill more specialized roles in operations, meetings, long-form work, and customizable automation.

Each covers a different part of running a one-person business, so the best choice depends on where you need the most support.

Here are the best AI tools for solopreneurs compared side by side:

1. Hostinger Agent – Best for managing multiple business functions

Hostinger Agent is a business-focused platform with seven specialized assistants: Business Advisor, Creative Writer, SEO Consultant, Marketing Planner, Legal Advisor, Customer Comms, and Sales & Outreach. That breadth suits solopreneurs who need structured support across several business functions without having to open a different general chatbot for each task.

If you’re launching a new service, you can use it to develop the offer and pricing, then carry that work into keyword research, website copy, lead generation, and outreach.

Because the work stays in the same conversation, Hostinger Agent can use the context from earlier stages as you move through the project.

More than 150 guided skills turn common business tasks into step-by-step workflows, including business planning, audience definition, SEO audits, campaign creation, outreach, and customer communication.

Select what you want to accomplish and follow the workflow to provide the relevant information and produce a usable starting point.

Hostinger Agent also connects to more than 1,000 apps, including Gmail, Google Sheets, Notion, HubSpot, and Google Calendar.

With your approval, it can use information from connected apps to add leads to a CRM, update a Google Sheet, create calendar events, or send follow-up emails.

Hostinger Agent strengths

• Keeps context as you move through different stages of a project, making it useful for workflows spanning several business functions.
• Guided skills provide structure for unfamiliar tasks, so you don’t need to know every step of the process before getting started.
• Can carry approved tasks into connected apps, which reduces manual handoffs between researching, creating, organizing, and acting on information.
• Supports recurring tasks and scheduled jobs, taking routine work off your daily to-do list.

Hostinger Agent limitations

• Important outputs still require human review, especially legal documents, pricing recommendations, business strategy, factual claims, and sensitive customer communications.
• The 1,000 monthly credits can limit how much you use the agent, particularly if it becomes part of several recurring business workflows.
• Its broad business coverage may be less suitable when you need advanced features from a specialized tool, such as dedicated CRM, SEO, or analytics software.

Hostinger Agent pricing

New users can try Hostinger Agents with 200 credits. Paid plans start at $6.99/month with a 12-month term. The three-month option costs $7.99/month, while the monthly option costs $9.99/month. Plans include 1,000 credits per month, 150+ skills, and access to 1,000+ app integrations.

Best for: Solopreneurs building anAI tool stack to support planning, marketing, lead generation, sales, and customer communication across a consulting, freelance, coaching, agency, or other online service business.

2. ChatGPT – Best general-purpose AI assistant

ChatGPT is a general-purpose AI assistant that can help you plan, research, analyze information, solve problems, and create business materials through conversation.

Starting a consulting business, for example, could involveusing AI for business planning, then uploading your customer research to identify common needs, compare service ideas, work through pricing options, and turn your decisions into a launch plan.

For ongoing work, Projects let you keep related chats, files, and instructions together. You could create one for your business and add customer research, product or service information, brand guidelines, and other reference materials.

ChatGPT can then use that context when you return with a new task, such as analyzing customer feedback or planning your next campaign.

You can also use ChatGPT for work that requires more than a standard conversation. Deep research can gather and synthesize information from multiple web sources, while data analysis can examine uploaded spreadsheets and turn the data into calculations, tables, or charts.

For tasks you do regularly, you can create a custom GPT that follows the same instructions each time. Scheduled tasks can automatically run prompts at set times, such as preparing a weekly business summary or reminding you to follow up with leads.

ChatGPT strengths

• Works well for tasks that develop through discussion, allowing you to question assumptions, compare options, and refine an idea over several exchanges.
• Projects give ongoing business work a shared context by keeping relevant conversations, files, and instructions together.
• Can work directly with documents, spreadsheets, images, and other uploaded information, which is useful when you need to analyze your own business data.
• Custom GPTs and scheduled tasks can turn instructions you use repeatedly into reusable or recurring workflows.

ChatGPT limitations

• You need to provide enough business context and clear instructions to get specific, useful responses. Vague prompts can produce generic recommendations.
• Important facts, calculations, recommendations, and other generated information should be checked before being used to make business decisions.
• Some capabilities have lower limits on the Free plan, including file uploads, data analysis, deep research, and memory.

ChatGPT pricing

ChatGPT has a free plan with access to its core AI model, web search, file and image uploads, data analysis, and image generation, although some features have usage limits. Paid individual plans start at $8/month for Go, $20/month for Plus, and $100/month for Pro.

Higher tiers offer higher usage limits and expanded access to features such as advanced reasoning, in-depth research, memory, and data analysis.

Best for: Freelancers, consultants, coaches, creators, and other solopreneurs who need a flexible assistant for research, planning, analysis, problem-solving, and everyday business tasks.

3. Perplexity – Best for research

Perplexity is an AI-powered search engine that browses the web, combines information from multiple sources, and returns answers with citations.

Say you’re considering adding a new service to your business. You can use Perplexity to research demand, identify competitors, compare how they position and price similar services, and investigate market trends.

You can then follow the citations to check the evidence behind the findings before deciding whether the opportunity makes sense for your business.

This source-first approach is also useful when you’re entering an unfamiliar market or need to get up to speed quickly on a topic.

You can ask follow-up questions to narrow the research, compare information across sources, and investigate individual claims without manually starting a new search each time.

For more complex questions, Perplexity’s Research mode can carry out multi-step research and produce a more comprehensive report.

This can help with tasks such as comparing several competitors or investigating a market from multiple angles.

Perplexity strengths

• Provides citations with its answers, making it easier to trace information back to the original source and verify important claims.
• Synthesizes information from multiple web sources, which is useful when comparing competitors, markets, products, or industry developments.
• Supports follow-up questions, so you can progressively narrow a broad research question as you learn more about the topic.
• Research mode can investigate more complex questions that require multiple searches and sources.

Perplexity limitations

• A citation doesn’t guarantee that the source is reliable or that Perplexity has interpreted it correctly, so you still need to inspect important sources yourself.
• Research findings can provide evidence for a business decision, but you still need to judge how relevant that information is to your customers, market, and circumstances.
• The free plan is useful for light research but currently limits advanced usage to three Pro Searches per day and one Research query per month. Frequent competitor or market research may therefore justify a paid plan.

Perplexity pricing

Perplexity has a free Standard plan with basic searches and limited access to advanced research features.

Paid individual plans include Pro at $20/month and Max at $200/month. Pro increases access to Pro Search, Research, advanced AI models, and file analysis, while Max provides higher limits for intensive use.

Best for: Solopreneurs launching into a new market, developing a new offer, or regularly researching competitors and industry developments.

4. Notion AI – Best for operations and knowledge management

Notion AI brings AI into the same workspace where you manage projects, notes, documents, databases, and other business information. This makes it useful for solopreneurs who use Notion as a central hub for organizing their work.

Say you manage client projects in Notion. After a client call, Notion AI can summarize your meeting notes and identify action items. You can then use those notes alongside the existing project information to draft next steps, update project documentation, or prepare a follow-up.

It can also help you retrieve information you’ve already saved. If you need to remember what a client requested several weeks ago or find a decision buried in project notes, you can ask a question and have Notion AI search the relevant workspace content for the answer.

This becomes more useful as you accumulate customer research, project documentation, content plans, and other business knowledge.

Beyond individual tasks, Notion includes AI features for recurring operations. AI Meeting Notes can capture and summarize meetings, while database automations can process data when changes occur in a database.

Higher-tier plans also include Custom Agents for recurring workflows, such as compiling project updates or organizing new information.

Notion AI strengths

• Works directly with the notes, documents, databases, and project information already stored in your workspace.
• Makes it easier to find and summarize information across a growing collection of business pages.
• Can turn meeting notes and project updates into summaries, action items, and follow-up work.
• Combines AI with databases and automations, which is useful for keeping recurring operational work organized.

Notion AI limitations

• It is only useful if you already use Notion, or plan to centralize a meaningful part of your business there.
• Notion AI has usage allowances even on the Business plan. Some features can temporarily pause if you reach the rolling six-hour or monthly allowance.
• Custom Agents are not included in the regular AI allowance. They use separate Notion credits based on how much information they process, how many steps they perform, and how often they run, so recurring automations can add to your monthly cost.

Notion AI pricing

Notion has a free plan for individuals that includes basic forms and sites, Notion Calendar, databases with subtasks and custom properties, and a limited trial of Notion AI. Plus costs $9.50/member/month, and Business costs $19.50/member/month when paid monthly. The Business plan includes Notion Agent, AI Meeting Notes, Enterprise Search, and Research mode. Custom Agents use separate Notion credits at $10 per 1,000 credits.

Best for: Solopreneurs who already manage projects, notes, client information, content plans, or business documentation in Notion and want AI to work directly with that existing workspace.

5. Fathom – Best for meetings and follow-ups

Fathom is an AI meeting assistant that records and transcribes calls, creates summaries, identifies action items, and lets you search across past conversations.

For a solopreneur, that can be useful during sales calls, discovery calls, client meetings, or interviews.

Along with otherAI tools for sales, Fathom can reduce the work around these conversations by capturing what was discussed and turning it into summaries and action items you can use for the next step.

For example, after a client meeting, you can review the transcript, pull out commitments and next actions, and use the generated follow-up email as a starting point.

Fathom also lets you search meetings by attendee or keyword and use Ask Fathom to find specific details from any previous call.

Its integrations can extend that workflow beyond the meeting itself. Fathom supports CRM sync and connects with tools such as Zapier, Make, ChatGPT, and Claude, while its public API and MCP support allow meeting information to feed other workflows.

Fathom strengths

• Creates transcripts, summaries, and action items automatically, so you don’t have to take detailed notes during meetings or manually turn them into a list of next steps afterward.
• It allows you to search past calls and find specific decisions, commitments, or discussion points without replaying the full recording.
• Integrates with CRM, project management, automation, and AI tools, which makes it easier to continue the workflow after the call.
• The Free plan includes unlimited recordings and transcriptions, which is useful if you have frequent meetings but do not need advanced features.

Fathom limitations

• You still need to check summaries and action items before relying on them for important commitments, pricing, deadlines, or customer requests.
• Recording meetings can create privacy and compliance concerns, particularly when calls contain customer or confidential business information, and you may need participants’ consent before recording.
• More advanced features, such as AI-generated action items, advanced summaries, and a conversational meeting assistant, require the Premium plan.

Fathom pricing

Fathom has a free individual plan with unlimited recordings, transcriptions, and instant AI summaries.

Premium costs $16/month and adds advanced summaries, AI-generated action items, and the conversational meeting assistant. Team plans start at $15/user/month with a minimum of two users.

Best for: Consultants, coaches, freelancers, recruiters, and other solopreneurs who spend a large part of their week on client, sales, discovery, or interview calls.

6. Zapier – Best for easy workflow automation

Zapier is a workflow automation platform that connects the apps you use so recurring tasks can move from one tool to another automatically.

A Zapier workflow starts with a trigger, such as a customer submitting a form, followed by one or more actions. For example, when a new lead fills out your contact form, Zapier can add their details to your CRM, categorize the inquiry, and create a follow-up task for you.

You can build similar workflows around other repetitive parts of your business. Zapier can turn form responses into tasks, send information between your business apps, categorize customer inquiries, or generate social media copy when new content is published.

AI can be added to individual steps when the workflow needs to summarize, classify, or draft information.

For a solopreneur, the main advantage is that these workflows can connect tools you already rely on. Zapier supports more than 9,000 apps and can also add AI steps for tasks such as summarizing, classifying, drafting, or making simple decisions inside a workflow.

Zapier strengths

• Connects with more than 9,000 apps, so you can automate work between many of the tools you already use.
• Can complete several steps from a single event.
• Can use AI within a workflow to summarize information, categorize requests, or generate text before passing the result to the next step.
• Lets you set conditions for what happens next, such as sending high-priority leads through a different workflow from general inquiries.

Zapier limitations

• Successful action steps generally consume tasks, so complex workflows can use the monthly allowance quickly.
• Automations still need review points when they affect customers, payments, contracts, or other decisions where an incorrect action could have serious consequences.
• Building reliable multi-step workflows takes some setup and testing, especially when several apps and conditions are involved.

Zapier pricing

Zapier has a free plan with 100 tasks per month. The Professional plan starts at $19.99/month and adds multi-step workflows, premium apps, webhooks, and other advanced automation features. Team plans start at $69/month.

Best for: Consultants, freelancers, agencies, and other service-based solopreneurs who use multiple apps and want to automate workflows such as adding new leads to a CRM, creating follow-up tasks, updating customer records, and sending information between tools.

How solopreneurs can use AI

Solopreneurs can use AI across business planning, research, marketing, content, SEO, sales, customer communication, admin, and legal support.

Common applications include:

• Business planning. Use AI to organize ideas, compare options, draft a business plan, test assumptions, and turn a broad goal into concrete next steps. You still decide which direction to pursue, what risks to take, and how much to invest.
• Market and competitor research. Ask AI to gather information about competitors, customer needs, pricing, industry trends, or unfamiliar markets, then compare findings across sources. Check the original sources before relying on the information for an important decision.
• Marketing. UseAI tools for marketing for campaign ideas, promotional copy, audience research, and adapting messages for different channels. You still decide which audiences to target, how to position your offer, and which campaigns are worth pursuing.
• Content marketing.AI for content marketing can help you research topics, build outlines, create first drafts, and repurpose existing content into different formats. Review the final content for accuracy, usefulness, brand voice, and anything that requires your own expertise or experience.
• SEO. Use AI to research keywords, analyze competing pages, identify content gaps, and find opportunities to optimize existing pages. Whenusing AI to improve SEO, review the recommendations against actual search results and your audience before deciding what to create or change.
• Lead generation and follow-up. AI can research prospects, summarize lead information, draft personalized outreach, prepare call notes, and suggest follow-up messages. Review anything customer-facing before sending it, especially when pricing, promises, or sensitive information are involved.
• Customer communication. Use AI to draft routine replies, summarize long email threads, categorize incoming requests, and prepare responses to common questions. Complaints, refunds, unusual requests, and sensitive conversations still need direct human judgment.
• Admin and recurring operations. Automate repetitive tasks such as converting form submissions into tasks, updating records after meetings, preparing recurring reports, or moving information between tools. Start with predictable workflows where you can clearly define the trigger, inputs, and expected result.
• Legal and administrative support. AI can help explain unfamiliar terms, organize requirements, summarize documents, or create a first draft of routine business materials. Treat the result as a starting point and get professional advice when a legal decision could materially affect your business.

Best practices for using AI as a solopreneur

A practical starting point is to automate low-risk backend work first, keep human approval at consequential decision points, protect customer data, and add complexity only when a workflow consistently removes manual work.

Automate backend work where mistakes are easy to spot and correct. Organizing information, summarizing documents, categorizing requests, transferring data between apps, creating first drafts, and preparing recurring reports are good starting points.

Be more cautious with customer communication, financial decisions, contracts, and other actions that can directly affect your business.

Build human approval into the workflow at important decision points. AI can prepare an email, proposal, campaign, analysis, or recommendation, but review it before it reaches a customer, triggers a payment, becomes part of an agreement, or influences a significant business decision.

The same caution applies tolegal AI tools, which can assist with research and documents but shouldn’t be the sole basis for consequential legal decisions.

Be selective about the business and customer data you give AI tools. Before connecting an app or uploading a file, check whether the information is actually necessary for the task. Review the tool’s privacy settings, data retention and training policies, and the permissions granted through integrations. Limit access to the data and actions the workflow genuinely needs.

Give AI reusable context about your business. Create a reference that covers your audience, positioning, preferred terminology, tone, examples of writing you like, and phrases or styles to avoid.

Reusing these instructions across content and communication tasks makes the output more consistent and reduces the need for repeated editing.

Avoid accumulating subscriptions with overlapping capabilities. Before paying for another tool, check whether something in your existing stack already handles the task, how regularly you will use the new capability, whether it can replace another subscription, and whether it connects with your current tools.

Understand a workflow before automating it. Complete the process manually enough times to identify its trigger, required inputs, decisions, expected output, and common exceptions. Then automate the predictable stages first.

This prevents you from spending time building a complex system around a process that is still changing.

Finally, judge an AI workflow by how much work it removes, not simply by whether the automation runs successfully.

Look for reductions in manual steps, context switching, repetitive writing, administrative work, and corrections. If maintaining, monitoring, or fixing the workflow takes about as much effort as completing the task manually, simplify it or stop using it.

For businesses juggling planning, marketing, sales, content, and customer communication, Hostinger Agent can handle several of these functions in a single platform.

If most of your work involves thinking through problems, analyzing information, and creating different types of material, ChatGPT is a broader general-purpose option.

More specific bottlenecks point to more specialized choices. Use Perplexity when research takes up a significant part of your week, Notion AI when the challenge is finding and using information stored across your workspace, and Fathom when meetings create a backlog of notes and follow-up work.

For automation, look at the complexity of the process you want to remove from your workload.

Zapier is a good starting point for straightforward workflows such as moving a new lead from a form into your CRM and creating a follow-up task.

Before adding a second AI subscription, assess how you’re already using AI across your small business and check whether your current tools can meet the new need.

A good AI setup can therefore be as simple as one general tool plus one specialist tool or automation platform.

Add another only when a recurring bottleneck remains, and compare the subscription cost with the time and manual work it actually removes.

All of the tutorial content on this website is subject to

Hostinger’s rigorous editorial standards and values.

The author

Ksenija Drobac Ristovic

Add Hostinger as a preferred source on Google

Ksenija is a digital marketing enthusiast with extensive expertise in content creation and website optimization. Specializing in WordPress, she enjoys writing about the platform’s nuances, from design to functionality, and sharing her insights with others. When she’s not perfecting her trade, you’ll find her on the local basketball court or at home enjoying a crime story. Follow her on LinkedIn.

The post Best AI for solopreneurs: 6 options for running a one-person business appeared first on WEBNET Hosting.

The post I Found these Computers in a Ditch… appeared first on WEBNET Hosting.

AI agents for real estate are AI systems that connect to tools such as your customer relationship management (CRM) platform, email, and calendar to handle tasks for you.

Unlike basic AI assistants or scripted chatbots, they can use live data and choose from approved actions, which helps them handle repetitive tasks that still vary from one client or situation to another.

Some of the most practical uses are lead follow-up, property matching, listing content, client communication, document processing, appointment scheduling, email marketing, and search engine optimization (SEO).

1. Lead qualification and follow-up

AI agents can qualify and follow up with new leads by asking about their budget, timeline, property type, and financing status, then scoring the responses and updating your CRM.

• Needs access to: website forms, CRM, email, calendar, and messaging apps
• Keep human control over: pricing discussions, negotiations, financial or legal questions, and unusual client situations

When inquiries come in through website forms, social ads, open houses, and otherreal estate lead generation methods, an agent can start the qualification process immediately instead of waiting for someone to review the lead manually.

One way to support this workflow is withHostinger Agent, an AI-powered business assistant that connects with Gmail, HubSpot, and Google Calendar. Its sales-focused AI expert can then handle lead follow-up across the tools you already use.

2. Property search and buyer matching

AI agents can match buyers with suitable properties by comparing their requirements with available listings and summarizing why each property fits.

• Needs access to: CRM, authorized listing feeds, internal property data, and buyer requirements
• Keep human control over: listing availability, pricing, property condition, and the final recommendations shared with clients

This can save time when a buyer has several requirements to compare at once. For example, an agent could narrow a large set of listings to properties with three bedrooms, within budget, close to the buyer’s workplace, and with space for a home office.

The quality of those recommendations depends on the data the agent receives. Keeping buyer preferences and other relevant details up to date in aCRM designed for real estate gives it more reliable information to work with.

Matching criteria should stay focused on legitimate property preferences such as price, location, size, and features, not protected characteristics or information that could act as a proxy for them.

3. Listing content creation

AI agents can turn verified property information into drafts for your multiple listing service (MLS), website, email campaigns, and social media.

• Needs access to: verified listing data, brand guidelines, and format requirements for each channel
• Keep human control over: measurements, amenities, location claims, property condition, and fair-housing language

This can reduce the repetitive work of rewriting the same property details for different channels. One verified property brief can become an MLS description, website copy, photo captions, an email highlight, and social media posts, with each version adapted to its format.

A tool such as Hostinger Agent can also use specialized content and marketing AI experts to help prepare different versions of the same verified listing information for multiple channels.

Always check the facts before publishing. AI can produce polished copy from incomplete or incorrect source information, and listing language should describe the property rather than the ideal buyer or neighborhood demographics.

4. Client communication

AI agents can handle routine client communication by preparing replies, reminders, property updates, and follow-up messages.

• Needs access to: email, calendar, CRM, website chat, and messaging apps
• Keep human control over: negotiations, complaints, sensitive conversations, legal questions, and contract discussions

This helps when several clients need updates at the same time. An agent can confirm showings, remind clients about missing documents, notify buyers about new property matches, and prepare post-viewing follow-ups without you drafting each message from scratch.

When communication is spread across several tools, an agent can also use information from connected apps to keep the right context with each client. Hostinger Agent, for example, supports connected business apps alongside a customer communication-focused AI expert.

More sensitive conversations should still stay with you. If a message involves a complaint, negotiation, contract issue, or situation where tone and judgment matter, the agent can prepare a draft for you to review.

5. Document processing and transaction administration

AI agents can help manage transaction documents by extracting key information, organizing files, checking for missing details, and flagging deadlines.

• Needs access to: document storage, transaction management software, CRM, and internal checklists
• Keep human control over: interpreting documents, verifying extracted information, and making legal or transaction decisions

This can reduce the manual work of reviewing and organizing documents throughout a transaction. For example, an agent could scan an inspection report for major findings, compare them with your checklist, and flag an upcoming appraisal deadline.

The agent should support administrative work, not interpret contracts or make legal decisions. Because transaction files can contain sensitive personal and financial information, limit its access to only the documents and data needed for the task.

6. Appointment and showing coordination

AI agents can coordinate property showings by checking availability, suggesting times, sending confirmations, and updating calendars.

• Needs access to: calendar, CRM, email, messaging platforms, and showing management software
• Keep human control over: access requirements, occupied-property rules, restricted viewing times, multi-party arrangements, and sharing access codes

This reduces the back-and-forth involved in scheduling. You can set your available hours and property-specific rules, then let the agent suggest suitable time slots, confirm appointments, update the calendar, and handle routine rescheduling.

For anything involving property access or special viewing conditions, keep the final approval with you.

7. Email marketing and newsletters

AI agents can prepare real estate marketing emails and newsletters by pulling listing information, adding relevant updates, and adapting the content for different audiences.

• Needs access to: CRM, email marketing platform, listing data, website content, and brand guidelines
• Keep human control over: property details, market statistics, personalization fields, recipient lists, and final approval before sending

This can save time when the same campaign needs different versions for different audiences. For example, an agent could create one newsletter for buyer leads, another for seller leads, and a third for past clients using the same underlying listing and market information.

Existingreal estate newsletter formats and examples can provide a starting point, which the agent can then adapt to each audience while keeping the structure and branding consistent.

8. Real estate SEO

AI agents can support recurring SEO tasks by checking existing pages, spotting issues, and preparing updates.

• Needs access to: your website, analytics, search performance data, keyword research, and editorial guidelines
• Keep human control over: search intent, local-market claims, keyword targeting, and final content approval

This can reduce the manual work involved in maintaining and improving a real estate website. For example, an agent could flag pages with missing meta descriptions, suggest relevant internal links, identify search topics for your service areas, or draft updates for older content.

The quality of those recommendations depends on the information you give the agent. Reliable keyword research, accurate website data, and a solidSEO setup for a real estate website give it a stronger basis for identifying useful improvements.

Hostinger Agent also includes an SEO-focused AI expert, making SEO another workflow that can be handled alongside sales, content, and marketing tasks from the same tool.

When to use AI agents for real estate

AI agents make sense for tasks where the next step can be decided from information already available in your tools.

For example, an agent can decide when to send a lead follow-up, which listings meet a buyer’s requirements, or which available time slots to offer for a showing.

They work best when the task:

• Happens often. Lead follow-up, listing updates, showing coordination, and newsletter preparation are all recurring tasks.
• Uses reliable existing data. The agent can work from CRM records, listing feeds, calendar availability, or transaction documents.
• Has clear rules for what happens next. For example, you can tell it to follow up with leads who plan to buy within 90 days.
• Doesn’t depend heavily on human judgment. Drafting, sorting, scheduling, and organizing are better fits than pricing, negotiating, or interpreting legal documents.

Best practices for using AI agents in real estate

To use AI agents safely in real estate, give them accurate data, limit what they can access and do, and keep human review in place for anything that could affect a client or transaction.

• Use reliable, current data. If your CRM and MLS feed show different prices, the agent needs to know which source to trust. Outdated listings, incorrect contact details, or unverified property information can lead to inaccurate results.
• Limit permissions. Give the agent access only to the data and tools it needs for the task. An agent that drafts listing descriptions, for example, doesn’t need access to transaction documents or financial records.
• Keep humans in the loop. Require approval before the agent sends messages, changes important records, or takes actions that could affect a client or transaction.
• Protect client privacy. Transaction files can contain sensitive information such as Social Security numbers, bank statements, and pre-approval letters. Check how connected tools process, store, and share that data before giving an agent access.
• Test before going live. Test realistic situations such as incomplete lead details, conflicting listing information, failed integrations, and messages that should be escalated to you rather than sent automatically.

How to get started with AI agents in real estate

To get started with AI agents in real estate, choose one repetitive, low-risk task and test it before expanding to more complex work. Lead qualification, follow-up messages, listing descriptions, showing coordination, and CRM updates are good starting points. Avoid contracts, negotiations, and other decisions that require significant human judgment.

Connect only the data and tools the task needs, then set clear rules for what the agent can do automatically and what still requires your approval. If you want to start with a ready-made option, Hostinger Agent lets you work with specialized AI experts across several business functions instead of building an agent from scratch.

Test the workflow with realistic situations before using it with clients. Once it consistently handles the task correctly, you can expand it to related work orbuild an AI agent with more complex goals and access to additional tools.

All of the tutorial content on this website is subject to

Hostinger’s rigorous editorial standards and values.

The author

Alma Fernando

Add Hostinger as a preferred source on Google

Alma is an AI Content Editor with 9+ years of experience helping ideas take shape across SEO, marketing, and content. She loves working with words, structure, and strategy to make content both useful and enjoyable to read. Off the clock, she can be found gaming, drawing, or diving into her latest D&D adventure.

The post AI agents for real estate: 8 practical use cases appeared first on WEBNET Hosting.

The post What’s the Worst Tech Linus Still Uses? appeared first on WEBNET Hosting.