This is the builder's field guide for our Solutions Architects and Solutions Engineers: how to build apps, APIs, agents, and AIs for your users, customers, and ICPs on 🤫 One. Learn the mindset and the build blocks - Agent One, PCHP consent and receipts, and the open rails (MCP, A2A, AP2, UCP) - how to personalize to an ICP with consent, and how to do it within our values and the law. Steve-Jobs-simple, deep enough to teach from.
Ten blueprints across a whole life: the job, who it helps, the smallest slice to ship first, the consented context, the rails, the guardrails, the evals, and where your human ingenuity matters most. Plus the ten best practices every agent on 🤫 One is built to. Build the smallest thing that works, show it to a real person, and bring the world along.
You listen to a customer, understand the human and the ICP, and design the smallest end-to-end slice that helps. You choose the build blocks, set the guardrails, and keep the whole thing legible. This guide gives you the mental model and the patterns.
You turn the design into a working app, API, or agent on 🤫 One - context, tools, consent, evals, shipped and measured. This guide gives you the loop, the consent handshake in practice, and the taste to know when it is good.
You can build something genuinely personal for a customer's ICP without collecting their life. One holds the consented context; PCHP hands you the exact scoped field with a receipt. That is the whole trick, and this guide teaches it.
Describe the solution you wish existed for the customer - like you'd explain it to a colleague. The AI writes the first version. You don't need to know the syntax to start; you need to know what "good" looks like for that human.
Try it. Notice what's off. Ask for the change in plain words. This loop - describe, run, react - is "vibe coding": you steer with taste while the machine does the typing.
Ask for small, self-contained chunks you can understand and reuse. Small pieces are easy to fix, easy to share, and easy to trust. (This is "code like bacteria" - more below.)
Keep a few simple tests or examples that prove it works ("evals"). When the AI changes something, your checks tell you the truth. Taste plus tests beats vibes alone.
Six blocks. The private layer holds the human's context; PCHP wraps every access in consent and a receipt; the open rails let One reach tools, other agents, payments, and commerce. Live today: Agent One, PCHP, and the rails via the hushh MCP. Planned: the Verified Network (below).
The private, owner-owned agent that holds the human's context on hardware they own. Reach for it when a solution needs real, personal context to be useful - and when that context must never leave the owner's control. It is the trust boundary you build around.
The Personal Consent Handshake Protocol - identity, consent, scoped exchange, and a signed receipt on every access. Reach for it whenever your solution touches personal data. It is how you stay consent-first by construction, not by policy. See /pchp.
Model Context Protocol - how an agent reaches tools and data. Reach for it to give One the right tools for a task. PCHP wraps each call in consent and writes it to the owner's ledger. Live today via the hussh MCP; see /developers.
How two agents talk. Reach for it when your solution's agent needs to coordinate with the customer's One, or two Ones meet on behalf of their humans. The handshake between them is PCHP.
How agents pay. Reach for it when a solution needs to settle a transaction on the human's behalf. PCHP gates the settlement and records it on both ledgers, so money never moves silently.
Open commerce rails - how agents transact. Reach for it when a solution buys or sells for the human. PCHP scopes exactly what is shared and puts the receipt on a ledger only the owner can read.
Start with the person, not the feature. What is this customer's ideal customer trying to accomplish? What would genuinely help them, on their terms? Name the real job before you name a tool. Work backwards from the human.
Not the whole platform - the thinnest path that helps one real person, one real time, end to end. A slice you can ship this week and honestly evaluate beats a grand plan you can't.
Most of the magic is here. Give the agent the scoped context it needs (with consent), the tools to act (over MCP, A2A, AP2, UCP), and clear guardrails: least privilege, purpose-bound scope, expiry, and a receipt for every access.
Keep a handful of honest checks that prove the slice does what you promised - and keep a human in the loop on what matters. Taste tells you what to build; evals tell you whether it works. Never ship a personal-data flow you can't verify.
Put it in front of the real person, watch what actually happens, and grow from there. Publish what changed. Small, legible, shipped, and honest beats big, opaque, and pending.
This is the whole trick. One holds the customer's consented context; PCHP hands your solution the exact scoped field, for one purpose, with a receipt. Personalization without surveillance - and it is auditable by construction.
The customer's personal context - preferences, history, situation - lives inside their own 🤫 Agent One, on hardware they own. You never copy it into your app's database. There is no shadow profile to assemble or to breach.
When your solution needs something personal, it asks One for exactly that scope, with a transparent reason, an expiry, and a purpose. The owner approves with a biometric unlock. You get the field you asked for - nothing more.
Every scoped exchange writes a signed receipt to a ledger the owner can read and revoke. Your solution is personal and auditable at the same time. Personalization without surveillance is the point, and this is how it holds.
You describe intent; the model writes the code; you steer with judgment and tests. The skill becomes taste and clarity, not syntax. For you: you can ship a real customer slice this week by describing it well and steering carefully.
Neural nets are a new kind of software you "program" by choosing data and checking results. The dataset and the evals are as important as the code. For you: curate good examples and good checks - that's half the work of a reliable solution.
Write pieces so small and self-contained that anyone could copy one out - "yoink" - without importing your whole project. Build a bigger backbone only where you must. For you: prefer 5 lines over 50; make each connector a gist another SE could love.
Think of the model as a kernel with tools, memory, and peripherals around it. Solutions are built by giving it the right context, tools, and guardrails. For you: most of the magic is in the context and tools you give One, not a clever prompt.
Measure behavior with small, honest checks, and keep a human in the loop on what matters. Taste tells you what to build; evals tell you whether it works. For you: a handful of real examples beats a wall of opinions - especially for a customer flow.
The best way to understand is to build the smallest version that works, end to end, then grow it. Small, legible projects teach more than big plans. For you: ship one tiny working agent today; understanding compounds.
Distilled from the public teaching and open-source of builders we learn from - especially Andrej Karpathy. See our gratitude & learnings page. Admiration for public work; not an affiliation or endorsement.
The fastest way to learn this is to build the smallest agent that helps one real person, one real time. Name a real job for a customer's ICP. Design the thinnest end-to-end slice. Give One the scoped context (with consent), one or two tools over the rails, and clear guardrails. Keep two or three honest evals. Ship it, watch it, and grow from there.
The 🤫 Academy is built around exactly this outcome - a semester you build through until you can ship a genuinely useful working agent, with a certification to prove it. This guide is the reference you build from; the Academy is the program. We cross-link on purpose and do not duplicate. For the architecture, the consent handshake in practice, and patterns for apps, APIs, and agents, read the deep playbook.
Build consent-first, with the human at the center, privacy by construction, and strictly within the law. When we say we transform rigid systems, we mean we operate transparently and lawfully while openly advocating and building for better, more flexible ones - never evading, gaming, or circumventing rules. The consent-first system is itself the better system. Transparency and lawfulness are the strategy, not an obstacle to it. The deep playbook has the do / do-not list for builders.
We try to practice what this guide preaches: small, self-contained code anyone could yoink; a backbone only where complexity demands it; consent-first by construction; and a public story that maps to real, legible code. We publish our protocol (PCHP) openly, keep our research in the open, and welcome contributions - because a good idea spreads when everyone can build to it.
Solutions Architects and Solutions Engineers who build working solutions - apps, APIs, agents, and AIs - for customers, users, and ICPs on top of 🤫 One. Architects shape the solution and its guardrails; engineers make it real, shipped, and measured. It is a practical playbook, not a marketing tour: the mindset, the build blocks, the build loop, how to personalize with consent, and the guardrails.
Live today: 🤫 Agent One (the private, owner-owned agent), PCHP (consent-first identity, scoped exchange, and a signed receipt on every access), and the open agent rails - MCP, A2A, AP2, UCP - that PCHP wraps, reachable through the hussh MCP and REST surfaces on /developers. Planned and on the roadmap: the 🤫 Agents Verified Network, with human biometric verification and human-to-human verification for safety and security. Build on what is live; design for what is coming, and never describe the Verified Network as if it already ships.
You don't collect their life - you ask for one field at a time. The customer's context lives inside their own 🤫 Agent One. When your solution needs something personal, it requests exactly that scope through PCHP, with a transparent reason, a purpose, and an expiry. The owner approves, you receive only that field, and a signed receipt lands on a ledger they can read and revoke. Personal and auditable, without a shadow profile.
No, the opposite. We win by being transparent and lawful, never by loopholes. Building consent-first, with the human at the center and privacy by construction, is itself the better system. Where existing systems are rigid, we operate strictly within the law while openly advocating and building for more flexible, more humane ones. We do not evade, game, or circumvent laws or rules - transparency and lawfulness are the strategy, not an obstacle to it.
The Academy is the program - a semester you build through until you can ship a genuinely useful working agent, with a certification to prove it. This field guide is the reference you build from. They cross-link: start a tiny agent here, go deep in the Academy. See /academy.
They're distilled, in plain English, from the publicly shared teaching and open-source of the best builders - especially Andrej Karpathy (Software 2.0, the LLM OS, "code like bacteria," nanoGPT, and his Zero to Hero course). This guide reflects our admiration for that public work; it does not imply any affiliation or endorsement.
Pick one real customer job, design the thinnest end-to-end slice on 🤫 One, and ship it this week - personal by consent, honest by evals, lawful by construction.
This guide reflects admiration for the publicly shared teaching of builders like Andrej Karpathy and does not imply affiliation or endorsement. One is a product of Hushh Technologies Corporation (brand: 🤫 “hussh”), an independent company. One runs on third-party silicon, systems, and cloud; all company names are used solely to describe the platforms on which One software runs. Hushh Technologies is not affiliated with, endorsed by, sponsored by, or partnered with any company named.