ENTARC — The Autonomous VC Agent

The AI VC that writes its own checks: evaluates startups with Gemini and autonomously invests USDC via Circle agent wallets — within hard policy limits, no human in the loop.

Comment 6

Inspiration

Every agent demo ends the same way. The agent reasons, plans, picks the right tool — and then a human clicks "pay". That click is the whole gap between an AI agent and an AI agent that runs a business.

Venture capital is the sharpest version of the problem. The work of a seed investor is reading evidence and moving money against a thesis. The reading is already automatable. The moving is where everything stops: wire approvals, multisig signers, a partner on holiday. So we built the missing half — an agent whose output is a payment.

What it does

ENTARC is an autonomous venture agent. Founders submit projects; the agent evaluates them and funds the ones that clear its bar, milestone by milestone, in USDC — with no human in the approval path.

The decision chain is three steps, visible live in the Agent Console:

1. Due diligence (Gemini). Gemini 3 Flash reads repo activity, milestone structure and category, then returns a 0–100 trust score with a written rationale. It runs at temperature 0: the same evidence must produce the same score when that score releases money.

2. Spending policy. The verdict passes through a policy gate: max $5 per transaction, a rolling $20 per 24 hours, and a minimum trust score of 70. There is deliberately no human-approval branch and no override flag — the policy is the approval path. A risk-monitor pause flips a flag the gate enforces.

3. Settlement. If the policy clears, the agent calls Circle's developer-controlled wallet API and USDC leaves its own wallet on Arc. The transaction is polled until the on-chain hash lands, then written back to the deal: proposal FUNDED, milestone RELEASED, hash stored.

Two runs from the demo — both real

MoonVault — "guaranteed 100x, anonymous team, no public code." Gemini scores it 0/100, calling it a high-probability fraudulent scheme. The policy gate denies the release. No transaction is created.

A NEW ONE — 340 commits, rug-proof architecture, live on testnet. Gemini scores it 88/100, STRONG_BUY. The policy clears it and the agent sends 1.5 USDC, then 0.9 USDC for the second milestone. Confirmed on Arc in 0.51 seconds, for a fee of $0.0008.

The denial matters as much as the payment. It is the difference between an agent that is allowed to spend and an agent that is trusted to spend.

Verify it yourself
Agent wallet (Circle, Arc Testnet) 0xd8d42a355fe806545490758cf76e9c4b6ff535ad
Autonomous payment #1 1.5 USDC
Autonomous payment #2 0.9 USDC

How we built it

  • Reasoning: Google Gemini 3 Flash via the Generative Language API, JSON-forced output, temperature 0.
  • Payments: Circle Developer-Controlled Wallets. The agent provisions its own wallet on ARC-TESTNET (idempotent), reads its USDC balance by Circle token id, and settles with createTransaction plus polling until the hash appears.
  • Guardrails: a standalone policy module that every payment path must call. The 24-hour budget is computed from the on-chain-backed audit trail, so it cannot be gamed by drafts.
  • Idempotency: the key is derived from (proposal, milestone, proposal version). A retry of one release can never double-spend; a genuinely new funding round gets a fresh key.
  • Stack: Next.js 14 App Router, TypeScript, Prisma + PostgreSQL, Tailwind, NextAuth. Live at entarc.xyz.
  • Network: Arc, Circle's stablecoin L1, where USDC is the gas token — so fees and payouts are denominated in the same dollar.

Challenges we ran into

Making an LLM verdict safe to spend against. Our first scoring pass gave the same project 88 one minute and 68 the next — a threshold of 70 turned into a coin flip. We moved analysis to temperature 0 and rewrote the system prompt to score on verifiable evidence rather than "conservatively", which removed the bias and made runs reproducible.

Honest fixtures. An early demo run scored a real project 12/100. Gemini was right: our seed data claimed "500+ commits" while the repo fields were left at zero, and it flagged the contradiction. We corrected the fixtures and added a genuinely weak project for the denial path, so the demo shows a deserved denial rather than a manufactured one.

Arc is not a normal EVM chain. USDC is the native token, so there is no ERC-20 contract to call for transfers, and the faucet rejects a native: true request outright. Transfers go through Circle's token id, not a token address.

Replacing a simulation with real money. The escrow endpoint used to return Math.random() transaction hashes. Cutting that out meant reconciling the schema (orphan escrowTxHash columns nothing ever wrote), the wallet layer and the UI in one pass — and labelling the flows that are still previews, so nothing on screen implies more than it does.

Accomplishments that we're proud of

  • An agent that has actually moved money, twice, with hashes anyone can verify — not a video of an agent that would.
  • Guardrails that are enforced in code and demonstrably deny a bad deal, which is the harder half of autonomy.
  • A console that makes the whole chain legible in one screen: score, verdict, hash.

What we learned

Agentic payments are not "add a wallet to the agent". The design work is in the guardrails: what can it spend, on what evidence, how often, and what stops it. Once those are explicit, removing the human from the approval path stops being reckless and starts being the point.

Card rails cannot serve this pattern — fixed per-transaction cost, multi-day settlement, chargeback windows and a human in the approval path. Sub-second, sub-cent, final settlement in a stablecoin is what makes machine-speed capital allocation possible at all.

What's next for ENTARC — The Autonomous VC Agent

  • Mainnet on Arc the day it opens — a config change; the wallet layer is unchanged.
  • Circle nanopayments for continuous milestone streaming instead of discrete tranches.
  • Agent-to-agent negotiation: founders' agents proposing terms to ENTARC, both sides settling in USDC.
  • Selling due-diligence reports through the Circle Agent Marketplace, so the agent both pays and gets paid.

Built With

Share this project:

Updates

posted an update —

Have you developed a brilliant idea but hit a capital wall? Don't let the search for funding shelve your vision.

Leave behind the cumbersome steps of traditional VC processes and months of pitch meetings. @entarcai is now live on @arc with its Mainnet Beta!

Circle CEO Jeremy had asked us to work in this area last March. We pursued that goal and brought our work to the mainnet, and the day has finally arrived: the Autonomous Venture Intelligence Agent and Marketplace has launched on ARC in beta.

Powered by autonomous AI agents and Circle’s specialized Autonomous Agent kits, Entarc is a next-gen AI VC ecosystem that deeply analyzes projects and matches them with the right investors.

It works in a straightforward way:

  • Submit your project on Mainnet Beta.
  • Let the autonomous AI architecture analyze your project and present it to the investor network.
  • Receive direct email notifications when investors who value your startup make an offer.

It’s time to turn your idea into code, and your code into investment.

To experience the Mainnet Beta and take the first step;  https://entarc.xyz 

Submission history