Public disclosure note: This is a sanitized case study. The target application is my own production application, Minuto AI - Meeting Minutes, a vibe-coded web application built on Lovable. I intentionally omit exploit payloads, sensitive URLs, account identifiers, infrastructure addresses, and reproduction details that could expose the application or its users to unnecessary risk.

Abstract

This article presents a practical field test of a cost-efficient infrastructure setup for experimental Web App Vulnerability Assessment and Penetration Testing (VAPT). The experiment used PentAGI, Ollama, and a rented NVIDIA A100-SXM4-40GB GPU on Vast.ai to evaluate whether an open-source multi-agent testing workflow, backed by a self-hosted Qwen 3.5 35B-family model, could support a short, affordable security assessment of an authorized vibe-coded production web application.

The experiment used Minuto AI - Meeting Minutes, my own Lovable-built production application, as the authorized target. PentAGI coordinated the VAPT workflow, Ollama served the local model, ngrok exposed the model endpoint for controlled access, and Vast.ai provided temporary GPU compute. The run produced useful infrastructure and workflow evidence: agent task progression, model traffic, token usage, tool calls, infrastructure billing, and a generated VAPT report. The most important result was not that AI agents can replace cybersecurity professionals. Rather, the experiment showed that low-cost, rented GPU infrastructure can make AI-assisted Web App VAPT experimentation accessible, provided that human intelligence remains central to scoping, validation, interpretation, and remediation.

Keywords

AI-assisted penetration testing, Web App VAPT, cost-efficient infrastructure, PentAGI, Ollama, Vast.ai, Qwen 3.5, Lovable, vibe-coded web application, OWASP, security automation

Introduction

Security testing is becoming more automated, but practical infrastructure questions remain. Can a self-hosted large language model support an experimental Web App VAPT workflow? Is rented GPU infrastructure affordable enough for short security experiments? Can a multi-agent tool produce useful workflow evidence without exposing sensitive production details?

To explore these questions, I ran an authorized assessment against Minuto AI - Meeting Minutes, my first vibe-coded application built on Lovable and already being used in production. Because the application belongs to me, I could test the workflow without crossing legal or ethical boundaries. The goal was to evaluate the cost-efficient infrastructure setup and experimental VAPT process, not to publish a full vulnerability report.

The research question for this experiment was:

Can a cost-efficient infrastructure stack using rented GPU compute, self-hosted Ollama, and an open-source multi-agent VAPT workflow support an experimental Web App VAPT of a Lovable-built, vibe-coded application within a short testing window?

This writeup focuses on infrastructure design, workflow setup, runtime observations, cost, and lessons learned. It does not disclose exploit steps or sensitive target details.

Background and Motivation

Modern web applications often combine third-party services, authentication layers, client-side logic, API routes, and rapidly shipped features. Vibe-coded applications built with platforms such as Lovable can move from idea to production very quickly. That speed is useful, but it also creates security review debt. For solo builders and small teams, a full manual penetration test may not always be available early in the product lifecycle. A cost-efficient experimental VAPT setup can help identify areas for review before a more formal audit is scheduled.

For this experiment, I wanted to test a practical stack:

  • PentAGI as the multi-agent VAPT orchestrator.
  • Ollama as the self-hosted model server.
  • Qwen 3.5 35B-family model as the local reasoning model.
  • Vast.ai as the temporary GPU compute provider.
  • ngrok as the tunnel between the agent workflow and the model endpoint.

The motivation was operational rather than theoretical. I wanted to understand what it feels like to run the stack end to end, how much it costs, what evidence it produces, and where human review is still required. The central object of study was the infrastructure approach, not the disclosure of vulnerabilities.

Experimental Setup

Figure 1. Tech workflow diagram with VAPT process.
Component Role in the Experiment Configuration / Observation
Target application Authorized VAPT target Minuto AI - Meeting Minutes, my own production application
Application origin Vibe-coded development platform Built on Lovable
Compute provider Temporary GPU infrastructure Vast.ai instance using NVIDIA A100-SXM4-40GB
Model server Local LLM serving layer Ollama running on the rented GPU instance
Model Reasoning engine for the agent workflow Qwen 3.5 35B-family model via Ollama; the exact local tag may vary by pulled variant
VAPT orchestrator Multi-agent security workflow PentAGI running a web application VAPT flow
Tunnel Controlled model endpoint exposure ngrok HTTP tunnel for model API access
Experiment window Wall-clock testing period 18:12:14 to 20:58:08, approximately 2h 45m 54s
Observed infrastructure cost GPU, storage, and transfer charge Approximately $2.39 for the visible Vast.ai instance charge

