embco

The payables agent for the ERPNext you already run.

It reads your purchases, decides what to pay and when, pays suppliers in USDC on Arc itself, and acts on what happened. A smart contract sets the limits it cannot cross.

Documentation · Dashboard · How it works · Connect your ERPNext

Built for the Tameion Agents Hackathon (Canteen x Circle, on Arc). Early and built in public: the agent runs against a live ERPNext and pays on Arc Testnet.

What it does

• Checks every invoice against its order and receipt, its price history and the contract's limits. Only an unproven supplier wallet or a duplicate bill stops it outright.
• Decides, with an AI model that weighs what the checks found: pay now, pay on a date, hold, or ask the owner, each with a written reason.
• Pays itself in USDC, through a shop contract on Arc that holds the owner's limits, then reads the result: the transaction, or the contract's or Circle's own error. When something stops a payment, it looks up why and tells the owner what only they can fix. Every payment is recorded back in ERPNext.
• Talks with the owner on the dashboard and on Telegram: questions, instructions, notices.
• Remembers every decision and answer in a hash-chained journal that nobody can rewrite unnoticed.

Why it exists: Agents and Ledgers in 2026. How each part works, with diagrams: the documentation.

Built with

Layer	Technology
Agent
Chain
ERP
Owner apps
Tooling

Project structure

embco/
├── agent/               the agent: its brain and the checks it cannot skip
│   ├── agent.py         the brain: the AI model decides, pays and acts on the result
│   ├── think.py         one session: wake the model, run it, remember the result
│   ├── plan.py          turns the decisions into the cycle's payment plan
│   ├── models.py        what the agent decides, and what it keeps for the next session
│   ├── prompt.py        the briefing the model reads
│   ├── cost.py          estimates what a session cost
│   ├── wiring.py        builds the agent from the settings
│   ├── tools/           what the agent can read and do
│   ├── reflexes/        what wakes it, and the cycle every 15 minutes
│   ├── guardrails/      the controls, the fixed rule (HOLD, ASK, notes) and the gate
│   ├── memory/          the hash-chained journal
│   └── explain/         plain-language explanations for the owner
├── services/            what the agent stands on
│   ├── erp/             the ERPNext adapter
│   ├── circle/          Circle developer-controlled wallets (EOA and smart contract accounts)
│   ├── earn/            Arc Earn integration: zero-custody idle USDC yield in ERC-4626 vaults
│   ├── unified_balance/ the owner's Unified Balance (Circle Gateway), through Circle's kit
│   ├── payments/        simulate on Arc, send, follow, record
│   ├── hub/  shops/     the hosted service behind the dashboard
│   ├── signing/         supplier wallet signatures
│   ├── telegram/        the Telegram bot
│   ├── settings.py      settings from the environment, checked once
│   └── cli.py           the embco command
├── contracts/           ShopPayables, ShopFunding, ShopEarn and their factories (Solidity, Arc Foundry)
├── dashboard/           the owner dashboard and the supplier page (static, MetaMask)
├── connector/           prepares an ERPNext instance
├── deploy/              install.sh and the server files it sets up
├── docs/                the documentation site (MkDocs)
└── tests/               tests for the agent and the services

Circle tools

Tool	What embco does with it
Wallets: developer-controlled wallets	Creates each shop's agent wallets (a smart contract account that sends payments, and an EOA that signs Unified Balance spends) and signs every transaction, with idempotency keys
Wallets: Gas Station	Pays the network fees of the agent's smart contract account, so the owner never sends it gas
Unified Balance Kit (@circle-fin/unified-balance-kit)	Moves the owner's USDC from other chains into their Unified Balance and brings it to their wallet on Arc, with the fees estimated first
Gateway	Holds the owner's Unified Balance; the ShopFunding contract deposits into it for the owner
Arc Earn (ERC-4626)	Parks the owner's idle USDC on Arc into owner-approved vaults (e.g. Morpho) and unparks it to pay invoices, zero custody
USDC and Arc	The currency the suppliers are paid in, and the chain where the shop contract runs

Getting started

Use ours

No installation. Open the dashboard, connect your wallet, create your shop contract, and follow Connect your ERPNext.

Run your own

The same dashboard and agents on your own server (Ubuntu or Debian, with a domain):

git clone https://github.com/JaDi03/embco.git
cd embco
cp .env.example .env
nano .env                       # your domain, an Arc node URL, Circle and Anthropic keys
sudo bash deploy/install.sh

Then shops connect through your dashboard, as they do on ours. Details: Run your own server.

Tests: agent, contracts, dashboard and docs

uv run ruff check . && uv run pytest -q

The contracts use Arc Foundry (Linux and macOS; on Windows, WSL):

cd contracts
arc-forge test                                                                 # unit and fuzz tests
ARC_TESTNET_RPC_URL=https://rpc.testnet.arc.io arc-forge test --network arc    # plus the Arc fork test

The dashboard has no build step:

cd dashboard && node --test

The documentation site, locally:

uv run --no-project --with-requirements requirements-docs.txt mkdocs serve

License

MIT