AI Agent Readiness in action: AI Baby Gorilla welcomes autonomous AI agents through its Cloudflare-powered public API, connecting ARD discovery and OpenAPI with structured data analysis, security controls and auditable execution.
AI Agent Readiness / An Engineer's Field Notes / Investigation 04
AI Agent Readiness: From Discovery to Autonomous Execution
A new Agentic Browsing check in Google's PageSpeed Insights sent us investigating Agentic Resource Discovery (ARD). What began as a missing audit requirement became a practical engineering experiment: could we make a real website diagnostic discoverable and callable by external AI agents?
PageSpeed reported 3 out of 4. What were we missing?
Our investigation began with a PageSpeed Insights report. Sydney Business Web was already performing well in the conventional Lighthouse categories, but the emerging Agentic Browsing section introduced a new consideration.
Three of its four checks were passing. The outstanding item concerned Agentic Resource Discovery (ARD). We had not yet implemented the ARD discovery information required for that check.
ARD outstanding
ARD valid
Rather than treating this as another box to tick, we wanted to understand what ARD was intended to accomplish, whether it was relevant to our infrastructure, and what implementing it would actually achieve.
We investigated. Then implemented.
We already operated behind Cloudflare and had experience developing serverless services using Cloudflare Workers. That gave us a practical environment in which to investigate agent-facing discovery and execution.
We published an ARD manifest at /.well-known/ard.json under our own domain, describing AI Baby Gorilla as an available diagnostic capability.
We also provided an OpenAPI 3.1 specification describing its API interface. The manifest and specification serve different purposes: ARD supports discovery; OpenAPI documents invocation.
The implementation was not simply a Cloudflare setting switched on. It involved publishing the appropriate discovery resources, aligning their descriptions with the actual service, and verifying the publicly accessible results.
We then repeated the PageSpeed test. On 1 November 2026, our homepage returned 4 out of 4 Agentic Browsing checks passed, including confirmation that the ARD manifest was valid.
What the passing audit does not prove
4/4 is not proof of autonomous agent execution. The audit checks specific technical conditions. It cannot establish that an independent AI agent has discovered our diagnostic, invoked its API, and successfully used the result within a real workflow.
That was the point at which yesterday's investigation became much more interesting.
The next question: could an agent actually use the tool?
For that investigation, we used a system we had already developed: AI Baby Gorilla . It examines JSON-LD entities and relationships on a single public webpage and reports structural identity and connectivity issues. Originally, it was designed for human visitors using a browser and a security-protected form.
But publishing discovery documentation created a new possibility. Could a compatible AI agent locate Baby Gorilla, understand its API and execute a diagnostic independently, without requiring a person to open our page?
Publish the capability
Describe Baby Gorilla through an ARD manifest hosted under our domain.
Document the interface
Use OpenAPI 3.1 to describe requests, responses and access requirements.
Remove the access barrier
Develop controlled public API access through a Cloudflare Worker without requiring an agent to obtain a private Bearer token.
Test and record outcomes
Test API responses and limits, use Cloudflare D1 for audit evidence, and separate successful calls from proven external adoption.
Yesterday's key engineering lesson: discovering an API is not the same as being able to invoke it. We had to solve both problems before Baby Gorilla could become a practical tool for external AI-agent workflows.
Investigation 04 / The practical experiment
Meet AI Baby Gorilla: the diagnostic behind the experiment
Before an AI agent can use a tool, there must be something useful for it to do. Baby Gorilla gave us a real, working diagnostic against which to investigate agent readiness.
AI Baby Gorilla was developed by Sydney Business Web as a free, browser-accessible way to examine the structured data on an individual public webpage. Its purpose is not simply to validate JSON-LD syntax, but to assess whether declared entities form meaningful, connected identities.
A page can contain perfectly parseable structured data yet still describe its business, website and subject matter through disconnected or inconsistent declarations. Baby Gorilla examines those relationships rather than treating schema markup as a collection of isolated labels.
The result is a structured diagnostic: a connectivity verdict, an entity graph summary, selected findings and practical areas for review. The browser interface also presents a visual map of the relationships.
JSON-LD declarations
Identify and parse structured-data blocks on the submitted public page.
Entities and relationships
Construct an on-page graph of entities, identifiers and named relationships.
Identity consistency
Examine connectivity, missing identifiers, fragmented graphs and selected identity-related issues.
An important boundary: Baby Gorilla analyses one public page. It does not assemble a whole-site entity graph, verify AI crawler retrieval or establish that an AI system will recommend a business. Those require different evidence and more extensive analysis.
A useful tool for people. But what about AI agents?
The original Baby Gorilla experience was designed around an ordinary website visitor. A person opens the interface, enters a URL, completes Cloudflare Turnstile verification and receives a diagnostic report.
We wanted an external AI agent to perform the same underlying analysis as part of its own authorised workflow, without depending on the browser interface or pretending to be a human visitor.
Browser interaction
- Visitor opens Baby Gorilla.
- Enters a public webpage URL.
- Completes Turnstile verification.
- Reviews the diagnostic and entity map.
Machine-to-machine invocation
- Agent discovers the diagnostic capability.
- Reads its documented API contract.
- Submits a public URL programmatically.
- Receives machine-readable diagnostic results.
This separation matters. Browser security mechanisms designed to distinguish human interaction from automated traffic are not suitable credentials for legitimate autonomous software. Agent access needs its own defined interface and security boundaries.
Our first design was authenticated. Then came the obvious question.
Our initial agent-facing implementation used a Cloudflare Worker endpoint protected by a Bearer token. An API client holding the correct credential could submit a URL and receive the diagnostic response without using the browser form.
We tested that authenticated interface and confirmed that it could return structured results. For a known integration partner, with credentials supplied through a secure onboarding process, that model can be entirely appropriate.
Publishing an ARD manifest and OpenAPI documentation did not solve that problem. The agent could discover what the service offered and how to invoke it, but discovery did not provide authorisation.
We had made the service machine-discoverable without making it independently machine-accessible. That was a genuine architectural limitation, not a documentation issue.
The next engineering decision: public access without abandoning control
The answer was not to publish our private token or weaken the browser's Turnstile protection. It was to introduce a separate, deliberately constrained public agent interface.
That required more than changing an authentication condition. We needed to define acceptable targets, enforce resource limits, prevent unsafe network access, control both individual and aggregate demand, and retain meaningful audit evidence.
Our next step was to engineer that public execution boundary on Cloudflare Workers.
Investigation 04 / The implementation
Engineering public agent access: open by design, controlled by architecture
We had a working diagnostic, a discoverable capability and an OpenAPI specification. What we did not yet have was a practical means for an unfamiliar AI agent to invoke Baby Gorilla without obtaining private credentials. The engineering challenge was to remove that barrier while retaining meaningful control over execution.
We did not remove security. We redesigned the access boundary.
The original agent API used Bearer-token authentication. That remained useful for explicitly provisioned integrations, but it imposed a practical requirement: the caller needed to possess a valid private credential before using the service.
An ARD manifest could advertise the diagnostic. OpenAPI could describe the request and response. Neither mechanism could independently supply an unknown external agent with a secret token.
We therefore developed a separate public agent scan endpoint, while preserving the existing browser workflow and its Cloudflare Turnstile verification. Both interfaces use the diagnostic capability, but they enforce different access requirements.
The public API accepts a URL for one public webpage and returns structured diagnostic findings. It does not expose administrative operations, permit authenticated website access or provide an unrestricted crawling service.
Two interfaces. One diagnostic purpose.
We deployed the agent interface through Cloudflare Workers, separate from the human-facing WordPress application. This matters operationally: the public agent endpoint can receive requests through its Worker route without depending on the WordPress form or its security challenge.
Baby Gorilla website
/ai-baby-gorilla/
Designed for visitors using a conventional web browser.
Access: URL submission through a Turnstile-protected form.
Presentation: Human-readable findings, diagrams and next steps.
Cloudflare Worker endpoint
POST /api/ai-baby-gorilla/agent/scan
Designed for programmatic machine-to-machine invocation.
Access: No API token required; optional Bearer authentication.
Presentation: Machine-readable JSON results, including the verdict, graph summary and findings.
Simplified request-processing architecture
The Worker acts as the execution boundary, while Cloudflare D1 provides persistent records for quota management and audit evidence. D1's SQLite-compatible interface allows database-backed decisions rather than relying solely on temporary per-request memory.
Security engineering / Public endpoint constraints
An anonymous API requires deliberate limits.
The difficult part of a publicly callable diagnostic is not accepting a JSON request. It is deciding what the service will accept, how much work it may perform, and what it must refuse.
Public webpages only
The requested address must represent an acceptable public web resource. Internal and private network targets, credentials in URLs and unsuitable connection destinations are rejected.
Maximum 1.5 MB
Page retrieval is constrained by a maximum HTML response size. The service is a single-page diagnostic, not a general-purpose bulk downloader.
Eight-second fetch limit
A request cannot consume unlimited retrieval time. Timeouts provide an operational boundary for unresponsive destinations.
Three redirects maximum
Redirect chains are bounded. Destination checks remain important because an initially acceptable URL can redirect elsewhere.
Small, defined payload
The request body is limited to 4 KB, with a defined JSON structure. Arbitrary instructions and unlimited input are not accepted.
Fail closed
If the service cannot establish the necessary database-backed permission to execute a scan, it does not simply bypass the quota controls.
These controls reduce resource-exhaustion and server-side request-forgery risks, although no collection of safeguards should be mistaken for a guarantee against every possible failure mode.
Resource governance / Cloudflare D1
Rate limiting: not just per agent, but globally.
per rolling hour
per rolling hour
The requester allowance limits how frequently one source can use the public service.
The global allowance protects the overall system from excessive combined demand.
Authenticated and anonymous agent requests share the same agent-scan quota budget.
Why database-backed quotas?
Cloudflare Workers can process requests through distributed execution environments. A simple in-memory counter is not an adequate shared authority for a global quota.
We used Cloudflare D1 to make the admission decision against persistent request history. Rather than independently checking the counters and later inserting a record, the reservation uses a conditional database write that evaluates the requester and global limits together.
This avoids the basic check-then-insert race in which two requests independently observe an available slot and both proceed. The database write becomes the reservation decision.
Privacy consideration: requester identifiers are derived using keyed hashing rather than storing raw client IP addresses in the scan audit records. Submitted targets are also represented by hashed identifiers in that audit process.
A scan that fails after an admission slot has been reserved still consumes that slot. Otherwise, repeated failing requests could evade the intended work budget.
Verification / Development and production
We tested the behaviour. Not just the documentation.
Yesterday's work involved isolated development testing, database inspection, route configuration and production verification. We examined both successful requests and deliberate failure conditions.
The earlier credential-protected endpoint successfully returned structured diagnostic results.
The new endpoint accepted a valid scan request without a Bearer token and returned HTTP 200 with a diagnostic verdict and graph data.
An invalid supplied Bearer token produced HTTP 401 rather than falling through to anonymous access.
Development tests exercised the per-requester allowance and confirmed HTTP 429 once the permitted scan budget was exhausted.
A reserved scan that failed was recorded as a failure outcome rather than being treated as a successful analysis.
A successful anonymous scan was confirmed in production, with its completion event visible in the production D1 data.
The 20-scan global allowance is implemented, but an exhaustive independent-source concurrency test remains outstanding.
We have demonstrated that the public endpoint can be called. We have not yet established routine autonomous use by unrelated external agents.
The production deployment also preserved the distinct browser security requirement: an unauthorised browser-form submission without the expected Turnstile verification remained rejected. This is useful separation-of-access evidence, although further end-to-end browser regression testing is still worthwhile.
Inspect the live API documentation
Machine-readable contract
The public OpenAPI specification describes the agent scan interface and its optional Bearer authentication.
Inspect the live discovery resource
Agentic Resource Discovery
Our public ARD manifest identifies the available diagnostic capability and points to its technical description.
The result: a callable tool, not merely a discoverable one.
We now had evidence that Baby Gorilla's public agent endpoint could accept an anonymous request, execute its one-page structured-data diagnostic and return a machine-readable result. That was the practical capability missing from our initial Bearer-token-only design.
It does not mean that every AI agent will automatically discover or adopt the service. ARD and OpenAPI improve the opportunities for discovery and integration; an external agent still needs the ability and reason to select and invoke the tool.
The next challenge is no longer simply technical access. It is whether other AI systems find Baby Gorilla useful enough to incorporate into their own workflows.
Investigation 04 / Beyond the implementation
From a working API to an AI agent's workflow
Making Baby Gorilla publicly callable established a technical capability. The next question is whether external AI systems can make productive use of it: not simply calling an endpoint, but incorporating the diagnostic into a meaningful task.
The opportunity is not another website visitor. It is another system.
The original Baby Gorilla serves people who visit our website, submit a public page URL and inspect the results. That remains useful.
The agent-facing API changes the distribution model. A third-party AI system could, with appropriate authorisation from its user, invoke Baby Gorilla during an existing website-building, SEO auditing or technical assessment workflow.
The user would not necessarily have to leave that system, open our website or manually copy findings between tools. The API returns structured JSON that software can interpret and incorporate into its next steps.
That is an important difference between promoting a standalone web tool and making a narrowly defined engineering capability available for integration.
It also changes what meaningful success looks like. A useful API may be invoked repeatedly inside another organisation's workflow without producing a conventional website visit or contact-form enquiry.
Agentic integration / Potential applications
Where could an AI agent use Baby Gorilla?
We see several plausible integration patterns. These are proposed uses, not claims that third-party platforms have already adopted the service.
Check a newly published page
An AI-assisted website builder could submit a public page URL after deployment, inspect the identity graph and flag missing or fragmented structured-data relationships.
Add structural diagnostics
An auditing agent could include entity connectivity alongside conventional checks for indexability, metadata, links and technical SEO.
Investigate identity signals
An agent examining possible AI visibility weaknesses could use the result as one piece of technical evidence, without treating it as proof of retrieval or recommendation.
Illustrative agent workflow
An integration would still need to handle API errors, response interpretation, rate limits and appropriate user consent. Public availability does not remove those responsibilities from the system calling the service.
Commercial engineering / Integration pilots
A sensible next step: controlled partner integration
One potential route is to work with organisations already building AI-powered business automation workflows. Rather than asking them to send people to another website, we can offer a useful diagnostic component for their existing systems.
Automate Accelerate is one organisation we may approach about this possibility. A limited pilot could establish whether Baby Gorilla's output is useful within their automation model and whether the existing public API limits suit real operating conditions.
No integration or partnership is being claimed here. The objective would be to test a practical application, capture technical feedback and assess whether there is a genuine use case.
Our current public limits are intentionally conservative. A sustained commercial integration may require a separately governed access arrangement rather than treating the free public endpoint as unrestricted infrastructure.
Evidence / Measuring real adoption
What should we measure? More than API traffic.
Our D1 audit trail provides an initial engineering record of agent-interface activity. But usage statistics alone cannot determine who or what initiated a request. A command-line test client, a scheduled script and an autonomous AI agent can all call the same endpoint.
Execution outcomes
Count accepted requests, completed scans, failures, quota rejections and recurring demand over time.
Verified adoption
Identify participating partners through explicit integration arrangements, test records and agreed workflow evidence.
Qualified opportunities
Separately record genuine enquiries, requested assessments, integration agreements and paid service engagements.
This distinction will help us avoid mistaking infrastructure activity for market traction. It also informs whether Baby Gorilla should remain a free diagnostic, support partner-specific access, or eventually become part of a more extensive commercial API offering.
Engineering context / Scope boundaries
Baby Gorilla is the entry point. Not the entire assessment.
The wider Sydney Business Web AI visibility engineering work addresses different questions. We keep these capabilities separate because they require different evidence and methods.
AI Baby Gorilla
Examines the JSON-LD identity connections visible on one public webpage.
Schema Gorilla
Investigates the relationships, identities and consistency across a wider website entity graph.
AI Observatory
Measures qualifying retrieval activity from recognised machine systems using collected infrastructure evidence.
A successful Baby Gorilla result may establish that a particular page contains coherent identity relationships. It does not establish that an AI system retrieved that page, corroborated its claims or recommended the business.
Invitation / AI developers and automation providers
Building AI agents? Let's test an integration.
AI Baby Gorilla's public agent API is available for developers and AI automation platforms to evaluate, subject to its published technical and usage limits.
If you are developing AI website builders, SEO diagnostics or automated technical assessment workflows, we welcome enquiries about controlled integration pilots, technical feedback and potential partner arrangements.
Discuss an AI agent integrationPublic evaluation does not require an API token. An integration pilot is an opportunity to establish whether the capability is genuinely useful in your system.
Investigation 04 / Engineering conclusions
What we learned. And what remains to be proved.
What began with a missing ARD check in PageSpeed Insights became several days of engineering, testing, troubleshooting and refinement.
The result is our own AI Baby Gorilla public agent interface, developed by Sydney Business Web using Cloudflare Workers, Cloudflare D1, ARD discovery and OpenAPI 3.1. It extends our independently developed Baby Gorilla diagnostic rather than relying on a third-party assessment service.
We moved from a browser-oriented diagnostic to a documented API with controlled anonymous access, request safeguards, database-backed quotas and auditable execution outcomes. We deployed it and demonstrated successful public invocation.
The engineering achievement is real. So are its limits. We have not yet proved widespread independent-agent adoption, and further operational testing remains. Those are matters for the next stage of investigation, not claims to make prematurely.
Sydney Business Web — AI Agent Readiness: An Engineer's Field Notes. Investigation 04, November 2026. Independently developed, implemented and tested on our own infrastructure.
Investigation 04 / Frequently asked questions
AI Agent Readiness: practical questions
The emergence of Agentic Browsing audits, ARD manifests and callable AI services raises questions that conventional SEO and performance reports do not answer.
What does Agentic Browsing mean in PageSpeed Insights?
It refers to technical checks relevant to machine-driven browsing and agent discovery. These include accessibility structure, layout stability, llms.txt recommendations and ARD manifest validity. A passing result does not prove that an autonomous agent can complete a business task.
What is an ARD manifest?
An Agentic Resource Discovery manifest describes capabilities that AI systems may discover and potentially use. It can identify available APIs, tools or services and point to their technical descriptions. ARD concerns discovery, not execution.
Does a valid ARD manifest make my website agent-ready?
Not by itself. It provides discovery information, but an agent must still understand the interface, satisfy its access requirements and successfully invoke the service. Security, reliability and useful outcomes remain separate engineering concerns.
What is the difference between ARD and OpenAPI?
ARD helps compatible systems discover an available capability. OpenAPI describes an HTTP API, including its operations, inputs, responses and authentication. They complement one another: discovery identifies the tool; the API contract explains how to call it.
Can an AI agent use Baby Gorilla without an API key?
Yes. Baby Gorilla's public agent scan endpoint accepts eligible anonymous requests for single-page diagnostics. It supports optional Bearer authentication and currently limits usage to five agent scans per requester and twenty globally per rolling hour.
Why use Cloudflare Workers and D1 for agent access?
Workers provide the callable HTTP execution interface. D1 supports persistent request records and database-backed quota decisions. This architecture lets us separate human browser access from controlled machine-to-machine requests.
Does Baby Gorilla prove that AI will recommend my business?
No. Baby Gorilla examines JSON-LD identity connections on one public page. It does not verify AI retrieval, corroborate external business evidence, assess an entire website or establish whether an AI system will recommend a business.
Further reading / Evidence and technical context
Engineering references and related investigations
These references distinguish our own implementation and supporting research from the public specifications and platform documentation on which the investigation draws.
From Sydney Business Web
AI Agent Readiness
The central hub for our engineering-led investigations into agent-ready websites, capabilities and infrastructure.
Visit the investigation hubCloudflare Agent Readiness
Our earlier investigation into Cloudflare's emerging agent-facing capabilities, their technical implications and practical limitations.
Read the Cloudflare investigationAI Baby Gorilla
The human-facing single-page entity-connection diagnostic that formed the basis of this API engineering project.
Try Baby GorillaIntelligent Entity Skeleton
The principles behind coherent identities and relationships across structured website data.
Explore the entity skeletonAI Credibility Footprint
Why structural identity is only one part of the broader evidence required to support credible business information.
Explore the credibility footprintSchema Gorilla
Whole-site identity and entity-graph analysis, beyond the scope of Baby Gorilla's one-page checks.
Explore Schema GorillaExternal specifications and documentation
Agentic Resource Discovery
The developing ARD specification, covering discovery of APIs, tools, skills and other callable agentic resources.
Read the ARD specificationIntroducing ARD
Google's June 2026 explanation of the motivation for federated discovery and verification of agentic capabilities.
Read Google's announcementCloudflare D1
Official documentation for Cloudflare's serverless SQL database used in our rate-limit and audit architecture.
Read the D1 documentationOpenAPI Initiative
The specification used to describe Baby Gorilla's HTTP request and response contract in machine-readable form.
Read the OpenAPI specificationBaby Gorilla ARD Manifest
Our published discovery resource identifying the Baby Gorilla API and linking to its technical description.
Inspect the live ARD manifestBaby Gorilla OpenAPI
The public machine-readable contract for the agent scanning interface, including its access model.
Inspect our OpenAPI documentEvidence boundary: public specifications describe intended interoperability. Our own deployment and test records demonstrate selected working behaviour. Neither alone proves widespread autonomous-agent adoption.