The architecture was intentionally simple. PentAGI needed a model endpoint. Ollama provided that endpoint. Vast.ai supplied the GPU required to serve the model. ngrok made the endpoint reachable during the experiment window.

Figure 2. The rented Vast.ai instance used an NVIDIA A100-SXM4-40GB GPU, which provided enough GPU memory for the Ollama-hosted model used in this experiment.

Methodology

The experiment followed a controlled practitioner workflow.

First, I defined the scope. The target was my own production application, and the assessment was performed as an authorized security review. The public version of this writeup does not include payloads, session details, private URLs, or account identifiers.

Second, I provisioned compute. I rented a Vast.ai instance with an NVIDIA A100-SXM4-40GB GPU, installed or prepared the Ollama model serving environment, and used the instance as a temporary inference server.

Third, I connected the agent workflow. PentAGI was configured to use the Ollama-hosted model endpoint. ngrok was used as the controlled tunnel so the agent workflow could communicate with the model server during the experiment.

Fourth, I ran the VAPT flow. PentAGI performed a web application security assessment workflow against the authorized Lovable-built target. I monitored model API traffic, instance logs, task progress, token usage, and the generated report.

Fifth, I reviewed and sanitized the output. I treated the generated findings as triage material, not final truth. Any security issue found by an agentic tool still requires manual validation, reproducibility checks, and remediation review before it should be treated as confirmed.

Results and Observations

Infrastructure Behavior

The GPU-backed Ollama server was able to respond to the agent workflow throughout the experiment. The traffic evidence showed repeated successful model API calls during the run, which confirmed that PentAGI was actively using the self-hosted model rather than a paid external model endpoint.

Figure 3. The tunnel traffic showed repeated successful requests to the local model API. Sensitive tunnel and account details were removed from the public figure.

The infrastructure cost remained low for a short experimental Web App VAPT run. My notes recorded an advertised GPU rental rate around $0.676 per hour. The visible Vast.ai billing crop showed approximately 3.49 GPU hours at $0.667 per hour, plus small storage and download charges. The visible instance charge totaled approximately $2.39.

Figure 4. The visible billing line item showed the practical cost profile: GPU time was the dominant cost, while storage and transfer were minor for this short experiment.

PentAGI Workflow Execution

PentAGI organized the assessment into a structured task flow. The visible task list included reconnaissance, OWASP-oriented checks, component analysis, authentication and session review, business impact analysis, and final report compilation. This was useful because it transformed a broad security goal into a sequence of observable work items.

Figure 5. PentAGI structured the run into auditable tasks and subtasks. The public article keeps the view at the workflow level rather than exposing exploit details.

The dashboard also provided operational metrics. In the visible run, PentAGI reported approximately 3.8 million input and output tokens, 161 tool calls, one primary task, and nine subtasks. The dashboard duration visible in the screenshot was about 2h 21m, while my full experiment notes recorded 2h 45m 54s from start to end. The difference is expected because infrastructure setup, observation, and teardown can extend beyond the active agent-flow timer.

Figure 6. The run consumed substantial token volume even though the direct LLM spend inside PentAGI showed $0.00 because the model was self-hosted. The cost shifted from API billing to GPU rental.

Generated Report Output

The generated VAPT report was useful as a draft security artifact. It organized findings into categories and severity levels, which is helpful for triage and remediation planning. However, I would not publish or act on the report without human verification. Agent-generated security reports can contain exaggeration, incomplete evidence, false positives, or unclear severity ratings.

Figure 7. The generated report summarized findings by category and severity. This public crop preserves the reporting structure while avoiding exploit-level evidence.

At a high level, the agent workflow produced useful signals around security policy posture, header hardening, dependency or component review, authentication/session checks, and business impact prioritization. Those categories are appropriate for remediation planning, but the public version of this article intentionally avoids exploit payloads, affected routes, and reproduction steps.

