Skill file (for agents): /themes/SKILL.md
This reference maps the four Synthesis hackathon themes to the CROPS framework, Ethereum infrastructure, and real human needs. Use it to connect design thinking outputs to the specific constraints and opportunities of each theme.
CROPS is not a feature checklist. It is a set of non-negotiable architectural constraints drawn from the Ethereum Foundation's mandate. Every project at The Synthesis should be evaluated against all four. If your design fails on any one of them, it needs to be reworked.
No single actor can selectively block, freeze, or disable the system for specific users. The infrastructure works for everyone or it doesn't work at all. There are no whitelists, no gatekeepers, no single points where access can be revoked.
What this means for builders: Your agent's infrastructure should function even if a government orders a platform to freeze your user's account. Even if an API provider decides they don't like what your user is doing. Even if a payment processor unilaterally decides to block a transaction. The system routes around these failures by design.
Design test: If you remove any single intermediary from your system, does it still work? If the answer is no, you have a censorship vulnerability.
Every component is auditable. No proprietary black boxes. Every piece of the system can be inspected, forked, and run independently.
What this means for builders: Your user should be able to read the code that governs how their agent operates. They should be able to verify that the system does what it claims. If your team disappears, someone else should be able to pick up the project and keep it running.
Design test: Could a stranger read your code and understand exactly what your agent does with the user's data, money, and identity? If there's a component they can't inspect, that's a problem.
User data is not exposed beyond necessity. Privacy is the default, not an option the user has to enable. The protocol layer supports unconditional privacy; any moderated forms of disclosure happen downstream, under the user's control.
What this means for builders: Every interaction your agent has with a service generates metadata. Payment amounts, timing, counterparties, access patterns. Your design should minimize this metadata by default. The user decides what to reveal and to whom, not the infrastructure.
Design test: If an adversary gained access to every log generated by your system, what could they learn about the user? The answer should be: as little as possible.
The system does what it claims to do, nothing more and nothing less. It withstands technical failure, social coercion, and the disappearance of any single party, including the builder.
What this means for builders: Your agent's behavior should be verifiable and predictable. The user should have an exit path that doesn't depend on you. Smart contract logic should be auditable. The system should degrade gracefully, not catastrophically.
Design test: What happens if your server goes down? What happens if you abandon the project? What happens if a component is compromised? The user should never be trapped.
Your agent moves money on your behalf. But how do you know it did what you asked? Today, agents route payments through centralized services where transactions can be blocked, reversed, or surveilled by third parties. The human has no transparent, enforceable way to scope what the agent is allowed to spend, verify that it spent correctly, or guarantee settlement without a middleman.
Priya the freelancer can't verify that her agent paid the right vendor. Daniela's cross-border payments get frozen by providers she has no relationship with. Ravi the gig worker gets paid on a schedule and at a rate controlled entirely by the platform. Tomasz can't pay a source without creating a traceable financial record. Sofia can't enforce consistent spending rules across the dozen services her family's agents interact with.
The common thread: the human delegated a financial task to an agent, but the financial infrastructure the agent runs on doesn't answer to the human. It answers to the intermediary.
Your agent interacts with other agents and services. But trust flows through centralized registries and API key providers. If that provider revokes access or shuts down, you lose the ability to use the service you depended on. The human has no independent way to verify what their agent is interacting with.
Kai the developer can't verify that an agent service actually does what it claims. Marcus the researcher trusts API providers with his query logs because he has no alternative. Daniela can't evaluate whether a new supplier's agent is legitimate or a front. Jin the creator can't tell if a licensing request comes from a real buyer or a scam. Amara delegates everything and has no way to audit the services her agent chose.
The common thread: the human can't independently verify the identity, capabilities, or track record of the agents and services their agent interacts with. They're forced to trust claims made by the very parties who benefit from being trusted.
Your agents make deals on your behalf. But the commitments they make are enforced by centralized platforms. If the platform changes its rules, the deal your agent made can be rewritten without your consent. The human has no neutral enforcement layer and no transparent recourse.
Daniela's agent negotiates supplier contracts on platforms that can change their terms unilaterally. Kai's agents commit to deliverables and prices with no enforceable mechanism beyond API promises. Lena's DAO agent disburses community funds but the spending rules depend on her personally enforcing them. Ravi has no way to collectively negotiate terms with platforms. Jin's licensing agreements exist only on platforms that take a cut and control the terms.
The common thread: agents are making commitments on behalf of humans, but those commitments are only as durable as the platform they were made on. The human has outsourced negotiation to an agent but has no guarantee that the result will be honored.
Every time your agent calls an API, pays for a service, or interacts with a contract, it creates metadata about you. Spending patterns, contacts, preferences, behavior. The agent isn't leaking its own data. It's leaking yours. There's no default privacy layer between your agent and the services it touches.
Tomasz's agent creates a map of his investigative work through the metadata of every service it contacts. Marcus's research queries build a profile of his academic interests that anyone with log access could exploit. Amara's delegated life management creates a comprehensive surveillance profile she never consented to. Sofia's family agents expose her kids' digital lives to every service they interact with. Priya's vendor relationships and financial flows are visible to every payment processor her agent touches.
The common thread: agents create metadata as a byproduct of doing their job. That metadata is about the human, not the agent. And no one is protecting it by default.
Most strong projects will touch multiple themes. Here are the natural overlaps:
Pay + Secrets: Private payments are where these two themes merge. An agent that pays without revealing who's paying or what they're buying solves both the payment sovereignty problem and the metadata problem simultaneously.
Trust + Cooperate: Verifiable identity and reputation are prerequisites for enforceable cooperation. If agents can't verify each other, they can't make commitments that mean anything.
Pay + Cooperate: Smart contract escrow is both a payment mechanism and a cooperation mechanism. Money moves when commitments are fulfilled, verified onchain.
Trust + Secrets: Proving something about yourself (I have permission, I have a track record, I'm a real entity) without revealing unnecessary information is the intersection of trust and privacy. Zero-knowledge proofs sit here.
All four: The ideal agentic infrastructure lets an agent pay privately (Secrets), through rails that can't be blocked (Pay), to a counterparty whose reputation is verifiable (Trust), under terms that are enforced by the protocol (Cooperate). This is the full stack.
These are tools and standards being built across the Ethereum ecosystem that builders can use at The Synthesis. Each one connects to one or more themes:
Builders are encouraged to combine these tools. The strongest projects will use infrastructure from multiple categories to build a coherent solution grounded in a real human need.