TrusTech — See locally. Sanitize locally. Reason securely. Act with confidence.
Local AI. Sensitive data protected.
Real-time PII detection with transparent confidence scores and latency tracking.
TrusTech analyzes website signals and flags potential security risks before you interact.
Detect locally. Redact intelligently. Protect privacy.
Asking about Is the task done
It detects sensitive information through local AI-powered vision and OCR, helping protect personal data before remote AI processing.
TrusTech - Extension
Asking for Approval
TrusTech flags suspicious websites and potential impersonation risks before you share sensitive information.

Inspiration

AI browser agents are becoming capable of navigating websites, interacting with forms, and automating everyday tasks. However, these capabilities raise an important question: what happens when an AI agent encounters passwords, personal information, financial details, or other sensitive data while browsing?

I started building TrusTech to explore how browser automation could become more privacy-conscious. Instead of sending unrestricted webpage information to an AI model, the idea is to process visual information locally, detect sensitive data, sanitize context before external transmission, and keep browser actions under explicit safety controls.

Our vision is to make AI-powered browsing more useful without treating user privacy as an afterthought.

What it does

TrusTech is a privacy-focused AI browser agent that combines local visual perception, sensitive-data detection, privacy-oriented redaction, AI-assisted planning, and controlled browser automation.

Its key capabilities include:

Local visual perception: Uses YOLOS-tiny for object detection and Tesseract OCR to extract text from images.
Sensitive-data detection: Combines pattern matching and contextual rules to identify information such as contact details and financial identifiers.
Privacy firewall: Helps sanitize text and visual context before it is sent to remote AI services.
AI-assisted planning: Uses a backend integrating remote language models to help interpret browser tasks and propose actions.
Confidence and risk controls: Applies validation and safety policies, with user confirmation for actions that require additional approval.
Browser interaction and verification: Coordinates webpage observation, element targeting, actions, and checks of the resulting page state.

The central principle is simple: observe locally, sanitize sensitive context, reason securely, and act only through controlled execution paths.

How we built it

We built TrusTech using React and TypeScript for the browser-extension interface, Chrome and Firefox extension APIs for browser integration, and Python with FastAPI for the backend.

For visual perception, we integrated Transformers.js with YOLOS-tiny for local object detection and Tesseract.js for OCR. We developed a privacy pipeline combining sensitive-data detection, contextual analysis, redaction, and transmission controls.

The agent architecture separates planning from execution. A controller coordinates observations and proposed actions, while validation and policy checks determine whether an action is permitted. The backend integrates remote AI providers, but browser execution remains on the extension side.

We organized the code into dedicated modules for the agent controller, background messaging, content scripts, vision, privacy, trust analysis, execution, and verification. This modular design helps us investigate failures and strengthen individual security boundaries without rebuilding the entire application.

Challenges we ran into

One major challenge was balancing visual understanding, privacy, and performance. An agent needs sufficient context to identify the correct webpage element, but collecting too much information creates privacy risks and increases processing costs.

Another challenge was coordinating communication between the extension interface, background service worker, content scripts, and backend. Dynamic webpages, navigation events, changing elements, and browser lifecycle behavior can interrupt an otherwise valid task.

We also faced the challenge of making privacy and safety controls consistent across the system. Detecting sensitive information is only part of the problem; every network request must be sanitized, and every browser action must be validated and authorized.

Finally, local inference introduced performance constraints. We had to consider model loading, CPU and memory usage, OCR latency, bundle size, and the additional latency introduced by remote reasoning.

These challenges reinforced the importance of testing the complete browser workflow instead of relying only on individual component tests.

Accomplishments that we're proud of

We are proud of building a modular browser-agent prototype that brings local visual inference, OCR, sensitive-data analysis, privacy-oriented redaction, AI-assisted planning, and guarded browser execution into one architecture.

We integrated real local inference components rather than relying exclusively on mock AI outputs. Our development and testing work also helped us distinguish implemented functionality from simulated demonstrations and identify security gaps that need to be addressed before production use.

Another accomplishment is establishing a clear separation between AI-generated proposals and the code responsible for validating and executing browser actions. This provides a foundation for improving the agent while keeping safety policies independent of the model.

Most importantly, TrusTech has evolved into a substantial engineering project that explores an important problem in AI: how to combine useful automation with meaningful privacy protections.

What we learned

Building TrusTech taught us that a reliable AI agent requires much more than connecting a language model to a browser.

Local perception, deterministic validation, privacy controls, action authorization, and outcome verification each solve different problems. A strong design must account for the failures of individual components and ensure that one failure does not bypass the rest of the system.

We also learned that privacy claims must be supported by evidence. A redaction function passing a unit test does not prove that sensitive information can never reach a remote service. That requires end-to-end tests, adversarial inputs, outbound-payload inspection, and careful validation of every execution path.

Finally, we learned to measure real performance, clearly label simulations, and prioritize security and reliability before expanding the feature set.

What's next for TrusTech

Our next priorities are to strengthen the privacy boundary, close alternate execution paths that bypass safety controls, prevent sensitive values from entering logs or unnecessary memory, and expand sensitive-data detection and visual redaction.

We also plan to improve real-browser integration testing, measure end-to-end latency and resource utilization, improve recovery from failed actions, and make demonstration metrics reflect actual execution.

Longer term, we want to explore local language-model reasoning, multilingual OCR, stronger semantic grounding, and privacy-preserving memory while retaining the same validation and safety architecture.

Our goal is to make TrusTech a dependable browser-agent platform that helps people automate everyday web tasks while keeping privacy, transparency, and user control at the center of the experience.

TrusTech — See locally. Sanitize locally. Reason securely. Act with confidence.