Discussion

The experiment was successful as an infrastructure and workflow test. It showed that a self-hosted model can support an AI-assisted Web App VAPT run and that a temporary GPU instance can keep the infrastructure cost manageable for short experiments on a vibe-coded application.

The most interesting observation was the cost model. PentAGI showed $0.00 in direct model spending because the model endpoint was self-hosted. That does not mean the run was free. The cost moved to GPU rental, storage, transfer, setup time, and operational risk. For this short run, the visible infrastructure cost was low. For longer tests, repeated assessments, or higher-concurrency use, those costs need to be measured more carefully.

The second observation was workflow quality. PentAGI was useful for creating structure. It gave me a task timeline, execution visibility, dashboard metrics, and a report draft. That is valuable, especially for solo builders who need a security checklist and an initial review path. Still, the output should be treated as assisted analysis, not as an independent penetration test sign-off.

The third observation was the boundary between experimentation and assurance. A low-cost AI-assisted VAPT stack is useful for learning, early triage, and developer-led security exploration. It is not a substitute for a sensitive IT Security Audit of an organization's IT infrastructure. For production systems with regulatory, financial, healthcare, identity, or business-critical exposure, it is still recommended to hire a qualified Cybersecurity Firm to perform a formal assessment. Human intelligence is still the cornerstone of a VAPT engagement.

The fourth observation was security hygiene. Exposing a model endpoint through a tunnel is convenient, but it must be time-boxed and controlled. Tunnels, admin panels, logs, and screenshots can easily reveal details that should not be published. For that reason, the figures in this article are cropped and sanitized.

Limitations

This was a single-case experiment against one Lovable-built web application. The results should not be generalized as a benchmark for all AI-assisted VAPT tools, all Qwen model variants, all vibe-coded applications, or all web applications.

The generated report was not independently validated as part of this article. A proper production security process would require manual verification, remediation, retesting, and documentation of residual risk. Organizations should treat this type of experiment as a complement to, not a replacement for, professional cybersecurity assessment.

The experiment was also constrained by the public disclosure posture. Because Minuto AI is a real production application, this article intentionally excludes technical exploit detail. That makes the writeup safer to publish, but it also means readers should understand this as an operational case study rather than a complete vulnerability disclosure.

Ethical and Disclosure Considerations

AI-assisted penetration testing is dual-use. The same automation that helps defenders can also help attackers if used carelessly or maliciously. My test was limited to an application I own and operate. I do not recommend running autonomous or semi-autonomous VAPT tools against third-party systems without explicit written authorization.

For sensitive IT Security Audits, organizations should engage a Cybersecurity Firm with the proper legal authorization, methodology, evidence handling, reporting discipline, and professional accountability. AI agents can assist the process, but human intelligence remains the foundation of risk judgment, exploit validation, business impact analysis, and remediation prioritization.

For public sharing, I followed three rules:

  1. Do not publish secrets, account identifiers, temporary tunnel URLs, public IP addresses, or administrative endpoints.
  2. Do not publish payloads, reproduction steps, or route-specific exploit evidence.
  3. Treat AI-generated findings as leads until they are manually verified.

Those rules keep the article useful for learning while reducing avoidable security risk.

Conclusion

This experiment demonstrated that a cost-efficient infrastructure setup using PentAGI, Ollama, Qwen 3.5 35B-family models, and rented Vast.ai GPU compute is practical for short, authorized, experimental Web App VAPT of a vibe-coded application. The workflow produced meaningful evidence: model traffic, task progression, token and tool metrics, infrastructure cost, and a draft report.

The strongest value of the stack is not autonomous hacking. Its strongest value is cost-efficient experimentation and acceleration: it helps structure the assessment, explore common web security categories, generate a first-pass report, and surface remediation themes. The human researcher still owns the most important parts of the work: scoping, authorization, validation, prioritization, remediation, and responsible disclosure.

For my own practice, the key lesson is clear: AI agents can make security testing faster and more organized, but they should be used as disciplined assistants, not unchecked authorities. For sensitive organizational audits, human-led VAPT by qualified cybersecurity professionals remains essential.