BuildInternal software, written by AI agents
Ask for the tool. Get a URL your team signs in to.
Not a demo and not a snippet for someone else to host. An Emra agent builds working internal software with its own data, the workspace sign-in your people already have, and an address you can send to the whole company.
From a sentence to something people use
The hard part was never the code. It was the hosting, the accounts, the who-is-allowed-in, and the fact that nobody had a free week. An agent does all of it, and you stay in the conversation the whole time.
The warranty claims spreadsheet has fourteen tabs and three people editing it at once. Can you make it a real tool? One row per claim, the supplier, days open, who owns it, and a filter for what is overdue.
- [01]
Say what you need
Write to an agent the way you would write to anyone else on the team. Rough is fine. It asks about what it cannot guess: which fields matter, who should see it, what happens to a row when the work is done.
- [02]
It builds the thing, not a sketch
The agent works on your workspace machine, in a folder of its own with its own dependencies and its own data. Real pages, real records, real saving. There is no repository to set up and nothing for you to host.
- [03]
It publishes, and asks who gets in
One command puts the app on an address. Before it publishes, the agent asks which of the three access modes you want, and afterwards it tells you which one it used.
- [04]
Your team opens the link
The workspace signs people in. Nobody makes another account, the app never handles a password, and the tool is in use the same day somebody asked for it.
What actually arrives
An app in the sense a person outside the team would use the word: it holds its own data, it knows who you are, and it has an address.
Its own data
The app keeps its records in its own folder on your workspace machine, with its own dependencies beside them. Nothing is shared with another app and nothing is handed to a database somewhere else.
Your sign-in, not a new one
No account to create and no password to reset. People arrive already signed in as themselves, and the app is told who turned up.
An address, not an attachment
A hostname on the internet, like team-claims.emra.ai, or a shorter name of your choosing under the same domain. Put it in a doc, a bookmark, a message to the team.
It stays up on its own
The app runs under its own process manager and comes back after the machine restarts. Nothing for you to keep alive, and nothing that disappears when the chat scrolls away.
The kind of thing a team actually asks for
Not products. The small internal software a company runs on, that everybody needs and nobody has ever had the week to build.
A warranty claims tracker
One row per claim with the supplier, the days open and the owner, instead of a spreadsheet with fourteen tabs.
A supplier lead-time board
What every open order promised, what it has slipped to, and who has not answered the last email yet.
An onboarding checklist
One per new hire: the laptop, the accounts, the training, each signed off by the person who actually did it.
A defect log with photos
The floor files it from a phone, and quality reads the pattern by line and shift instead of a pile of messages.
An approval queue
Price changes and one-off discounts, asked for in a form and approved by whoever owns the policy.
A customer visit log
What was promised on site, written down somewhere the next person to visit will read it.
Then you change it, and change it again
The first version is a draft that happens to work. What matters is how cheap the second one is.
Change it
Go back to the same agent and say what is wrong. It still has the folder, the process and the whole history of the thing, so version two is another message rather than a handover to somebody else.
Widen it, or narrow it
Publish it again with a different access mode when the audience changes. A tool three people tried on Monday can be open to the whole company by Friday.
Keep it
It is yours for as long as you want it. Unpublish it and the public address goes away, while the folder and everything in it stay exactly where they are.
Access
The app never decides who you are
An app an agent built has no user table, no passwords and no secret of its own. Every request to it is checked against your workspace first and only then forwarded. The app is simply told who turned up.
Somebody opens the app, from a link, a bookmark or the console.
Is this person signed in, and does this app take them?
Gets the request with the person attached, or never sees it at all.
What a gated app is handed about its visitor. Code in the browser can ask for the same thing instead.
- The access mode is read from the app's own entry on your machine, never from the request
- Every check re-reads the workspace's user list, so a removed account or a revoked grant is out on the next request
- The code that turns a workspace sign-in into an app session is good once, for one minute
- The app session is bound to that one hostname, and signing out of it leaves the workspace alone
Three answers to "who gets in"
Chosen per app, in its own entry on the machine, and changed by publishing it again.
Open
openEveryone gets through. Anyone signed in to the workspace is still recognized, so the app decides for itself what a guest may see.
Workspace
workspaceAnyone signed in to your workspace gets in, and there is no list to keep. A guest is sent to sign in first.
Members
membersOnly the people an admin picked for this app, plus the admins. Everyone else gets a page telling them who to ask.
Opening it is not changing it
Every app has an owner, the person who asked for it. Only the owner, the editors they add and the admins may change an app, its files, its address or its process, or read its source.
One sign-in, and it is yours
A workspace password, or single sign-on where the workspace is set up for it. Who is a member and who is an admin is read from your own user list, not from the identity provider.
An agent reaches only what it was given
Connections are added one agent at a time, and an agent with none added reaches nothing. A connection that signs people in acts only as the person the agent is working for. The keys stay on the machine, never in the agent configuration.
Every line of it is written down
Sign-ins, invitations, role changes, app grants and revocations, owner and editor changes, and every turn and tool call an agent ran, appended one line at a time to a log nothing rewrites. Admins read it in the console and download it as JSONL or CSV.
- app_grantdana@yourteam.com to claims
- app_editor_grantsam@yourteam.com on claims
- tool_callgithub: get_pull_request
- app_revokealex@yourteam.com from claims
What a security review asks
The three we answer most often on this page. The rest of the review is on the enterprise page.
Where does the app actually run?
On the machine that belongs to your workspace, in a folder of its own, under the agent's own process manager, and it survives a restart. Every agent on that machine is its own operating system user, so what one can read, change or run ends at its own directories.
Can an app be reached from outside the company?
Its address is on the public internet, and the access mode decides what happens there. An open app takes everyone. A workspace or members app sends anyone who is not signed in to sign in first. An app can also stay unpublished, with no public address at all.
What happens when somebody leaves?
Remove the account and the next request to every app is refused. Nothing waits for a session to run out, because the check reads the workspace's user list on every request.
The tool nobody has had time to build
Start with the spreadsheet your team keeps apologizing for. Ask an agent for it tonight, open the link in the morning.
- SOC 2 Type II underway
- Sandboxed workspace
- Append-only audit log