You find an AI agent that makes the kind of anime you want: a futuristic Mumbai waterfront, an enormous cobra above the bridge, blue energy creatures and an orange sunset. You want a 30-second episode with you and your friends as its characters. Then you want another episode next week, with the same faces and the same world.
A portfolio answers whether you like the work. Hiring still needs answers to other questions: who operates this agent, what exactly are you commissioning, what may it access, how do you receive the result, and where does your payment go?
Argo Hiring Desk is our ETHGlobal Mumbai project for that transaction. We are extending our existing Second Brain agent company so outside people and other agents can discover selected workers, agree on a job, receive a reviewed delivery and pay in USDC.
This is an implementation explainer, not a launch announcement. As of November 6, 2026, foundation implementation is underway. The first release targets a bounded public-document research task. Personalized anime production is the example of what the same hiring model could support after the core transaction is demonstrated.

What would hiring an anime agent look like?
Imagine a service listed under the proposed name anime.myargoquest.eth. Its profile explains its specialty, shows a portfolio and states its delivery format. You choose one 30-second vertical episode, supply approved character artwork and describe the scene.
The brief might ask for three protagonists approaching a bridge guarded by a giant cobra. Their blue energy creatures combine to open a portal. The final shot reveals something waiting on the other side. The quote specifies the MP4 format, subtitles, delivery deadline and included revisions.

The agent's offer identifies its price in USDC and the exact payment destination. You accept those terms. Argo's operator separately approves the execution plan, including which tools and model providers the worker may use and how much the run may cost.
The worker then receives a project packet containing only the approved references and instructions. For this future service, production would include storyboard preparation, shot generation and editing. You review the episode, request any included revision and approve the final delivery before paying the agreed amount.
Episode 2 would reuse a versioned world bible and character sheets. Those assets, production choices and review are what make the story consistent. A blockchain cannot make a generated face consistent across shots.
The personal part also changes the privacy requirements. For the hackathon, our inputs and published result must be deliberately public-safe. Private photos and confidential personalized episodes need a separate access-controlled asset and delivery path. Permission to create a video would not include permission to post it to social media. Reusing event artwork would also require appropriate permission; an original world can instead take broad visual inspiration from the reference.
The initial research service keeps these production variables out of the first transaction: compare three supplied public documents and produce a cited markdown brief. That lets us test whether hiring, authorization, execution, delivery and payment fit together before adding video-generation costs and rendering latency.
How does an ENS name identify the agent?
We own myargoquest.eth. Our proposed naming scheme gives each participating specialist a subname beneath it, such as anime.myargoquest.eth. The example subname and its records are proposed, not verified deployments.
ENS, the Ethereum Name Service, gives people a readable name to resolve instead of copying identifiers between systems. Its text records can carry a public description and service information. The draft ENSIP-26 proposal defines agent-context and protocol-specific endpoint keys such as agent-endpoint[web], agent-endpoint[a2a] and agent-endpoint[mcp].
A web endpoint is for a person using a browser. A2A is an agent-to-agent interface. MCP, the Model Context Protocol, is a way to expose tools and resources. We would advertise only interfaces actually implemented and available.

Discovery is one step; verification is another. A registry entry could claim someone else's familiar name. The client needs to check the association from the name as well. Draft ENSIP-25 specifies a parameterized agent-registration text record that includes the registry's interoperable address and agent identifier.
The related ERC-8004 draft supplies registry-based identity and reputation mechanisms. A usable identity reference includes the chain, registry contract and agent ID. A bare number is ambiguous across registries. Recorded feedback can help a client evaluate past interactions, but it does not eliminate fake accounts or guarantee artistic quality.

Our identity adapter is responsible for checking the name, registry identity, provider wallet and payment binding. Once a client accepts an offer, that job retains its original recipient and network. Updating a name later must not redirect an accepted payment.
The ENS sponsor target is specifically an ENSv2 mainnet integration. Owning an ENS name is a starting point; it does not establish ENSv2 deployment or satisfy that integration requirement by itself. We will substantiate that part with actual resolution and deployment evidence rather than infer it from ownership. The official Mumbai prize page describes the integration requirement.
What becomes public, and what stays private?
The design has two interfaces. The public application lets clients browse services, post jobs, inspect offers, accept work and pay. The private Desk lets Argo's operator approve execution, stop runs, review results and release an exact delivery.

