Before you start

You need:

• WordPress 6.0 or newer, PHP 8.0 or newer. You can check both at Tools → Site Health → Info in your WP admin.
• An Arguto Free-plan install or paid subscription. Get Arguto from the Arguto product page — the Free plan needs no credentials, you just download the .zip and start. If you’ve subscribed you’ll also receive an email with your account email, password, and Subscription ID — keep those nearby for step 2.

Arguto works standalone. Five optional integrations — WooCommerce, The Events Calendar, Contact Form 7, WPForms Lite, and MailPoet — light up automatically when those plugins are active. No extra setup.

1. Install the plugin

You’ll get a .zip file from your Arguto account dashboard after buying. Two ways to install:

• From the WP admin (easiest): Plugins → Add New → Upload Plugin, pick the .zip, click Install Now, then Activate.
• Manual: unzip arguto.zip into wp-content/plugins/, then activate from the Plugins page.

You should see a new Arguto item in the admin sidebar.

2. Accept the EULA, then connect your license

Go to Arguto → Settings. The very first time you arrive — whether you’re a paid Subscriber or trying the Free plan — you’ll see an End-User Licence Agreement gate instead of the License panel. Read the EULA, tick the “I have read and agree…” checkbox, and click Accept and continue.

Acceptance is required to use Arguto at all — including the Free plan. Until accepted: every Arguto admin page redirects to the gate, the chat widget is hidden on visitor-facing pages, and the Login / Switch-to-Free-plan buttons don’t work. The plugin records who accepted the agreement, when, and which version, so the consent is auditable later if needed.

Once accepted, the License panel appears with a Login button. Click it and paste:

• Email — the one you signed up with
• Password — your Arguto account password
• Subscription ID — from your dashboard’s Subscriptions tab

Save. The status should flip to Active within a few seconds. The page also shows your Plan Tokens Usage — a green bar means you have plenty of headroom; amber means you’re getting close to the cap; red means upgrade or wait for the monthly reset.

Want to try Arguto without a paid licence? You don’t need to do anything — once you’ve accepted the EULA, the plugin is already running on the Free plan. The Free plan covers about 500 visitor chats per month and resets automatically each billing period, so there’s no expiry to worry about; it’s enough to test agent behaviour, customise overlay styles, and try every integration before you decide to upgrade. The Switch to Free plan button in the Login dialog only matters if you’ve previously entered a licence and want to drop back to Free.

Can’t log in? Re-check the Subscription ID has no trailing space and the email matches your Arguto account. If you’re stuck, contact us.

3. Verify Arguto is running

Once you’ve accepted the EULA, Arguto is already running on the Free plan with everything pre-configured — there’s nothing else to switch on. Specifically:

• Three sample agents are seeded automatically:
  • Site Assistant — the default, all-purpose agent. Uses every tool that works on a stock WordPress site (site search, post fetching, navigation, etc.).
  • Page Guide — a tighter agent focused only on getting visitors to the right page.
  • Knowledge Explorer — RAG-focused; only useful after you’ve synced a knowledge set (see section 5).
• Sitewide auto-inject is on by default. The chat bubble appears bottom-right on every page of your site without needing a shortcode or block. (You can turn this off in Arguto → Settings → Sitewide widget if you’d rather pick where the widget shows up — see section 6 for per-page embed alternatives.)
• The default agent has no knowledge set bound to it. It works fine without one — questions about your site go through live tools like search posts and get post. Section 5 explains why and how you’d add a knowledge set later for richer answers (and PDF uploads).

To verify everything works, open any page of your site in a new tab. You should see a chat bubble in the bottom-right corner. Click it → a greeting appears. Type “hi” and press Enter to confirm the round-trip to the Arguto backend works.

4. Pick a purpose for your agent

Go to Arguto → Agents and click the default agent to edit. The Purpose dropdown is the single most important setting — it presets the agent’s system prompt, enabled tools, and briefing to match a role:

