// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
Software, engineered for the AI era
Vezoft is a small European software studio. For clients we build custom platforms, AI agents and desktop apps. We also have our own product, TimerOS.
Runs on TimerOS
The whole studio works in it every day.
AI in your product
The model can run on your own server.
Design and build
You do not need to bring your own designer.
Hosted in the EU
We write the code in Bulgaria; the servers sit in Germany.
The studio
We’re small on purpose. The person who designs your software also writes the code. When something needs changing, you talk to them.
BriefDesignBuildAI agentAPITestDeployAutomateReviewShipRunClient portalDataSync
Custom software & web platforms
Bespoke web applications, internal tools, and full SaaS platforms. We start at the data model, because everything above it inherits its mistakes.
Learn moreAI integration & agents
We add AI to existing products and build agents that run on their own. When data cannot leave your systems, the model runs on the device.
Learn moreDesktop & cross-platform apps
Applications that run on the computer itself, with access to files and hardware a browser cannot touch. They keep working when the connection drops.
Learn more
// timeros/core/session.ts — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client, Org } from "@vezoft/core"; import { classify } from "./on-device/model"; import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" }); session.on("idle", () => session.pause());
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); return session.commit({ at: trustedNow(), tz: user.timezone });
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost); return payroll.run(profit, { region: "EU", currency: "EUR" }); }
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return open.reduce((sum, i) => sum + i.total, 0); // billed from tracked hours
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true }); // one shared workspace
// shifts, goals, approvals, payroll and an org chart all read from the same hours, and the client portal reads from the same projects
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// the classifier ships inside the app, and every timeline timestamp is anchored to a trusted server clock
export const dashboard = render({ week, team, projects, profit: settle(projects), invoices: open }); // real-time, multi-tenant
// timeros/core/session.ts — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client, Org } from "@vezoft/core"; import { classify } from "./on-device/model"; import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" }); session.on("idle", () => session.pause());
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); return session.commit({ at: trustedNow(), tz: user.timezone });
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost); return payroll.run(profit, { region: "EU", currency: "EUR" }); }
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return open.reduce((sum, i) => sum + i.total, 0); // billed from tracked hours
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true }); // one shared workspace
// shifts, goals, approvals, payroll and an org chart all read from the same hours, and the client portal reads from the same projects
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// the classifier ships inside the app, and every timeline timestamp is anchored to a trusted server clock
export const dashboard = render({ week, team, projects, profit: settle(projects), invoices: open }); // real-time, multi-tenant
// timeros/core/session.ts — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client, Org } from "@vezoft/core"; import { classify } from "./on-device/model"; import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" }); session.on("idle", () => session.pause());
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); return session.commit({ at: trustedNow(), tz: user.timezone });
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost); return payroll.run(profit, { region: "EU", currency: "EUR" }); }
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return open.reduce((sum, i) => sum + i.total, 0); // billed from tracked hours
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true }); // one shared workspace
// shifts, goals, approvals, payroll and an org chart all read from the same hours, and the client portal reads from the same projects
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// the classifier ships inside the app, and every timeline timestamp is anchored to a trusted server clock
export const dashboard = render({ week, team, projects, profit: settle(projects), invoices: open }); // real-time, multi-tenant
// timeros/core/session.ts — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client, Org } from "@vezoft/core"; import { classify } from "./on-device/model"; import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" }); session.on("idle", () => session.pause());
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); return session.commit({ at: trustedNow(), tz: user.timezone });
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost); return payroll.run(profit, { region: "EU", currency: "EUR" }); }
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return open.reduce((sum, i) => sum + i.total, 0); // billed from tracked hours
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true }); // one shared workspace
// shifts, goals, approvals, payroll and an org chart all read from the same hours, and the client portal reads from the same projects
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// the classifier ships inside the app, and every timeline timestamp is anchored to a trusted server clock
export const dashboard = render({ week, team, projects, profit: settle(projects), invoices: open }); // real-time, multi-tenant
// timeros/core/session.ts — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client, Org } from "@vezoft/core"; import { classify } from "./on-device/model"; import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" }); session.on("idle", () => session.pause());
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); return session.commit({ at: trustedNow(), tz: user.timezone });
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost); return payroll.run(profit, { region: "EU", currency: "EUR" }); }
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return open.reduce((sum, i) => sum + i.total, 0); // billed from tracked hours
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true }); // one shared workspace
// shifts, goals, approvals, payroll and an org chart all read from the same hours, and the client portal reads from the same projects
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// the classifier ships inside the app, and every timeline timestamp is anchored to a trusted server clock
export const dashboard = render({ week, team, projects, profit: settle(projects), invoices: open }); // real-time, multi-tenant
// timeros/core/session.ts — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client, Org } from "@vezoft/core"; import { classify } from "./on-device/model"; import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" }); session.on("idle", () => session.pause());
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); return session.commit({ at: trustedNow(), tz: user.timezone });
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost); return payroll.run(profit, { region: "EU", currency: "EUR" }); }
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return open.reduce((sum, i) => sum + i.total, 0); // billed from tracked hours
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true }); // one shared workspace
// shifts, goals, approvals, payroll and an org chart all read from the same hours, and the client portal reads from the same projects
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// the classifier ships inside the app, and every timeline timestamp is anchored to a trusted server clock
export const dashboard = render({ week, team, projects, profit: settle(projects), invoices: open }); // real-time, multi-tenant
// timeros/core/session.ts — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client, Org } from "@vezoft/core"; import { classify } from "./on-device/model"; import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" }); session.on("idle", () => session.pause());
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); return session.commit({ at: trustedNow(), tz: user.timezone });
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost); return payroll.run(profit, { region: "EU", currency: "EUR" }); }
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return open.reduce((sum, i) => sum + i.total, 0); // billed from tracked hours
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true }); // one shared workspace
// shifts, goals, approvals, payroll and an org chart all read from the same hours, and the client portal reads from the same projects
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// the classifier ships inside the app, and every timeline timestamp is anchored to a trusted server clock
export const dashboard = render({ week, team, projects, profit: settle(projects), invoices: open }); // real-time, multi-tenant
// timeros/core/session.ts — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client, Org } from "@vezoft/core"; import { classify } from "./on-device/model"; import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" }); session.on("idle", () => session.pause());
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); return session.commit({ at: trustedNow(), tz: user.timezone });
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost); return payroll.run(profit, { region: "EU", currency: "EUR" }); }
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return open.reduce((sum, i) => sum + i.total, 0); // billed from tracked hours
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true }); // one shared workspace
// shifts, goals, approvals, payroll and an org chart all read from the same hours, and the client portal reads from the same projects
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// the classifier ships inside the app, and every timeline timestamp is anchored to a trusted server clock
export const dashboard = render({ week, team, projects, profit: settle(projects), invoices: open }); // real-time, multi-tenant
Our own product
We run the studio on the software we build
TimerOS is a multi-tenant platform for time, teams, projects, clients and payroll. Anyone can sign up for it at timeros.ai.
Where the day went
Productive, idle and break time, per department. You set how long a machine can sit idle before that time stops counting as work.
Projects to profit
Hours are logged against a project. The cost comes from payroll, the revenue from the client rate. Profit per project is on screen halfway through the month.
The whole team
Shifts, schedules, goals, approvals, payroll and an org chart. All of it starts from the same hours.
A portal for clients
A branded client portal for projects, changes, incidents and invoices. A login only reaches that client’s own records.
How we work
From first idea to production
A small team spends less of the week coordinating and more of it building. The process runs in four phases, and each one ends with something you can open.
01
Understand
We start with the problem and the constraints around it. Discovery is short, and it ends in a written scope you can hold us to.
02
Design
You get clickable screens before we write production code, and the data model underneath them. Changing a screen at this stage takes an afternoon.
03
Build
Iterations are short and each one ends with software that runs. Nothing sits half-finished for a month while we work on something else.
04
Run
After launch we watch how it behaves in real use and fix what shows up. Whether we stay on for that or hand it to your own team is your call.
Every phase is visible in our client portal — projects, changes, incidents and invoices in one place. See the portal
Why Vezoft
What we decided at the start
01
Small team, deep experience
Questions go straight to the developer writing your code. There is no second team to re-brief, and decisions do not wait for a meeting.
02
AI where it earns its place
Most briefs ask for more AI than the problem needs. We put it where it improves the product, and we say so when an ordinary feature would do the same job for less.
03
We use what we build
TimerOS is not a demo for us. The studio’s own hours and invoices run through it, and every bug in it reaches us before it reaches a client.
04
European by default
Every project starts with two decisions: what data we need to keep, and where in the EU it will live.
Tell us about your project
A few sentences are enough to start. We answer every request personally, usually within a day.
you approve the quote · you own everything we make
Projects start in our client portal. You register there, then send a project request. Or just email [email protected].