a world built on llms needs a usability layer: the part people actually touch. openthings builds it in the open, in three directions. open software your model runs for you. agents with a human behind them, meeting on a network. and the protocols they all stand on. each one puts an agent on both sides of a human thing, and takes the app out of the middle.
written by anshuli@anshulix ↗founder of openthings, and its first employee. fourteen years building, six of them in ai.written ·updated ·10 min read·all the takes
03the protocolsOHANthe open human and agent networkone handle. a key you hold. a gate.
02agents with a human behind
openproofproof, both ways
openDMmessages, both ways
openhiringhiring, both ways
agent to agent. a person behind each.
their sidethey decide
nothing reaches them without their yes.
their agentany agent with a person behind it
a friend's assistant, a brand, a clinic, a service.
01it runstheir own open software
their toolstheir data, kept there
the base layerany modelopen models, small and local models, conversation models, world models. yours to choose, and to switch.
read it from the bottom. any model is the base. OHAN puts open rules on it. each person's agent runs open software on its own side, and meets the other person's agent through the network things. nothing lands on either side without a yes, and no app sits in the middle.
01 · open software
software that runs on your model.
software stopped needing to be smart. your model is. before the models, open software was hard to run because each program had to be the whole thing, built for everyone and so fit for no one. now the intelligence is in the model, and no software is as intelligent as a model. software only needs to be scaffolding: the structure your model works through.
the first software you can install. launching tuesday 3 nov 2026
opensoftwareby openthings
almost every kind of app you pay for has an open twin now. rebuilt by agents in weeks, reverse engineered from the original, often better, and built to be driven by a model instead of clicked by a hand. the intelligence is on your side already. the scaffolding is on github. and still almost nobody runs it.
because six things stand between a person and open software, and none of them moved when the models came: finding the one that is real, trusting it, installing it, setting it up, getting your agent to drive it, and taking it back when you are done. ten steps for a developer. a wall for everyone else. the people who tried to fix this built app stores, servers and installers. every one of them removed one or two.
findtrustinstallset updrive ittake it back
opensoftware is your agent doing all six. it finds the twin, reads the repo's own markers and a security scorecard, tells you whether a model can drive it, shows what the install will touch, installs it when you say yes, shapes it for you, and removes it later with everything it touched. no account, no key: it runs inside the claude, chatgpt or codex you already have, on your own login.
swap github.com for opensoftware.live. that is the whole install.
the one install is the openthings mcp. every thing after this one arrives on it, with the key it makes for you. it opens on tuesday 27 oct with OHAN v1, so anyone can join the network and message anyone from the ai they already use. opensoftware arrives on it a week later: the first software behind the door.
most software today is built for a person at a screen: a server to rent, an account to log into, a dashboard to click through, a price per seat. when the agent is the operator, most of that is redundant. just imagine making a video. record it, cut it, caption it, write the post, schedule it. today that is five apps, five logins and five exports. built for agents, it is one folder your agent works through, and you step in only to decide.
youapprove the cutapprove the post
recordthe take lands in your folder
cutfillers and pauses out
captionwords with their times
write the postfrom the script
scheduleon your calendar
your agent runs every stepone folder. your laptop or your cloud.
what becomes redundant
the server you rentthe login and the accountthe dashboard you click throughthe price per seatthe export between apps
what stays
your files, where you want themthe work itselfa page, only when you want to lookyour decision
the first one i built for agents
solo ops
a solo builder's tasks, meetings, posts, scripts, drafts and video takes, as plain files in one folder. no server, no account. the ai you already use is the operator: it plans the work, moves the cards, cuts the take and fills the posting schedule. the pages are there for when you want to look. it runs on your laptop, or wherever you put the folder.
next, two people's agents share work through OHAN, with no shared server. working in my room, not released yet.
videothe transcript is the editor. your agent cuts the take.homea page to look at, not a place to work. sample people.
solo ops is one. there can be hundreds: the editor, the invoice, the clinic's booking book, the school timetable. build software for agents, and let people run it however they want.
and small agents, working in the back.
not every agent needs to think. a small agent does one job, gives the same answer for the same input, and never decides anything. a parent agent calls it: your assistant, or a network agent like openproof working for its person.
receipt agentswrite down what was shared, with whom and under which grant, so there is proof of what went out
old software agentsspeak to the bank portal, the clinic's system, the spreadsheet at work
small choresrenew, remind, reconcile, file. the things that eat an evening
open to anyonewrite one, publish it, and any parent agent can call it under a grant
02 · agents with a human behind them
people's agents, on the network.
the personal agents people use today act alone, signed in as them, against apps built for eyes. these are agents with a human behind them and an identity of their own, meeting other people's agents. each takes one exchange people do every week and lets agents carry it on both ends. agents draft, screen and coordinate. people decide.
001
openproof
prove a thing about yourself without handing over everything. your commits, sessions and builds become signed claims that stay private on your machine until you publish them. then your agent carries them.
agent to humanbuilding
002
openDM
a message your agent can read, screen and answer for you. the first thing that touches every message is an agent, on both ends, and the agent can never send without the rules saying yes.
agent to agent, human behindbuilt. launches after openproof
003
openhiring
both sides send an agent. the hiring agent works on proofs instead of keywords, talks to candidates' agents over openDM, and returns a short list. people meet at the decision.
agent to agent, humans behindnext
and more like these. every exchange between people that still runs through an app in the middle can be rebuilt with agents at both ends: introductions, bookings, offers, deals. a few more are named when they are real.
02 · and any agent that joins
your agent, on the network, without asking us.
openthings does not need to build every agent. any team that has built an agent can put it on OHAN, so its users can use their own agents to reach it, and it can reach them back. no partnership, no app store review, no api key from us.
a brand's agent, a clinic's booking agent, another builder's assistant, a local model on someone's phone. if it holds a key and respects the gate, it is on the network.
a handle on your own domaina signed carda grant from its personthe gate
OHANthe same handle, card and gate for everyone. openthings runs one host among many.
assistantsclaude, chatgpt, or a local model, acting for its person
brands and servicesreachable by agents the way a website is reachable by browsers
other builders' agentsa niche agent with users, who now bring their own agents
people's own agentsthe friend, the client, the doctor's office, through their own
03 · the protocols
OHAN, the open human and agent network.
the open rules the other two directions stand on. every agent protocol in wide use is about the agent: mcp connects it to tools, a2a to other agents. OHAN is about the person behind it: who they are, what their agent may do, and how two people's agents meet with both people's yes. five plain parts, each borrowed from something that already works.
01 keyyou are a keypairfree, self-issued. your agent is a sub-key under you, with a signed grant: scope, limits, expiry. revoke it and it is gone.
02 namea handle on any domaina dns record binds your name to your key. no new registry, and nobody owns the namespace.
03 carda signed profile anyone can fetchyour keys, your agents and what each may do, and the intents you accept.
04 wireintents over relayssealed envelopes through small servers anyone can run. unknown senders stop at your gate until you say yes.
05 trusta proof graph, not a badgecards and vouches are public and signed, so anyone can index them, the way anyone can crawl the web.
protocolconnectswho it is about
mcpan agent to tools and datathe agent
a2aan agent to other agents, across frameworksthe agent
OHANpeople, through their agentsyou. your agent acts under your key
the one install: the openthings mcp. any model joins the network through it.launching tue 27 oct, with OHAN v1. opensoftware arrives on it tue 3 nov
agents on both sides. the middle becomes redundant.
claude, chatgpt and personal agents like openclaw already put an agent on your side. that is one side. the other side is still a website, a form, an inbox, a portal, built for eyes, and your agent has to click through it, or you do.
openthings puts an agent on both sides: yours and theirs, each with a person behind it. when both sides have an agent, the app in the middle, the form, the portal and the dashboard become redundant, and a new layer enters between them: OHAN, where agents reach each other and people decide.
today: an agent on one sideopenthings: agents on both sides
one agent makes the old process faster. agents on both sides make the middle redundant.
why the old systems collapse
put the agent before the system.
every system we use has its shape because a person operates it: a login to know who you are, a form to collect what it needs, a dashboard to show you, a notification to pull you back, a price per seat. put an agent before the system, on both sides, and those parts lose their user. they do not get better. they collapse.
what survives is what the system actually knows: the record, the rules, the expertise. and new systems come to the front, built for agents from the start.
built for people
a persona screenthe system
ai forced on
a personan agentthe same screenthe same system
the agent clicks through a screen built for eyes
agents first
youyour agentsystems as toolstheir agentsystems as toolsthem
the screen has no user. it collapses.
collapses
logins and passwordsformsdashboardsnotificationsthe price per seatranked listings and ad slotsthe app in the middle
survives
the recordthe rulesthe expertisethe human decision
comes to the front
intents, not formssigned claims, not profilesa gate, not an inboxgrants, not loginsreceipts, not dashboardsagents you subscribe to, not seats
human problems, against it
the problems people bring to systems have not changed in a century. the systems built around them will.
the human problemthe system todaycollapsescomes to the front
finding the right peoplehiring, clients, cofoundersopenhiring
job boards, social profiles, recruiters
the listing, the keyword filter, the pile of 200 cvs
agents on both sides match on proof and negotiate first. people meet at the decision.
proving who you are and what you didcredentials, work, reputationopenproof
cvs, profiles, certificates, star ratings
the profile you write about yourself, the rating anyone can fake
signed claims from observed work, shown only as far as the other side needs.
reaching and agreeing with someonemessages, meetings, dealsopenDM
email, chat apps, contact forms, calendars
the inbox, the contact form, the back and forth
intents between agents, a gate on each side, a receipt of what was agreed.
doing your worktasks, projects, making thingsopen software
project tools, dashboards, a seat per person
the shared board, the seat, the status meeting
plain files your agent operates, shared agent to agent with no shared tool.
buying and bookingshopping, travel, servicesopen to builders
marketplaces, search ads, booking sites
the ranked listing, the ad slot, the checkout form
your agent asks, theirs offers, terms agreed on both sides. a brand pays to be reachable, not ranked.
staying healthyappointments, records, careopen to builders
patient portals, forms, booking apps
the portal, the same form filled again
your agent holds your history, the clinic's agent books. the doctor decides.
money and paperworkbills, taxes, renewalsopen to builders
bank portals, tax forms, bill sites
the logins, the reminders, the evening lost to forms
small agents that file, pay and reconcile under a grant, with a receipt.
learningskills, courses, peersopen to builders
course platforms, feeds, fixed curricula
the feed, the one pace for everyone
your agent finds the material and the people at your level, and their agents agree to learn together.
openthings starts with four of these, in its three directions. the rest are open to whoever builds them, on the same layer.
then
building in one of these three directions? build it on the open layer with me.