• General helper — answers across site content, events, products
• Site navigator — helps visitors find pages
• Shop assistant — recommends products, checks stock, cart (WC)
• Event concierge — lists events, adds them to visitors’ calendars (TEC)
• Support agent — answers FAQs, falls back to your contact form
• Product expert — deep answers from your content with citations
• Knowledge explorer — answers from uploaded documents (PDFs, etc.)
• Documentation assistant — scrolls visitors to the right section of the current page

Picking a purpose updates the tool checkboxes and the agent’s briefing. Edit the system prompt or tool list afterwards if you want.

5. Make it smarter with Knowledge (optional)

The default agent works out of the box without any knowledge index — it uses live tools to find and quote your content on demand: search posts finds matching pages, get post fetches the full body, navigate to page resolves menu names. For most sites that’s enough to feel useful from day one.

A knowledge set upgrades that experience. Why bother:

• Faster, cleaner answers. The agent calls knowledge search once and gets the most-relevant chunks pre-pulled, instead of fetching whole posts and skimming.
• Citations. Every chunk carries the URL it came from, so the agent can name its sources in the reply.
• Content that isn’t a WordPress post. Product manuals, brewing guides, FAQ PDFs, internal docs — anything outside your CMS becomes searchable.
• The seeded “Knowledge Explorer” agent uses knowledge search exclusively, so it doesn’t actually do anything until you’ve synced a knowledge set for it.

Two ways to populate one. Both live under Arguto → Knowledge → Add knowledge set:

1. Sync your site content. Pick the “All site content” source mode (or filter to specific post types — posts only, pages only, products only, etc.) and click Sync. The plugin chunks and embeds your published content. New posts you publish later get indexed automatically; you don’t have to re-sync by hand.
2. Upload PDFs and other documents. Pick the “Files” source mode and drag-and-drop your files. PDFs are supported out of the box (text is extracted via the bundled Smalot/PdfParser library); other formats fall back to plain-text extraction. Useful for handbooks, product datasheets, recipe books, anything not in your WP database.

Once a knowledge set is built, edit any agent and bind the set under Knowledge. Answers immediately get richer and start citing sources — and the Knowledge Explorer agent finally does what its name says.

6. Embed anywhere (alternatives to sitewide inject)

If you want fine-grained control instead of sitewide auto-inject:

• Gutenberg block — in any page/post, search “Arguto” in the block inserter and drop Arguto Chat Widget. The block’s sidebar has an Agent dropdown so you can point different pages at different agents. Best for block-based themes and Site Editor templates.
• Shortcode — paste [arguto] (default agent) or [arguto agent="shop"] (a specific agent by slug) into any post, page, or theme template. Best for classic editor and custom PHP templates.

Pages that already embed the widget via block or shortcode override the sitewide auto-inject, so no double-widget risk.

7. Activate integrations (optional)

Arguto auto-detects these free plugins — install them and Arguto’s tools for each appear in the Agent edit page:

• WooCommerce → product search, categories, coupons, stock, add-to-cart
• The Events Calendar → upcoming events, search, detail, one-click .ics download
• Contact Form 7 / WPForms Lite → list forms, describe fields, submit on the visitor’s behalf
• MailPoet → list newsletters, subscribe visitors directly from the chat (double opt-in by default)

No configuration — just tick the tools you want enabled on each agent.

8. Privacy & data flow (what your visitors see, what to put in your privacy policy)

Arguto is an AI chat. By default, the widget shows a small “AI assistant” label under the agent name in the chat header so visitors know they’re interacting with an automated system, not a human. Visitor messages, agent replies, and tool-call payloads are processed by Fluid Interactive (the operator of the Arguto backend) and a third-party large-language-model provider (currently OpenAI) — none of this content is stored in your WordPress database.

What you need to do