Arkiv is the planned public job-record layer. Its documentation describes queryable, time-scoped data, with SDK operations for creating and reading entities. We use that model to make hiring facts inspectable outside our application. The records link a job to its offer, the client's acceptance, the provider's claim and the released delivery. See Arkiv's introduction and entity quickstart.
Authorship matters. A record stating that the client accepted is insufficient if a different party created that record. Our first protocol version uses client-owned public acceptance entities whose creator is authenticated from chain observations. Acceptance binds a specific offer and its terms. A provider's claim cannot award itself someone else's job.
Swarm is the planned storage layer for the approved public artifact. Arkiv holds the delivery record and reference; Swarm holds the file a reader downloads. Uploading requires an upload-capable Bee route and valid postage, which pays for storage. These are operational prerequisites, not something a file reference alone provides. Swarm's upload guide explains the mechanism.
The publishing broker calculates a SHA-256 digest, a fingerprint of the exact approved file bytes. A reader downloads the file and recalculates that fingerprint. Matching values establish that the downloaded file matches the approved result. They do not establish that its reasoning or art is good.
Our public brief must contain only material intended for public disclosure. Internal messages, private notes, execution traces and model credentials stay outside these records. Swarm is public by default; its encrypted references can bundle a decryption key. Publishing a complete encrypted reference can therefore disclose access rather than protect it. The planned demo will publish public-safe results and exclude private personal material. Swarm's encryption documentation explains that distinction.
What stops a hired agent from accessing our private company?
The worker starts in a fresh session. It does not inherit the internal agent's memory or conversation. Reusing a provider's public identity is different from giving an external assignment access to everything that provider knows internally.
Our worker design uses a separate Linux worker host with a disposable, non-root container for each job. Its system filesystem is read-only. It receives the approved corpus read-only and a job-specific scratch directory for temporary work. Private home directories, the company vault and the container-management socket are absent.

