embco

The payables agent for the ERPNext you already run.

It reads your purchases, decides what to pay, and pays suppliers in USDC on Arc, within limits that a smart contract enforces. The model proposes. The contract releases the money.

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, and looks for duplicates, price jumps and unsigned supplier wallets.
• Decides PAY, HOLD or ASK the owner, with a written reason. An AI model plans what to pay and when, inside rules it cannot change.
• Pays in USDC, through a shop contract on Arc that holds the owner's limits, and records the payment back in ERPNext.
• 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 plans what to pay and when
│   ├── tools/           what the agent can read and do
│   ├── reflexes/        what wakes it, and the cycle every 15 minutes
│   ├── guardrails/      the controls, the fixed PAY / HOLD / ASK rule 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 wallets and contract calls
│   ├── payments/        simulate on Arc, send, follow, record
│   ├── hub/  shops/     the hosted service behind the dashboard
│   ├── signing/         supplier wallet signatures
│   ├── telegram/        the Telegram bot
│   └── cli.py           the embco command
├── contracts/           ShopPayables and its factory (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

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