• Keep the AI label visible on the chat widget. The EU AI Act and California’s BOT Act both require real-time disclosure to people interacting with AI systems. The default “AI assistant” label satisfies this in most contexts. If you change the label or hide it via custom CSS, you take on the disclosure obligation yourself.
• Mention Arguto in your site’s privacy policy. Paste the snippet below into your existing privacy policy and edit it to fit your site.
• If your visitors are in the EEA / UK, you’ll likely also want a Data Processing Addendum (DPA) covering the transfer of visitor data to Fluid Interactive. Email [email protected] to request one.

Privacy-policy snippet (paste-ready)

Drop this paragraph into your site’s privacy policy under a heading like “Chat assistant” or “AI services”. Adjust the bracketed bits to match your site:

This site uses Arguto, an AI chat plugin operated by Fluid
Interactive, Inc., to provide a chat assistant on [your-site-name].

When you interact with the chat:
- Your messages, the agent's replies, and any data the agent
  sends or receives through tools are processed by Fluid
  Interactive's hosted service and a third-party large-
  language-model provider (currently OpenAI). Processing may
  occur outside the country where you're located.
- We do not store your chat content in our own database. Fluid
  Interactive may retain logs and aggregated metrics as
  described in their privacy policy.
- The chat may take actions on this site on your behalf —
  looking up products, submitting forms, subscribing you to
  newsletters, and similar. Confirm any consequential action
  before accepting it.
- The chat is identified as an "AI assistant" in the widget
  header. You can stop interacting at any time by closing the
  widget.

For details on how Fluid Interactive handles data, see their
privacy policy at https://www.fluidinteractive.com/privacy-policy/ .

Contact: [your-contact-email]

For a full list of what visitor data flows where, see Fluid Interactive’s privacy policy and the Arguto End-User Licence Agreement that ships in the plugin’s docs/eula.txt.

9. Write your own custom HTTP tools (advanced)

Built-in templates (OpenWeather, Slack, Mailchimp, HubSpot, Zapier, generic webhook) handle third-party SaaS — paste an API key, save. Custom HTTP tools handle your own server: order lookup, lead capture into a private CRM, custom inventory or pricing, internal report generation. Anything you can expose as an HTTP endpoint, the agent can call.

The webhook can live anywhere Arguto’s backend can reach — your WP site (a one-file mu-plugin works fine), a sidecar Node service, an internal API behind a public hostname.

What your webhook receives

• GET tools: parameters merge into the query string. Static parameters from the admin form + LLM-supplied args travel together. Admin-defined headers are always sent.
• POST / PUT / PATCH tools: same merged shape, but as a JSON body. Default Content-Type: application/json, overridable via the Headers field.

HMAC signature

If you set an HMAC secret on the tool (strongly recommended for any non-public endpoint), every request carries an X-WP-Agent-Signature header signed with HMAC-SHA256. Arguto ships a verifier — drop one line into your endpoint’s permission_callback and you’re done:

'permission_callback' => fn ( $req ) =>
    Arguto_HmacVerifier::verify_with_secret( $req, 'YOUR_SHARED_SECRET' ),

The verifier returns true on a valid signature and a WP_Error on missing or mismatched signature — both are valid returns from a REST permission callback.

Writing your webhook in Node, Python, or Go instead of PHP? The signed payload is HMAC-SHA256(secret, "{METHOD}:{endpoint_url}:{body_str}"), where body_str is canonical JSON: compact separators, recursively-sorted keys, raw UTF-8. For GET, the merged-params object is the body. The reference algorithm lives in includes/class-hmac-verifier.php in the plugin.

Example 1 — Hello, world (GET)

The smallest possible custom tool: visitor says “say hi”, agent calls a GET endpoint, gets a greeting string back, replies. No parameters, no business logic — just enough wiring to confirm the plumbing works.

Custom-tool admin form (Arguto → Custom Tools → Add Tool):

