// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
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 });
}
// roll hours up into projects → real profit per project, in real time
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" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
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 });
}
// roll hours up into projects → real profit per project, in real time
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" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
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 });
}
// roll hours up into projects → real profit per project, in real time
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" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
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 });
}
// roll hours up into projects → real profit per project, in real time
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" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
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 });
}
// roll hours up into projects → real profit per project, in real time
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" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
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 });
}
// roll hours up into projects → real profit per project, in real time
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" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
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 });
}
// roll hours up into projects → real profit per project, in real time
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" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
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 });
}
// roll hours up into projects → real profit per project, in real time
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" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
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); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
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" }); } // 37.5h this week · +27%
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 — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
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); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
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" }); } // 37.5h this week · +27%
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 — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
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); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
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" }); } // 37.5h this week · +27%
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 — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
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); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
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" }); } // 37.5h this week · +27%
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 — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
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); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
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" }); } // 37.5h this week · +27%
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 — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
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); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
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" }); } // 37.5h this week · +27%
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 — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
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); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
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" }); } // 37.5h this week · +27%
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 — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
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); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
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" }); } // 37.5h this week · +27%
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 that designs, builds, and runs ambitious software — from custom platforms and AI agents to our own products, like TimerOS.
100%
of the studio runs on TimerOS
0
surveillance — classified on-device
Live.
profit per project, in real time
EU
privacy-first by default
The studio
We’re small on purpose. The people who design your software are the ones who build it and stand behind it — so the work stays sharp, honest, and genuinely yours.
BriefDesignBuildAI agentAPITestDeployAutomateReviewShipRunClient portalDataSync
Custom software & web platforms
Bespoke web applications, internal tools, and full SaaS platforms — engineered end to end, from data model to the last pixel.
Learn moreAI integration & agents
We weave AI into products where it earns its place — assistants, agents, classification and automation, on the cloud or on the device.
Learn moreDesktop & cross-platform apps
Fast, native-feeling desktop and cross-platform applications — like the always-on TimerOS client that lives quietly in your menu bar.
Learn more
// timeros/core/session.ts — every hour tracked honestly on the device, rolled up into projects, payroll and live profit per client
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 }); // 37.5h · +27% · 12 people
// shifts, goals, approvals, payroll and an org chart — the operational backbone of a company in one workspace, plus a branded client portal
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// classified on-device — no cloud model, no surveillance; every timeline timestamp 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 — every hour tracked honestly on the device, rolled up into projects, payroll and live profit per client
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 }); // 37.5h · +27% · 12 people
// shifts, goals, approvals, payroll and an org chart — the operational backbone of a company in one workspace, plus a branded client portal
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// classified on-device — no cloud model, no surveillance; every timeline timestamp 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 — every hour tracked honestly on the device, rolled up into projects, payroll and live profit per client
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 }); // 37.5h · +27% · 12 people
// shifts, goals, approvals, payroll and an org chart — the operational backbone of a company in one workspace, plus a branded client portal
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// classified on-device — no cloud model, no surveillance; every timeline timestamp 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 — every hour tracked honestly on the device, rolled up into projects, payroll and live profit per client
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 }); // 37.5h · +27% · 12 people
// shifts, goals, approvals, payroll and an org chart — the operational backbone of a company in one workspace, plus a branded client portal
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// classified on-device — no cloud model, no surveillance; every timeline timestamp 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 — every hour tracked honestly on the device, rolled up into projects, payroll and live profit per client
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 }); // 37.5h · +27% · 12 people
// shifts, goals, approvals, payroll and an org chart — the operational backbone of a company in one workspace, plus a branded client portal
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// classified on-device — no cloud model, no surveillance; every timeline timestamp 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 — every hour tracked honestly on the device, rolled up into projects, payroll and live profit per client
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 }); // 37.5h · +27% · 12 people
// shifts, goals, approvals, payroll and an org chart — the operational backbone of a company in one workspace, plus a branded client portal
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// classified on-device — no cloud model, no surveillance; every timeline timestamp 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 — every hour tracked honestly on the device, rolled up into projects, payroll and live profit per client
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 }); // 37.5h · +27% · 12 people
// shifts, goals, approvals, payroll and an org chart — the operational backbone of a company in one workspace, plus a branded client portal
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// classified on-device — no cloud model, no surveillance; every timeline timestamp 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 — every hour tracked honestly on the device, rolled up into projects, payroll and live profit per client
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 }); // 37.5h · +27% · 12 people
// shifts, goals, approvals, payroll and an org chart — the operational backbone of a company in one workspace, plus a branded client portal
const shifts = await Shift.week(team); const portal = Portal.for(client, { scope: "projects, invoices, changes" }); await sync.toPortal(portal);
// classified on-device — no cloud model, no surveillance; every timeline timestamp 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 our flagship — a multi-tenant platform for time, teams, projects, clients and payroll. Vezoft runs on it every day, so we feel every rough edge long before you would.
Time, honestly tracked
Productive, idle and break time across every department — measured fairly, on-device, with no surveillance.
Projects to profit
Tie hours to projects, clients, payroll and billing, so you can see real profit per project — not a guess.
The whole team
Shifts, goals, approvals, payroll and an org chart — the operational backbone of a company in one workspace.
A portal for clients
A branded client portal for projects, changes, incidents and invoices — your clients see exactly what they should.
How we work
From first idea to production.
A small team means less process and more progress. Four phases, wired together — working software at every step, no theatre.
01
Understand
We start with the problem, the people, and the constraints — not a feature list. A short, sharp discovery that gets us to the real shape of the work.
02
Design
Calm, considered interfaces and a sound architecture beneath them. You see and feel the product early, while it is still cheap to change.
03
Build
Tight iterations, working software every step, no theatre. We ship in slices you can actually use, react to, and steer.
04
Run
Launch is the start, not the finish. We stay on to measure, refine, and keep the thing healthy as it meets the real world.
Why Vezoft
A studio built to stay close to the work.
01
Small team, senior hands
No layers, no hand-offs. The people who design your product are the ones who ship it — so decisions stay fast and quality stays high.
02
AI where it earns its place
We build in the AI era without the hype. AI goes in when it makes the product genuinely better — not because it photographs well in a pitch deck.
03
We use what we build
Our own platform, TimerOS, runs the studio day to day. We feel every rough edge before a client ever does.
04
European by default
Privacy-first engineering and EU data practices are the starting point of every project, not a checkbox we add at the end.
Have something worth building?
Tell us what you have in mind. We reply to every serious enquiry — usually within a day.