Landing page
Agent
Verification done
Agent
sentry dashboard
browserbase dashboard
Landing page

Foleo Proof Agent

Inspiration

I had already been working on Foleo, a creator-brand collaboration platform designed to make partnerships more accessible, transparent, and manageable.

Foleo helps creators - especially smaller and growing creators - discover legitimate brand opportunities, build professional portfolios, submit campaign work, and earn income. Brands can launch UGC campaigns, discover creators, review submissions, and manage collaborations in one place.

What makes Foleo different is that it is not simply a creator directory. It is designed to support the full collaboration lifecycle, from campaign creation and creator discovery to submission management, feedback, and eventually payment.

While building Foleo, I kept running into one major problem: content verification.

A brand campaign may require creators to include:

a specific brand mention;
required hashtags;
a promotional code;
a campaign link;
a sponsorship disclosure;
required talking points;
prohibited claims;
previous revision requests.

Foleo already includes an AI campaign assistant that helps brands turn their goals into structured campaign requirements. However, after creators publish their content, someone from the brand still has to manually open every post and compare it against the brief.

That process becomes extremely difficult at scale.

If a campaign includes 500 creators and reviewing each submission takes only two minutes, the brand would still spend more than 16 hours manually checking content. Different reviewers may also interpret the same rules differently, leading to inconsistent decisions.

When I arrived at the hackathon and explored the sponsor technologies, I realized they could solve different parts of this exact problem. That led to the creation of Foleo Proof Agent.

What it does

Foleo Proof Agent automatically reviews a creator's published sponsored content against the corresponding campaign requirements.

A creator submits a public content URL through Foleo. The brand then clicks Verify Deliverable.

The system:

Loads the campaign, creator submission, and structured requirements.
Retrieves official platform metadata when it is available and useful.
Opens the rendered public page through Browserbase.
Uses Stagehand to extract visible evidence.
Combines the campaign brief, evidence, and relevant revision context.
Compresses that context through The Token Company.
Sends it to the Fetch.ai-powered Foleo Proof Agent.
Produces and validates a structured compliance result.
Saves the evidence, metrics, result, and safe failure state in Foleo.
Shows the appropriate report to the brand, creator, or administrator.
Traces the complete process through Sentry.

The final report can include:

compliance verdict;
numerical score;
passed requirements;
failed requirements;
warnings;
creator revision guidance;
confidence;
extracted evidence;
evidence source attribution;
Browserbase session or screenshot reference;
compression status and measured token reduction;
retry and safe failure controls.

The agent assists a human reviewer. It does not automatically approve content or release payments.

How it works

Creator submits a public sponsored-content URL
                    |
                    v
Foleo loads the campaign, creator, submission,
and structured verification requirements
                    |
                    +------------------------------+
                    |                              |
                    v                              v
Optional official metadata API        Browserbase opens the rendered
such as YouTube, when configured       public page in a cloud browser
                    |                              |
                    |                              v
                    |                   Stagehand observes the page,
                    |                   reveals public text when needed,
                    |                   and extracts structured evidence
                    |                              |
                    +---------------+--------------+
                                    |
                                    v
                     Foleo merges source-attributed
                     evidence and records conflicts
                                    |
                                    v
                     Campaign brief, brand rules,
                     revision history, and evidence
                     are assembled into one context
                                    |
                                    v
                     The Token Company compresses
                     the context before LLM analysis
                                    |
                                    v
                     Fetch.ai Foleo Proof Agent
                     evaluates every requirement
                                    |
                                    v
                     Structured output is validated
                     with deterministic post-checks
                                    |
                                    v
                     Supabase stores the job,
                     evidence, result, and metrics
                                    |
                                    v
                     Brand, creator, and admin
                     dashboards display the report
                                    |
                                    v
                     Sentry traces the full workflow

Why we combine APIs with Browserbase

Official platform APIs are generally the best source for metadata they reliably expose.

For example, a YouTube API integration may provide:

video title;
channel name;
description;
publication time;
platform identifiers.

However, official APIs have limitations. They may require special approval, support only certain account types, omit visible disclosure labels, or fail to represent exactly what a normal viewer sees on the rendered page.

Browserbase provides the fallback and visual evidence layer.

Browserbase opens the actual public page in a cloud browser. Stagehand then helps interpret the rendered content and extract:

creator name and handle;
captions and descriptions;
brand mentions;
hashtags;
promo codes;
sponsorship disclosures;
outbound links;
unavailable-content messages;
potentially risky or prohibited claims.

The system can combine both sources.

Official APIs are treated as authoritative for metadata they reliably provide, while Browserbase verifies the visible public experience. Conflicts are preserved rather than silently overwritten.