• Tool name: say_hello
• Description: Return a friendly greeting from the server. Use when the visitor says hello or asks if you’re there.
• Endpoint URL: https://yoursite.com/wp-json/myshop/v1/hello
• Method: GET
• Parameters: {} (no params for this one)
• HMAC secret: 32+ random characters — generate with wp generate-password 64 --no-special-chars or any password manager.

PHP webhook code — paste into your theme’s functions.php or a small mu-plugin at wp-content/mu-plugins/arguto-custom-tools.php:

add_action( 'rest_api_init', function () {
    register_rest_route( 'myshop/v1', '/hello', [
        'methods'             => 'GET',
        'permission_callback' => fn ( $req ) =>
            Arguto_HmacVerifier::verify_with_secret( $req, 'YOUR_SHARED_SECRET' ),
        'callback' => fn () => [ 'message' => 'Hello from your webhook!' ],
    ] );
} );

That’s the whole pattern. Once this round-trips successfully — the agent says “Hello from your webhook!” in chat — you can swap the body for any business logic.

Example 2 — Hello, world with a static parameter (GET)

Same hello tool, but with one piece of context the admin hard-codes once and the LLM never sees. Static parameters are the right tool for tenant IDs, signing keys for downstream services, fixed feature flags, or — as below — letting one webhook stand in for several agents by tagging where the greeting comes from. Arguto appends them to the request URL (for GET) or merges them into the JSON body (for POST) automatically.

Custom-tool admin form:

• Tool name: say_hello
• Description: Return a friendly greeting from the server. Use when the visitor says hello or asks if you’re there.
• Endpoint URL: https://yoursite.com/wp-json/myshop/v1/hello
• Method: GET
• Parameters: {} (still no LLM-driven inputs)
• Static parameters: {"from": "the Sales team"} — appended to every request; the LLM never sees this field.
• HMAC secret: 32+ random characters.

PHP webhook code — read the static value from the query string:

add_action( 'rest_api_init', function () {
    register_rest_route( 'myshop/v1', '/hello', [
        'methods'             => 'GET',
        'permission_callback' => fn ( $req ) =>
            Arguto_HmacVerifier::verify_with_secret( $req, 'YOUR_SHARED_SECRET' ),
        'callback' => function ( WP_REST_Request $req ) {
            $from = sanitize_text_field( (string) $req->get_param( 'from' ) ) ?: 'the team';
            return [ 'message' => sprintf( 'Hello from %s!', $from ) ];
        },
    ] );
} );

Same chat experience for the visitor — the agent now replies “Hello from the Sales team!” — but the admin controls the tag without prompting the LLM. Want a different tag for a Support agent? Add a second custom tool pointing at the same endpoint with {"from": "Support"} and assign it to that agent.

Example 3 — Hello, world with a standard parameter (GET)

Same hello tool, but the agent personalises the greeting with the visitor’s name. Standard parameters are LLM-driven: the model decides whether to call the tool at all, what value to pass, and when to omit the field if no value is available. The description string is the only thing the LLM ever reads about the field — treat it as a hint to a human helper.

Custom-tool admin form:

• Tool name: say_hello
• Description: Return a friendly greeting. Pass the visitor’s name when they’ve shared it.
• Endpoint URL: https://yoursite.com/wp-json/myshop/v1/hello
• Method: GET
• HMAC secret: 32+ random characters.

Parameters JSON:

{
  "name": {"type":"string", "description":"The visitor's name if they've shared it. Omit otherwise."}
}

PHP webhook code — read the LLM-supplied value, with a graceful fallback when it’s not given:

add_action( 'rest_api_init', function () {
    register_rest_route( 'myshop/v1', '/hello', [
        'methods'             => 'GET',
        'permission_callback' => fn ( $req ) =>
            Arguto_HmacVerifier::verify_with_secret( $req, 'YOUR_SHARED_SECRET' ),
        'callback' => function ( WP_REST_Request $req ) {
            $name = sanitize_text_field( (string) $req->get_param( 'name' ) );
            $msg  = $name !== ''
                ? sprintf( 'Hello, %s!', $name )
                : 'Hello there!';
            return [ 'message' => $msg ];
        },
    ] );
} );

