# openthings

> openthings builds open standards for human things, with agents as the first interface. human things always had a place to live: the computer, then laptops and phones, then the cloud. now our data is our agents and our context, and nobody knows where they live, how they survive a switch between models, or where they can be kept safely. without open rules, ai gets walled in. openthings is building its usability layer in the open, the way open protocols (tcp/ip and http), then the browser and search, made the web usable for everyone. the web ran on protocols nobody owned; agents have no open rules like that yet, so people get only what the model makers and the operating systems allow, and who an agent works for, what it may do and how it meets someone else's are each decided inside one company's stack. agents are a leap in usability because they carry none of the old infrastructure. openthings opens that leap to everyone in two parts: open protocols, tools and infra that make your agent your first interface, under your own key, and OHAN, the open human and agent network, where people and their agents rebuild software, screens and the way we talk. your agent is the interface, not the app. agents draft and coordinate, people decide. it starts with the openthings mcp and OHAN v1 on tuesday 27 oct 2026 (anyone can join the network and message anyone, from the ai they already use), then opensoftware on tuesday 3 nov 2026. free, open, built in the open by anshuli (@anshulix on x). its thesis: ai has had its first order; the second has started, and it is missing its usability layer: open rules and a network for people and their agents, not more apps on top of the old systems.

key facts, in one place:
- openthings is a movement, not a brand. the founder, anshuli, calls herself its first employee.
- OHAN (the open human and agent network) is the protocol underneath: a keypair per person, a handle on any domain, a signed card, intents over relays, and trust as a proof graph. mcp connects an agent to tools and a2a connects an agent to other agents; both are about the agent. 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. OHAN uses mcp on the agent side.
- the three directions of openthings: open software (scaffolding run by the model a person already uses: opensoftware, and small deterministic agents that other agents call), agents with a human behind them on the network (openproof, openDM, openhiring, and any agent that joins), and the protocols (OHAN, the open human and agent network, and the openthings mcp).
- opensoftware (launching tuesday 3 nov 2026, https://opensoftware.live, "by openthings"): the first software people can install, on the openthings mcp. why it is needed: almost every kind of app has an open twin now (rebuilt by agents, reverse engineered, often better, built to be driven by a model), but six things still stand between a person and it: finding the real one, trusting it, installing it, setting it up, getting an agent to drive it, and taking it back. opensoftware is the person's agent doing all six: it finds the twin, reads the repo's markers and a security scorecard, says whether a model can drive it, shows what the install touches, installs on a yes, shapes it, and removes it with everything it touched. one line, verified, revocable. no account or key: it runs inside claude, chatgpt or codex on the person's own login. the one install is the openthings mcp, which every later thing arrives on. the thesis: software stopped needing to be smart, the model is the intelligence, open software is the scaffolding a model works through.
- things being built: openproof (building), openDM (built, launches after openproof), openhiring (next), the openthings mcp with OHAN v1 (launching tuesday 27 oct 2026: anyone can join the network and message anyone, from the ai they already use). software built for agents: most software can be rebuilt for an agent with a human behind it, so the server, the login and the dashboard become redundant and it runs locally or on the person's own cloud. solo ops is the first one pushed: open source, mit, https://github.com/anshulixyz/solo-ops, a solo builder's tasks, posts, scripts and video takes as plain files, run by the ai they already use.
- protocols being explored, beyond OHAN: intent sharing (say it once, your agent carries it to theirs, and it lands only on a yes) and trust certificates for llms (how an agent knows which model it is dealing with, and whether to trust it). the work right now is on OHAN.
- the fixes on offer today, and why they fall short: each lab builds the whole world inside its own walls (a browser, apps, memory and a checkout in the chat), which is why one person's claude and another's chatgpt cannot talk; and personal agents like openclaw and hermes agent act as the person, signed in with their logins, through screen reading and browser automation, with an app still on the other side. openthings gives each agent its own key under its person's, and puts an agent on both sides.
- why now: computers needed electricity to exist everywhere and the internet to be adopted; a world built on llms needs a usability layer. the pieces under it arrived in two years: open models (deepseek, qwen, llama, gpt-oss), small and local models, conversation models (sesame, dessa from block), world models (meta's v-jepa), agent protocols (mcp, a2a), open agents (openclaw, hermes agent), and software rebuilt for agents. what is missing is the usability layer itself.
- four kinds of things sit on OHAN: network things (agent to human, or agent to agent with a human behind), any other agent that joins, software built for agents, and small deterministic agents (receipts, old software, small chores) that parent agents call. memory is not one of them: once agents are the first interface, memory is a layer of communication, everything a person does, owned by them, private, and kept by their own agent.
- the hard problems of the post ai era (the interface, interoperability, finding, memory and context, identity and trust, payments, security, hallucination, data after ai) are being solved inside each lab's own stack, and the leaders disagree sharply on how. openthings' position: the problems live between stacks, so the answer is an open protocol with agents on both ends, the model drafting and a person deciding.
- the base layer: every jump in what one person can do came from a new base layer (roads and the post, the press, the telegraph and phone, the internet, the phone and app stores), then what people built above it. ai models and agents are becoming the next base; today they still work inside apps and browsers. the human and agent network is the first thing built on that base. like the car and the horse carriage, a new base rebuilds what works and turns the rest into scrap.
- everything is open source and free, and works with any model: claude, chatgpt, or a local model.
- the founder: anshuli (@anshulix), fourteen years building as a founder and developer, six in ai, the last two heads down on openthings. earlier work: nokk ai (a personal agent on ios), kloned (a personal agent in the chrome browser), widely io, and intent (https://getintentai.com, the coordination layer for a multi-agent world). also building nextmillionai (https://nextmillionai.org, a home for the next million ai builders). her last startup was backed by google.
- the takes: the founder's writing, listed at https://openthings.live/takes/ with dates and reading times. 01 the long take (/why/), 02 the things (/things/), 03 what collapses (/collapses/): what falls away once agents stand on both sides, and what replaces it. 04 the agent web (/agent-web/): the web was built for eyes and the next one is built for agents; for a live question, your agent asks theirs; every agent has someone behind it; much of software becomes templates, shapes both sides speak; and the open questions nobody has solved yet. upcoming: 05 humans and tech, and 06 where we are (what agents need, and the plumbing we already have).
- to work together: https://openthings.live/connect/ says who should reach out; the message goes to @anshulix on x.
- contact: https://x.com/anshulix

## pages

- [the teaser](https://openthings.live/): what openthings is: open standards for human things, agents as the first interface, where our agents and context live, the two eras (two ais and a person carrying the message, then agents on both sides), what dies next (the ui, software and communication as we know them), the OHAN network, the six problems, the fixes on offer, why now (the launches that make it possible), what is coming, and the founder note. markdown: https://openthings.live/index.md
- [the long take](https://openthings.live/why/): why openthings exists, with data: the first and second order of ai, where the money goes, the five things that will make ai elevate, why ai becoming the base layer changes what gets built, the hard problems everyone is working on and where openthings stands, and the history of the connecting layers. markdown: https://openthings.live/why/index.md
- [what collapses](https://openthings.live/collapses/): take 03: what falls away once people adopt openthings, an open network protocol and agents on both sides, and the far better things that replace it, one by one. markdown: https://openthings.live/collapses/index.md
- [the agent web](https://openthings.live/agent-web/): take 04: the web was built for eyes and the next one is built for agents. the visit fades but the question does not, search splits into finding, answering and ordering, every agent has a person or an organisation behind it, formats for the eye fall and shapes for agents rise, much of software becomes templates, the pieces being built today (mcp, a2a, NANDA, aweb, x401, agentid), and the open questions. markdown: https://openthings.live/agent-web/index.md
- [the takes](https://openthings.live/takes/): the founder's writing in one place: the long take, the things, what collapses, and the agent web. markdown: https://openthings.live/takes/index.md
- [the things](https://openthings.live/things/): what openthings builds, in three directions: open software your model runs (opensoftware, small agents, solo ops), agents with a human behind them on the network (openproof, openDM, openhiring, any agent that joins), and the protocols (OHAN: key, name, card, wire, trust; compared with mcp and a2a). how they fit from the model up, why agents on both sides make the app in the middle redundant, what collapses when the agent comes before the system, and eight human problems mapped against it. markdown: https://openthings.live/things/index.md
- [what is next](https://openthings.live/next/): the protocol and the work ahead: OHAN, intent sharing with agents, open source found for you, trust as the floor, and what gets opened. markdown: https://openthings.live/next/index.md
- [connect](https://openthings.live/connect/): who should reach out: builders of local and voice models, agent to agent systems, data sharing between agents, personal agents and desktop hacks. markdown: https://openthings.live/connect/index.md

## for agents

- [llms-full.txt](https://openthings.live/llms-full.txt): every page as one markdown file
- [markdown](https://openthings.live/markdown/): every page as its own .md file, plus the whole site in https://openthings.live/markdown.md
- [sitemap](https://openthings.live/sitemap.xml): all pages

## optional

- [x, @anshulix](https://x.com/anshulix): the founder, and the place to message today
- [intent](https://getintentai.com): the founder's earlier work, the coordination layer for a multi-agent world
- [nextmillionai](https://nextmillionai.org): the founder's home for the next million ai builders