Browserbase gathers evidence. It does not invent the final verdict.

Why context compression is necessary

A verification request can include much more than one social media caption.

The complete context may contain:

the campaign brief;
brand guidelines;
required deliverables;
prohibited claims;
creator-brand messages;
previous revision requests;
official platform metadata;
Browserbase evidence;
prior verification attempts.

Language models process text in units called tokens. Sending more tokens generally increases model cost and processing time. Large prompts can also contain repetition and unnecessary wording that distracts from the facts needed for the decision.

The Token Company SDK wraps the agent's OpenAI-compatible client and compresses this context before it reaches the model.

The objective is not simply to shorten the prompt. It is to remove redundant information while preserving the campaign requirements and evidence required for an accurate result.

Foleo supports:

compression enabled or disabled;
graceful fallback to the original context;
compressed versus uncompressed comparison mode;
SDK-provided metrics when available;
explicit bypassed or unavailable states.

In a live needs-revision verification, the system recorded a 4 - 10% SDK-measured context reduction. We present that as one observed result, not as a universal guarantee.

Comparison mode can also evaluate whether compressed and uncompressed runs reach the same verdict.

Fetch.ai, Agentverse, and ASI

The compliance system is implemented as a Python uAgent using Fetch.ai's ASI-compatible chat protocol.

The Foleo Proof Agent:

acknowledges incoming chat messages;
understands Foleo-specific verification requests;
retrieves a narrow verification payload from Foleo;
processes compressed campaign and evidence context;
validates structured model output;
applies deterministic evidence and verdict checks;
submits the result back to Foleo;
returns a readable explanation through chat.

The same verification capability can therefore be used in two ways:

Directly through the Foleo product workflow.
Conversationally through Agentverse and ASI.

For example, a user can ask:

Verify the Northstar Summer Creator Challenge submission and explain every requirement that passed or failed.

The agent can then return the score, evidence, missing requirements, and revision guidance.

The Agentverse registration and ASI-compatible chat were verified live on June 21, 2026.

Agent address:

agent1qwz8kxt27y7gmur2sp4guhxk9nxx93mhkl7v3lnz82ejc9mx4q60gjxkk9h

Sentry observability

This workflow depends on several external systems.

A platform API may fail. Browserbase may time out. Stagehand may return malformed evidence. Compression may be unavailable. The agent may return an invalid result. A database operation may fail.

Sentry connects those stages into one observable trace:

foleo.creator_post_verification
├── authorize request
├── load campaign
├── load creator submission
├── retrieve official metadata
├── initialize Browserbase
├── navigate to public content
├── extract Stagehand evidence
├── assemble context
├── compress context
├── call Foleo Proof Agent
├── analyze compliance
├── persist evidence
└── persist result

This makes it possible to see:

which stage failed;
how long evidence collection took;
whether compression ran;
whether the agent completed successfully;
whether the result was persisted;
where performance bottlenecks occurred.

The Next.js and Python Sentry integrations include privacy scrubbing, global error capture, source-map uploads, structured logs, and workflow spans.

Production source-map upload was confirmed through Vercel.

Evidence and decision integrity

The hardest part of autonomous verification is not generating a score. It is maintaining a trustworthy chain from campaign requirement to visible evidence to final decision.

Foleo reduces unsupported decisions by:

Separating evidence collection from compliance reasoning.
Validating Stagehand extraction through Zod.
Preserving evidence source attribution.
Recording conflicts between API and browser evidence.
Requiring structured model output.
Validating agent responses through Pydantic.
Applying deterministic post-checks.
Returning inconclusive when evidence cannot be verified.
Showing evidence and confidence to the human reviewer.

The system distinguishes between:

evidence that was found;
a requirement that is visibly missing;
conflicting evidence;
content that could not be accessed.

The model is not instructed to assume that missing evidence exists.

Security

Foleo Proof Agent follows a narrow-access architecture.

Provider credentials remain server-side.
The Python agent has no broad database credentials.
Internal requests are signed using HMAC-SHA256.
Signatures include a timestamp, nonce, request ID, HTTP method, path, and body digest.
Replay attempts, stale timestamps, and invalid signatures are rejected before loading data.
Supabase Row Level Security limits access to the owning brand, assigned creator, and administrators.
Public URL validation blocks unsupported protocols and unsafe private-network targets in production.
Browser automation does not sign in, bypass access controls, like, follow, comment, purchase, or submit third-party forms.
Sentry does not receive credentials, cookies, authorization headers, private campaign text, agent seeds, or unnecessary personal information.

Reliable demonstration strategy

The live demo does not depend on Instagram, TikTok, YouTube, or X remaining accessible during judging.

Foleo hosts three original simulated creator posts:

a fully compliant submission;
a submission missing a sponsorship disclosure and required hashtag;
a submission containing a prohibited claim.

Demo pages:

https://getfoleo.co/demo/social-posts/compliant
https://getfoleo.co/demo/social-posts/needs-revision
https://getfoleo.co/demo/social-posts/prohibited-claim

These pages are public, mobile responsive, and clearly labeled as simulated content. They do not imitate a protected social platform.

How we built it

Product and web application

Next.js
React
TypeScript
Tailwind CSS
Zod
Vercel

The Next.js application handles authentication, authorization, campaign and submission workflows, verification-job creation, Browserbase evidence collection, secure agent communication, and role-aware reports.

Database and authentication

Supabase
PostgreSQL
Row Level Security

Supabase stores campaign requirements, creator deliverables, verification jobs, structured evidence, results, compression metrics, and safe failure states.

Browser evidence

Browserbase
Stagehand

Browserbase provides the cloud browser, while Stagehand observes and extracts structured rendered-page evidence.

Autonomous agent

Python
Fetch.ai uAgents
Agentverse
ASI
Pydantic
Railway

The Python agent runs on Railway and communicates with the Next.js application through narrow signed endpoints.

Context compression

The Token Company SDK
OpenAI-compatible model client

The Token Company compresses the assembled campaign and evidence context before the compliance decision.

Monitoring

Sentry

Sentry traces the complete workflow across the Next.js application and Python service.

Challenges we ran into

Separating evidence from judgment

It would have been easier to ask one model to open a page and return a verdict. However, that would make the result difficult to inspect or trust.

We instead separated:

Evidence collection.
Context preparation.
Compression.
Compliance reasoning.
Deterministic validation.
Human-facing reporting.

Supporting real platforms without depending on them

Social platform APIs may require approval, while rendered pages may block automation or change unexpectedly.

We designed official metadata adapters and Browserbase as complementary evidence sources, while keeping the primary demonstration functional through Foleo-hosted public content.

Securing the agent connection

The Python agent needed enough access to process a verification without receiving unrestricted database credentials.

We created narrow internal contracts and signed requests rather than sharing broad service credentials.

Reporting compression honestly

Compression savings can vary significantly depending on the input.

We expose measured SDK results when available and clearly distinguish measured values, estimates, unavailable metrics, and bypassed compression.

What we learned

The most important lesson was that an autonomous reviewer becomes more credible when it can admit that it does not have enough evidence.

Generating a score is easy. Preserving the chain from:

campaign requirement
→ public evidence
→ validated decision
→ human action

is much harder - and much more valuable.

We also learned that sponsor technologies are most powerful when they solve different stages of one real product workflow rather than appearing as separate integrations.

In Foleo Proof Agent:

Browserbase and Stagehand provide the eyes.
The Token Company optimizes the context.
Fetch.ai provides the agent and conversational interface.
Sentry provides operational trust and observability.

What's next

The next stages for Foleo Proof Agent include:

introducing provider budgets and rate controls;
evaluating video transcripts and visual-frame evidence with appropriate consent and policy controls;
measuring time saved for brand reviewers;
measuring false-positive and false-negative rates;
adding campaign-specific scoring weights;
learning from approved human-review corrections;
connecting successful verification to later campaign and payment workflows.

The long-term goal is for Foleo to support the full creator-brand relationship - not just helping brands discover creators, but also helping both sides manage, verify, and complete collaborations with greater confidence.

Built with

Next.js
React
TypeScript
Tailwind CSS
Supabase
PostgreSQL
Python
Fetch.ai uAgents
Agentverse
ASI
Browserbase
Stagehand
The Token Company SDK
OpenAI-compatible APIs
Sentry
Zod
Pydantic
Vercel
Railway

Team

Founder and developer: Rokin Hasan Prottoy
Team: Solo founder build
Product: https://getfoleo.co
Repository: https://github.com/rokinpro/foleo
Social: @getfoleo

Foleo Proof Agent is only one part of the larger Foleo platform. The full product includes creator discovery, UGC campaigns, portfolios, submissions, collaboration management, customer-facing creator services, and other tools designed to support the complete creator-brand relationship.

We are preparing to launch Foleo in Bangladesh, where we aim to become the country’s first end-to-end creator collaboration platform of its kind. Anyone interested in the broader product, roadmap, or technical architecture can explore our documentation and repository.

Foleo is also currently exploring pre-seed funding to support launch, creator acquisition, product development, and expansion. Investors, advisors, brands, and ecosystem partners interested in the creator economy are welcome to reach out.

Built With

agentverse
asi
browserbase
fetch.ai
next.js
postgresql
react
sentry
stagehand
supabase
thetokencompany
typescript
vercel
zod