If the visitor introduced themselves earlier in the chat, the agent passes name and the webhook returns “Hello, Alice!”. If not, the field is omitted and the webhook falls back to the generic greeting. To lock a field to a fixed set of values, add an enum alongside type — Example 4 below uses that.

Example 4 — Callback request (POST)

A real use case: visitor says “have someone call me about pricing”, the agent collects name, phone, topic and preferred time, then POSTs to a custom endpoint that emails the team.

Custom-tool admin form:

• Tool name: request_callback
• Description: Schedule a callback from the team. Use when the visitor asks to be contacted.
• Endpoint URL: https://yoursite.com/wp-json/myshop/v1/callback
• Method: POST
• HMAC secret: 32+ random characters (different from the say-hello secret — one secret per tool).

Parameters JSON (the LLM uses description to know when to call the tool, and enum to constrain values):

{
  "name":           {"type":"string", "description":"Visitor's name"},
  "phone":          {"type":"string", "description":"Phone with country code"},
  "topic":          {"type":"string", "enum":["pricing","support","other"], "description":"Reason for the callback"},
  "preferred_time": {"type":"string", "description":"e.g. 'tomorrow afternoon', 'next Monday morning'"}
}

PHP webhook code:

add_action( 'rest_api_init', function () {
    register_rest_route( 'myshop/v1', '/callback', [
        'methods'             => 'POST',
        'permission_callback' => fn ( $req ) =>
            Arguto_HmacVerifier::verify_with_secret( $req, 'YOUR_SHARED_SECRET' ),
        'callback' => function ( WP_REST_Request $req ) {
            $p   = $req->get_json_params();
            $msg = sprintf(
                "Callback request:\nName: %s\nPhone: %s\nTopic: %s\nWhen: %s",
                $p['name']           ?? '',
                $p['phone']          ?? '',
                $p['topic']          ?? '',
                $p['preferred_time'] ?? ''
            );
            wp_mail( '[email protected]', 'Arguto callback request', $msg );
            return [ 'queued' => true ];
        },
    ] );
} );

wp_mail() is the simplest sink — in production swap for a Slack post, a CRM API call, or a row in a custom DB table.

Tips & gotchas

• Static parameters for tenant IDs, fixed flags, query-string API keys (e.g. OpenWeather’s appid) — never shown to the LLM.
• Headers for Authorization: Bearer …, X-API-Key, etc. — also never shown to the LLM.
• Test with curl first. Hit the endpoint manually with the right params, headers and a computed signature; once that works, plug into Arguto.
• Rotate secrets if leaked — regenerate in the Arguto admin, update in the receiver. No plugin restart needed.
• For SaaS endpoints (Slack, HubSpot, Mailchimp), prefer the built-in template — saves a webhook hop.

Troubleshooting

• Chat bubble doesn’t appear → check the plugin is active under Plugins; disable any JS-optimiser plugin (Autoptimize, LiteSpeed, WP Rocket) briefly to rule out script mangling.
• “License inactive” in Settings → re-enter credentials via the Login button; check Plan Tokens Usage hasn’t hit 100%.
• Widget opens but says “Chat is temporarily unavailable” → usually a transient backend hiccup — hit Try again. If it persists, contact us.
• Agent doesn’t use a tool I expected → the agent’s Purpose drives which tools are enabled. Either change the purpose, or manually tick additional tools in the agent edit page.

Next steps

• Customise overlay styles (colours, position, logo) at Arguto → Overlay Styles
• Build a Knowledge Set from your pages or PDFs at Arguto → Knowledge
• Wire up a custom HTTP endpoint as a tool at Arguto → Custom Tools — a Gutenberg-style template picker starts you off for Mailchimp, HubSpot, Slack, Zapier, OpenWeather, or a generic webhook

Still stuck? Use the contact form on the product page — we usually reply within a couple of business days.