The interface is not the person
The Personal API
The next useful unit of work is not a résumé or a software seat. It is a clear boundary through which a person’s stack can contribute without absorbing the person.
People are not app profiles.
An App Person is made legible by fitting the fields a fixed application already has: title, location, availability, approval path, performance score. The application decides which parts of the person count, then asks the person to keep translating life into those boxes.
Stack People begin somewhere else. They assemble evolving capabilities around their own context, responsibilities, judgment, and relationships. That is the transition described in The First Stack Generation: software stops being only a place a person goes to conform, and becomes material a person can arrange.
A personal API is a human-owned boundary that states what a person’s stack may know, do, and return for a particular relationship without turning the whole person into an employee record.
The phrase borrows a technical shape, not a technical morality. An application programming interface lets one system ask another for a defined result. A personal API should do something the old app world rarely did: make the request narrow, visible, and revisable. It says, here is a capability I can offer; here is what it needs; here is what does not travel with it.
Three fields, not one profile.
A profile asks, “Who are you for our system?” A boundary asks, “What may this relationship ask for right now?” Open each field to see what changes.
Field 01
Request
Name the outcome, the recipient, and the period of use. A request for a project estimate is not permission to inspect every past negotiation.
The request carries purpose and expiry. It does not smuggle in a lifetime claim on the surrounding context.
Field 02
Permission
The person chooses which sources, rules, and delegation limits the stack may use. The boundary can be narrowed when stakes change.
Permission is specific enough to be refused, changed, and understood by the people affected by the result.
Field 03
Return
Specify the work product and its proof: a plan, a decision memo, a completed handoff, or a question that requires human judgment.
A useful return makes the work inspectable without exposing the private memory that helped produce it.
A small but consequential example
The vendor does not need your whole history.
Imagine a small manufacturer looking for a procurement recommendation. In the app era, the likely answer is another portal. The owner uploads files, recreates supplier records, accepts a broad data policy, and becomes a collection of fields inside a vendor’s product. The vendor gets a durable profile; the owner gets a temporary answer.
A personal API changes the exchange. The owner’s stack can be asked to compare three proposed contracts against a stated delivery target, existing inventory, and a maximum switching burden. It may use the invoices the owner permits. It may return a ranked recommendation with reasons, assumptions, and the points that need a human call. It does not send the owner’s entire commercial memory away as the entrance fee.
This is not a promise that every system will honor such a boundary. It is a design direction and a bargaining position. The more personal stacks become capable, the less sensible it becomes to treat total extraction as the normal price of participation.
Interoperability needs a human edge.
The practical challenge is not simply building better agents. It is establishing ways for agents, organizations, and people to make narrower requests and to honor narrower permissions. Organizations will still need reliability. People will still need ways to prove competence. Neither need requires a permanent copy of the person.
That changes the meaning of portability. App People carry a résumé from one closed system to the next and repeatedly refill the same profile. Stack People can carry a developing capability boundary: the kinds of work their stack can help perform, the evidence it can return, and the terms under which context is shared. The record belongs with the person because the capacity does.
The personal API is not a final standard. It is a useful question for every new AI service: does this ask for a whole person when it only needs a bounded capability? When the answer is yes, the interface is not merely inefficient. It is preserving the wrong social shape from the app era.