arxi is a personal ai agent that lives inside your messenger. one agent, one user, one isolated micro-vm that reads, decides and acts on your behalf. we're a tiny team that ships to production multiple times a day. our product holds people's real data, calendars, credentials and browsers, so security is not a feature, it's the substrate.

we mean full-stack literally: schema, backend logic, the api, the ui, the deploy, and the sharp edges with real users, all yours. you'll move across the typescript bot, the python services, the next.js admin console and the telegram mini-apps, and you'll ship to production the same day you start a thing. this is a founding-level, end-to-end role on a small team. there's no one to hand the boring half to, and that's the point: you own the whole vertical and you see it live.

how we work

• accuracy, then speed, then cost, in that order. accuracy never trades down. if the agent is wrong about the real world, it breaks trust, and trust is the whole product.
• ship very fast. no staging theater, no quarterly roadmaps. hear it in the morning, ship it in the afternoon, roll back in one command if it's wrong.
• automate everything that runs twice. builds, deploys, tests and reviews run as scripts, not as rituals.
• no mvps, no half-measures. if a problem can be solved properly in code, even if it's hard, we do it properly. cheap code means correct and thorough, not quick and trimmed.
• tiny team, enormous leverage. you own surfaces end-to-end and your decisions hit real users the same day.

our stack

typescript (grammy, fastify), python (fastapi), next.js with trpc and prisma, gemini via vertex ai behind our own llm proxy, firecracker micro-vms (one per user), self-hosted linux (hetzner, nginx, systemd), sqlite, prometheus and grafana, polar for payments. heavily automated tooling and a fast deploy pipeline, so engineers spend their time on the hard problems rather than the plumbing.

in this role you will

• build features end-to-end at startup velocity, in days not weeks: design the schema, write the backend (fastapi and python, or grammy and fastify in typescript), build the ui (next.js and trpc, or telegram mini-apps), deploy it, and watch it in prod.
• work across the whole product surface: the telegram bridge, the vm lifecycle manager, the file vault, billing and payments, the scheduler, the usage and telemetry pipeline, and the admin console.
• ship the llm-facing plumbing: the agent's tools, the key and usage proxy, prompt-cache and cost controls, provider adapters, and make them fast, because per-turn latency is a metric we watch live.
• treat performance as a feature: trace real turns, kill latency tails, cut redundant work, and keep the agent fast without ever trading away accuracy.
• build with security defaults baked in: per-user isolation, least privilege, no leaking one user's data into another's session, because every feature touches real personal data.
• automate your own toil: if you do it twice, script it. tests, deploy steps, smoke checks, data migrations. green is your responsibility (there's no ci babysitter doing it for you).
• own quality end-to-end: write the tests, open the pr, get it reviewed, merge it, deploy it, and own what happens after.

you might be a great fit if you have

• real full-stack range: you've shipped production web apps end-to-end and you're equally comfortable in a backend service, a database schema, and a frontend component.