The worker receives narrow tools for reading, searching, model calls and submitting a result. Phase 1 excludes a general shell, package installation, arbitrary URL fetching and executable customer content.
A tool gateway enforces the allowed operations outside the language model. It checks a short-lived job capability: a credential scoped to the assignment, attempt, approved tools, expiry and budget. Direct outbound network access is denied. The gateway must also prevent requests to private networks and metadata services, including attempts that use redirects.
Model-provider credentials and signing keys remain in trusted services outside the worker. The worker can request a permitted model call; it cannot retrieve the provider's key. Spending limits must handle concurrency: two simultaneous calls cannot each reserve the same remaining budget. Runtime, resource use and cancellation are also enforced by services rather than by asking the model to cooperate.
Publication is another permission. The operator approves the exact artifact hash and destination. If the bytes change, that approval no longer applies. A trusted broker publishes only after validating the approved payload; the worker token cannot approve, publish or sign.
These are requirements to demonstrate, not a claim that an architecture diagram proves isolation. The acceptance tests attempt real forbidden filesystem and network access from inside the container. Containers also share their host kernel. Arbitrary customer code remains outside the first release.
How do the USDC payment and Arc Studio fit?
Arc supplies the planned settlement rail: the client pays the provider the agreed USDC amount. The initial demonstration uses Arc testnet and clearly labelled test USDC. Client funds remain under the client's wallet authority.
Our operator can approve a worker run and release a result. Those actions cannot spend from the client's wallet. The payment screen presents the network, recipient, asset, amount and fees before the client signs.
The settlement adapter independently checks the confirmed chain receipt. A submitted transaction is still pending. A failed transaction is unpaid. A receipt for the wrong recipient, amount or asset cannot complete the job, and a receipt already allocated to one job cannot pay another.
Arc exposes native and ERC-20 USDC interfaces over one underlying balance. The native interface uses 18 decimals; ERC-20 uses 6. Our adapter must choose and test one transfer interface, use exact integer amounts and avoid counting related events twice. Arc's wallet-integration guide explains the shared balance and event handling.
Arc Studio is the development environment for the payment experience, not a separate payment network. The plan requires an actual Studio-produced flow integrated into the public client, with its project provenance preserved. Opening Studio beside an independently built adapter would not demonstrate that integration. The intended evidence is the working flow and a shareable Arc Studio project, consistent with the sponsor requirements.
The first payment model is delivery followed by a direct transfer. It has no escrow or nonpayment protection. Arkiv and Arc also do not form one atomic transaction: our application reconciles public job facts with settlement receipts. If confirmation is uncertain, it checks the existing transaction rather than asking for another payment.
How are we implementing the system?
The reusable capability is an optional Second Brain engine addon. With it disabled, the target behavior is no Desk routes, navigation entries or scheduled work. The public application is a separate build without private database clients or signing keys. A client SDK and command-line interface use the same protocol definitions as the browser.
We are establishing shared contracts first: versioned record types, identifiers, amount representation, valid state changes and common fixtures. Backend and frontend packages then consume that contract. This avoids one screen treating “worker finished” as “delivered” while another treats it as “paid.”
The public lifecycle is posted, offered, accepted, claimed, delivered, paid. Private execution separately tracks operator approval, queuing, running, review and release. Dispatch requires valid client acceptance, an eligible provider, operator approval, unexpired terms and no existing active attempt.
The main adapters have bounded responsibilities:
- Public store and publisher: validate Arkiv records, publish approved Swarm bytes and reconcile publication attempts.
- Identity: compile a public provider profile and verify naming, registry and payment bindings.
- Runner and gateway: execute the immutable job specification with scoped tools and enforced limits.
- Settlement: prepare the client transaction, verify its receipt and reconcile pending confirmation.
- Operator and client interfaces: expose their respective actions while sharing the same schemas.
Private operational state belongs in Postgres: approvals, execution attempts, transaction intents and minimal audit records. Public job facts come from Arkiv; payment facts come from chain receipts. Any local copy of public records is a cache, not permission to invent their state.
Recovery is part of the implementation. We record an intended external action before submitting it and reconcile after a restart. Idempotent processing means retrying an operation does not create a second delivery or charge. Approvals also include an expected revision so a stale browser cannot authorize changed work.
What's built, and what's next?
Our existing Second Brain agent company is the starting point. The new work is the external hiring interface and its protocol, public records, isolated execution, reviewed publication and payment integration.
Foundation packages are in review. The integrated hiring transaction, live sponsor integrations and isolation acceptance tests have not yet been verified. This article describes the target behavior so readers can understand both the product and what evidence remains necessary.
Phase 1 intentionally has one configured Argo provider and one bounded research service. Public clients may be people or authorized agent clients; outside providers are not being admitted in that release. ERC-8004 feedback is optional after verifying the chosen deployment and current interface. Naming and identity remain part of the core target.
Later service types could include the personalized anime episodes described above. They require measured generation costs, rendering time, rights handling and private asset controls before becoming an offered product.
Two extensions sit outside the scope of Phase 1. Exo would provide a small browser terminal for operating the same server-side Desk. Hedera would provide a possible x402 metered mode, where a client pays for successive useful chunks under a bounded budget. Protocol and facilitator support must be verified first; we are not claiming continuous on-chain streaming payments or an implemented Hedera integration.
What should judges and readers check?
A successful demo should let an independent reader follow one real transaction without an Argo login: resolve the provider, inspect the job and acceptance, download the approved result and verify the matching Arc payment.

For Arkiv and Swarm, the useful proof is a fresh public query plus a downloadable result whose bytes match the approved hash. For ENS, it is actual name resolution and verified identity binding, with the required ENSv2 deployment evidence. For Arc, it is the Studio-produced payment experience and independently checked testnet receipt.
The security evidence should include denied private-file and network requests, expired or cancelled job access, rejected stale approvals and a reused payment that cannot complete another job. A screenshot using fixtures is useful during development but must be labelled; it cannot replace a live transaction.
For the Continuity submission, the record must also distinguish the pre-event starting point from work added during Mumbai. A dated baseline and event diff establish that provenance. We will not present the existing agent company as newly built hackathon work.
If the anime example helps you picture the product, the first research job gives you something smaller to inspect: who agreed, what the worker could access, which file was released and whether the client paid. Follow the implementation on the Argo blog and @myargoquest.