Freelance Gig Agent
The agent scans the boards, scores what it can deliver, drafts the bids — you approve with one tap, it builds and ships the work.
One rule decides this whole architecture: “automation can prepare and support; humans must decide and send.” Upwork deprecated RSS specifically to kill auto-bidders, its API reviews every key and doesn’t allow proposal submission, and browser automation on a logged-in session is the fastest route to a ban. Freelancer.com, unusually, has a public API with real bid endpoints. So we build the compliant machine: full automation on Freelancer.com behind a tap-to-approve gate, and draft-only assistance anywhere else.
Winning gigs is drafting; delivering them is engineering. Hermes does both — proposal drafts scored against a capability profile, then actual delivery with its coding tools and parallel subagents. And its learning loop turns every won or lost bid into a better proposal skill.
Start Here: One Prompt
Copy this prompt and send it to the agent on your Pocketcorp. It sets up everything in this guide and reports back when it’s done. The steps below explain what your agent is doing — and how to check its work.
Set up my freelance gig pipeline. Rules before anything: full
automation only on Freelancer.com (its API officially supports
bidding). Upwork is draft-only — never automate a logged-in session
there. And every single bid waits for my explicit yes.
1. Interview me: what can we actually deliver, at what price, and
what do we never touch? Write a capabilities skill: CAN deliver,
CANNOT (never bid), red flags to skip silently, pricing anchors.
2. Write a proposal-writer skill: open with THEIR problem restated
in one concrete sentence; then exactly how we’d do it (stack,
steps, timeline); one relevant work sample; a specific price and
date from the anchors; under 120 words; no exclamation marks;
one question at the end.
3. I’ll get an API token from developers.freelancer.com — store it
in ~/.hermes/.env as FREELANCER_TOKEN.
4. Cron hourly: scan new projects matching our capability keywords,
dedupe against the pipeline file, score 0–100 (skills match 40,
budget vs anchors 25, client quality 20, competition 15). For
every job scoring ≥70: draft the proposal and message me for
yes/no.
5. On “bid”: submit via the API and log it in the pipeline file
(bid → won/lost → why).
6. Cron weekly: analyze wins and losses, patch the proposal-writer
skill with what the data says.
7. When we win: create ~/gigs/<client>/ and plan the delivery with
me. Client messages always route through me — you draft, I send.The Stack
Send the prompt — answer its interview honestly
Paste the prompt and the agent asks the questions this whole build stands on: what can it actually deliver to a paying stranger, at what price, and what should it never bid on? Your answers become its capability profile — the file that separates an agency from a liability:
---
name: capabilities
description: What we can deliver, at what price, and what to skip
---
## CAN deliver (bid confidently)
- Static & marketing websites (HTML/Astro/Next), incl. deploy
- Landing page copy, product descriptions, blog posts
- Web scraping & data-entry automation (Python)
- Spreadsheet automation, PDF/data extraction pipelines
## CANNOT (never bid)
- Mobile apps, smart contracts, anything requiring my identity
documents, video calls promised in the brief, design-from-scratch
brand work
## Red flags → skip silently
- Budget under $50 with vague scope, "easy job for experts",
client history of disputes, payment not verified
## Pricing anchors
- Landing page: $150–400 · Scraper: $100–300 · Copy: $0.10/wordThe job scanner
Your one account task: get a free API token at developers.freelancer.com — yes, Freelancer.com officially supports bidding through its API — and paste it to the agent when it asks. It stores the token and schedules the hourly scan:
/cron add "0 * * * *" "Scan Freelancer.com via the API for new
projects matching our capability keywords (last hour, dedupe
against the pipeline file). Score each 0-100: skills match 40,
budget vs anchors 25, client quality 20, competition 15.
For every job ≥70: draft a proposal and message me for approval."Do not point this at Upwork. No API bid path exists, and automating a logged-in browser session there is behaviorally fingerprinted (submission speed, polling patterns) — bans rose 23% in 2025 and a suspended profile is unrecoverable income. For Upwork, the agent may draft proposals in its own workspace; you paste and submit them yourself in your own browser.
Proposals that win
From the same interview, the agent writes itself a proposal style guide — short, concrete, and allergic to “Dear Hiring Manager”:
---
name: proposal-writer
description: Draft freelance bids that sound human and land
---
- Open with THEIR problem restated in one concrete sentence —
proof of reading, not "Dear Hiring Manager".
- Second line: exactly how we would do it (stack, steps, timeline).
- Include one relevant work sample link. Never more.
- Quote a specific price and delivery date from the anchors.
- Under 120 words. No exclamation marks. One question at the end.
- Track outcomes in the pipeline file: bid → won/lost → why.The approval loop
💼 Score 84: “Scrape 3 supplier catalogs into a master sheet, weekly refresh” — $250 budget, verified client (4.9★, 12 hires). Draft: “You need three catalogs merged into one clean sheet that stays current without anyone touching it. I’d build a Python scraper per supplier, normalize SKUs into one Google Sheet, and set a weekly auto-refresh — delivered in 4 days for $220, including a month of fixes if a site changes. Which supplier’s format is the messiest?” — Bid?
bid
Submitted via API ✓ ($220, 4 days). Pipeline: 3 live bids, 1 awaiting reply. I’ll ping you the moment the client responds.
Client messages always route through you — the agent drafts replies, you approve. Platforms (and clients) can tell when they’re talking to a bot, and the trust you’re selling is human.
Win → build → ship
This is where a Pocketcorp earns its keep: the same agent that won the bid opens its workspace and does the work. Websites get the full build-deploy-screenshot treatment; scrapers get written and tested against the real targets; copy gets drafted in the client’s voice. Hermes spins up subagents to parallelize — one on the scraper, one on the docs — while the main session tracks the deadline.
- Every deliverable lands in ~/gigs/<client>/ — inspect it in VS Code or the file browser before it ships
- You do final QA and upload the delivery — the client relationship stays yours
- Payment, disputes, reviews: human territory, always
Let losses teach it
A weekly cron reviews the pipeline file: win rate by job type, which openers got responses, which price points died. Hermes patches its own proposal-writer skill from the data — its learning loop applied to sales. Ten bids in, the proposals stop sounding like templates. Thirty in, they sound like the freelancer clients rehire.
What you end up with
A pipeline that scans hourly, bids only with your tap, builds the work in a real dev environment, and gets measurably better with every won and lost gig — your own AI agency with you as the closer.
