AI Autofill, But You Stay in Control.

Impleo reads your application forms, drafts every answer in your voice, and waits for your approval before a single field is touched.

Install from Source · Installation Guide · How It Works · Architecture · Privacy · Roadmap

The Problem

Every hackathon, fellowship, scholarship, accelerator, and job application asks the same mechanical fields — name, email, phone — followed by the questions that actually take time: "Why do you want to join?", "Tell us about a project you're proud of.", "Describe your background."

Answering those well means pulling context from your resume, your GitHub, your past applications, and whatever you can remember about your own story — then writing it out, by hand, again. Multiply that by every program you apply to, and it's hours of repetitive, low-leverage typing that has nothing to do with whether you're qualified.

Existing tools don't solve this:

• Traditional autofill (Chrome's built-in, LastPass, Dashlane) only knows static key-value pairs — name, address, card number. It has no idea how to answer "what's a technical challenge you overcame?"
• Generic AI assistants (ChatGPT, Gemini web) can draft an answer, but you're still copy-pasting between tabs, re-explaining your background every session, and manually matching answers back to form fields.
• Resume parsers and "smart" form bots either fabricate plausible-sounding nonsense the model made up, or — worse — submit forms on your behalf without you ever reading what was sent.

AI-generated answers should never be blindly submitted. A wrong fact, an off-tone sentence, or a hallucinated detail in a scholarship essay isn't a bug you can quietly ship a fix for — it's already been read by a human on the other side.

The Solution

Impleo is a human-in-the-loop AI copilot for application forms. It never types a form field it hasn't earned the right to guess, and it never submits anything on its own.

  1. Open the application  →  2. Impleo detects fields  →  3. AI drafts responses
                                                                       │
  6. Impleo fills fields   ←  5. You approve or edit     ←  4. You review every answer

Step	What happens
1. Detect	Click the extension icon on any application page. Impleo scans the live DOM — Google Forms, Luma, Greenhouse, Lever, Workday, Typeform, or a generic HTML form — and extracts every question, its field type, and its options.
2. Draft	Your stored profile (resume, projects, writing samples, past answers) plus the extracted schema go to the AI model of your choice in a single call. It returns a structured, per-question answer — not a wall of text to cut apart yourself.
3. Review	Every answer renders as a card: the question, the generated response, and a confidence badge. Nothing touches the page yet.
4. Approve / Edit / Regenerate / Skip	You decide, field by field. Regenerate with a one-line instruction ("make it shorter," "more technical") if the first draft isn't right.
5. Fill	Only what you approved gets written into the live form, with a per-field result so you can catch anything that didn't match.
6. Never submit	The submit button is never touched, clicked, or focused programmatically. That action stays yours, always.

Human-in-the-loop, by construction — not by policy. There is no code path in Impleo that can submit a form. Review isn't a setting you can turn off.

Product Demo

The side panel, waiting for a form Local-first, private-by-design, and bring-your-own-key — stated up front, not buried in settings.

Review, edit, or regenerate any answer Every card shows a confidence badge and a live regenerate box — steer the tone without leaving the panel.

🎬 See It In Action

_{A minute in — extract, review, and fill a real form without Impleo ever touching Submit. Watch the full-quality MP4.}

Features

🧠 AI-Native Contextual, on-voice answer generation Confidence scoring per answer (high / medium / low) Regenerate with a natural-language instruction Single combined classify + generate call — no wasted latency	🔒 Human-in-the-Loop Accept / Edit / Regenerate / Skip on every field Nothing is written until you click Fill Per-field fill report (filled / no match / not found) Submit button is never touched — structurally, not by convention	🕶️ Privacy-First Bring your own API key (BYOK) All processing runs on your machine No hosted backend, no analytics, no tracking Profile export/import for full data portability
🧬 Memory That Compounds Identity memory — remembers canonical answers (email, CTC, notice period) across every form Learned answers — previously accepted answers are reused instead of regenerated Q&A history (last 50) feeds future few-shot context	🌍 Works Everywhere Google Forms, Luma, Greenhouse, Lever, Workday, Typeform Generic HTML form fallback Hackathons, fellowships, scholarships, internships, accelerators, grants, job applications, event registrations	🔌 Multi-Provider Anthropic (Claude), Google Gemini, OpenAI, and Groq Swap providers and models per your own account/tier Key tested against a live call before it's saved

Why Impleo Is Different

Capability	Traditional Autofill	Generic AI Assistant	Resume Parsers / Form Bots	Impleo
Understands question context	❌	✅	⚠️ Partial	✅
Requires your approval before writing	➖ N/A	➖ N/A	❌	✅
Writes in your voice	❌	⚠️ Generic	❌	✅
Works across arbitrary form platforms	⚠️ Known sites only	❌ Manual copy-paste	⚠️ Limited	✅
Privacy-first / local processing	✅	❌ Cloud-only	❌ Cloud-only	✅
Runs on your own API key	➖ N/A	❌	❌	✅
Never auto-submits	➖ N/A	➖ N/A	❌ Often does	✅ Always

Architecture

Impleo is a single local piece — a browser extension — with no hosted backend, no local server, and no multi-tenant infrastructure. One instance per person, everything running inside your own browser.

flowchart TB
    subgraph Browser["Chrome Browser — everything runs here"]
        SP["Side Panel — React + Tailwind (Vite)<br/>onboarding · review cards · settings<br/>prompt builder + provider adapter (src/sidepanel/lib/)"]
        CS["Content Script — injected on demand<br/>extractGoogleForm / extractLumaForm / extractGenericForm<br/>fillGoogleForm / fillLumaForm / fillGenericForm"]
        ST[("chrome.storage.local + IndexedDB<br/>profile · qaHistory · identityMemory · learnedAnswers · apiKey · documents")]
    end

    PROV(["Your chosen provider<br/>Anthropic · Gemini · OpenAI · Groq"])

    SP -- "chrome.scripting.executeScript" --> CS
    CS -- "extracted form schema" --> SP
    SP -- "reads / writes locally" --> ST
    SP -- "single structured-output call, direct HTTPS" --> PROV
    PROV -- "answers + confidence" --> SP
    SP -- "approved answers only" --> CS
    CS -- "writes fields, never clicks Submit" --> Page(["Live form on the page"])

Loading

Layers, and why each exists:

• Content scripts are self-contained, serialized functions injected only on the active tab, only on demand — no persistent background scanning, no broad content_scripts manifest entry.
• The side panel is the whole application. Its lib/ builds the prompt, calls your chosen provider directly over HTTPS, and reads/writes all local storage — there is no server in between.
• Your API key is held in chrome.storage.local and sent only to the provider you chose, as that request's authentication header — never to any Impleo backend, because there is none.
• The review pipeline and human approval gate sit structurally between generation and fill: the fill function only ever receives the subset of answers you explicitly approved.
• Identity memory + learned answers persist in chrome.storage.local (documents in IndexedDB) so recurring fields (email, CTC, notice period, "why this role") get smarter, not just faster, over time.

Privacy

Your data. Your model. Your rules.

Impleo is built local-first because application answers are personal — resumes, salary expectations, government IDs, life story. That data should never leave a machine you don't control.

• ✅ Local processing — everything runs inside your browser. There is no server, local or hosted; the only network call is the one you configured, straight to your chosen provider.
• ✅ User-owned API keys — you supply your own key for the provider you trust; Impleo never ships a shared key or proxies your calls through anyone's infrastructure.
• ✅ No backend storage — there is no Impleo-hosted backend. Your profile, history, and identity memory live in your browser's own storage (chrome.storage.local), and your documents in IndexedDB, on your device.
• ✅ Sensitive IDs stay local — government/financial IDs (Aadhaar, PAN, passport, date of birth) are recognized by field label and filled from your remembered value locally; the value is never placed in the text sent to the AI provider.
• ✅ No tracking, no analytics, no telemetry.
• ✅ No data selling. There is no business model that depends on your data — Impleo has no backend to collect it in.
• ✅ No hidden uploads. The only network call Impleo ever makes on your behalf is the one you configured, to the provider you chose, when you click Generate.

Installation

Prerequisites

• Node.js 18+ and npm
• Google Chrome (or any Chromium-based browser: Edge, Brave, Arc)
• An API key from at least one supported provider (Anthropic, Google Gemini, OpenAI, or Groq)

Quick start

git clone https://github.com/Agnik47/Impleo.git
cd Impleo

cd extension && npm install && npm run build

Then load extension/dist as an unpacked extension via chrome://extensions (enable Developer mode → Load unpacked), and enter your API key in the side panel's Settings — Impleo runs a live test call before saving it, so you know immediately if the key works. There is no server to start.

Using an AI coding agent? Hand it INSTALLATION.md directly — it's written as a step-by-step runbook an agent can execute unattended (clone, install, build, verify), with the two steps that require a human — loading the unpacked extension and entering your API key — clearly called out. It also covers common setup failures in more detail than the summary above.

Configuration

Supported providers

Provider	Label	Default model suggestion
Anthropic	anthropic	claude-sonnet-5
Google Gemini	gemini	gemini-2.0-flash
OpenAI	openai	gpt-4o-mini
Groq	groq	llama-3.3-70b-versatile

Model IDs are never hardcoded to a fixed release — you can type any model string your account has access to under Settings, and that exact string is sent on every call.

Local storage behavior

All persistent state lives in your browser's own storage (chrome.storage.local, plus IndexedDB for documents) and is never synced anywhere:

• Profile — personal info, links, education, skills, projects, resume text, writing samples
• Q&A history — last 50 approved question/answer pairs, used as few-shot context
• Identity memory — canonical values (email, phone, CTC, notice period, etc.) reused across every form
• Learned answers — previously accepted answers, matched by normalized question text
• Documents — resume/CV/portfolio files, stored as raw bytes in IndexedDB; their contents never leave your device
• API key — stored once via onboarding/Settings in chrome.storage.local, sent only to your chosen provider as the request's auth header, never to any Impleo backend

Optional settings

• Export / Import profile — back up or transfer your full profile, Q&A history, identity memory, and learned answers as a single JSON file. Exported files contain sensitive values in plain text — handle them like a resume, or more carefully.

Repository Structure

impleo/
├── extension/                   Chrome MV3 extension (Vite + React + Tailwind)
│   ├── manifest.json             Permissions, entry points, icons
│   ├── background.js             Minimal service worker (side panel behavior only)
│   ├── content-scripts/          Self-contained extractors/fillers, injected on demand
│   └── src/sidepanel/            React side panel — onboarding, review flow, settings
│       ├── App.jsx                View routing
│       ├── ReviewFlow.jsx         Extract → review → fill state machine
│       ├── components/            Review cards, buttons, UI primitives
│       └── lib/                   The app's brain (client-side, no server):
│                                   providers.js — Anthropic/Gemini/OpenAI/Groq adapters
│                                   promptContext.js — builds profile + schema + history prompt
│                                   generate.js — classify + generate orchestration
│                                   fieldRegistry.js — canonical identity-memory fields
│                                   storage.js / documentStore.js — chrome.storage + IndexedDB
│
├── landing/                     Marketing site (Vite + React)
│
├── IMages/                      Product screenshots and brand assets
│
├── docs/                        Product spec, architecture rationale, brand guide
│
└── INSTALLATION.md              Step-by-step setup runbook (human- and AI-agent-friendly)

Contributing

Impleo started as a personal tool and is built to stay small, boring, and correct rather than sprawling. Contributions are welcome, with a few ground rules:

1. Read docs/ before proposing architectural changes. docs/PRD.md, docs/ARCHITECTURE.md, and docs/STRUCTURE.md capture why the system looks the way it does — several design choices (no hosted backend, self-contained content scripts, single combined AI call) are deliberate trade-offs, not oversights.
2. Human-in-the-loop is non-negotiable. Any change that lets Impleo write to a form field without an explicit user approval, or touches a submit control, will not be merged.
3. Privacy is a hard constraint. No new telemetry, no hosted storage, no calling any endpoint the user didn't configure themselves.
4. Keep PRs scoped. Small, reviewable diffs with a clear rationale beat large speculative ones.
5. Verify against a real page. Content-script changes should be checked against an actual Google Form / Luma event / target platform, not just read through — DOM structures on these sites are not stable across selectors.

To get started: fork the repo, follow Installation, and open a PR against main with a description of what you changed and why.

---

Where Impleo is growing

Impleo isn't on the Chrome Web Store yet — but it's finished, open source, and free today. It just arrives by clone instead of by one click.

%%{init: {'theme':'base','themeVariables':{'fontFamily':'Geist, Segoe UI, sans-serif','fontSize':'14px'}}}%%
flowchart LR
    S["<b>SEED</b><br/><br/>Built, working<br/>and MIT licensed"]
    P["<b>SPROUT</b><br/><br/>Clone and run it locally<br/>— the whole extension, free"]
    C["<b>CANOPY</b><br/><br/>One-click install from<br/>the Chrome Web Store"]

    S ==> P -.-> C

    classDef done fill:#0B0F0E,stroke:#28C94E,stroke-width:2px,color:#A3A3A3
    classDef here fill:#111a12,stroke:#A6D91A,stroke-width:3px,color:#F5F5F5
    classDef soon fill:#0B0F0E,stroke:#27332D,stroke-width:2px,color:#737373
    class S done
    class P here
    class C soon

Loading

You are here → Sprout. The dashed edge is the part that isn't built yet.

Grow the jungle

A jungle grows faster with more hands in it. Cheapest effort first — you don't need to open a pull request to help:

	Way in	What it does
✦	Drop a seed	Star the repo. One click, and it puts Impleo in front of the next person hand-copying their résumé at 2am.
✳	Flag a broken vine	Form platforms rewrite their DOM without warning. If an extractor stops biting on a page, open an issue with the URL — that report is the fix.
⑂	Grow a new branch	Greenhouse, Lever, Workday and Typeform extractors are all still unclaimed above. Pick one and it's yours.
☰	Clear the path	Setup notes, a sharper error message, a docs fix — anything that saves the next person the hour you just spent.

Three rules of the jungle. Everything else is up for discussion, but these three aren't: 1. Never auto-submit — there's no code path that clicks submit, and there never will be. 2. Privacy is a hard constraint — no telemetry, no hosted storage, no endpoint the user didn't choose. 3. Keep it scoped — a small, reviewable diff with a clear rationale beats a large speculative one.

License

Impleo is released under the MIT License.

MIT License — Copyright (c) 2026 Agnik Paul
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files, to deal in the Software
without restriction, subject to the inclusion of the above copyright notice.

See the LICENSE file for the full text.

Install from Source · Installation Guide · Architecture · Privacy · Contribute

_{Made for anyone tired of typing the same answer twice.}

_{MIT licensed · Local-first, single-user · No tracking, no telemetry, no data selling}