// 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
Софтуер, създаден за ерата на AI
Vezoft е малко европейско софтуерно студио. За клиенти правим платформи по поръчка, AI агенти и десктоп приложения. Имаме и собствен продукт, TimerOS.
Всичко в TimerOS
Студиото работи в него всеки ден.
AI в продукта ви
Моделът може да работи на вашия сървър.
Дизайн и разработка
Не ви трябва собствен дизайнер за проекта.
Хостинг в ЕС
Пишем кода в България, сървърите са в Германия.
Студиото
Малки сме нарочно. Човекът, който проектира софтуера ви, пише и кода. Когато нещо трябва да се промени, говорите пак с него.
ЗаданиеДизайнРазработкаAI агентAPIТестовеДеплойАвтоматизацияПрегледПусканеРаботаПорталДанниСинхронизация
Софтуер по поръчка и уеб платформи
Уеб приложения по поръчка, вътрешни инструменти и пълноценни SaaS платформи. Започваме от модела на данните, защото всичко над него наследява грешките му.
Вижте повечеAI интеграции и агенти
Добавяме AI към съществуващи продукти и създаваме самостоятелни агенти. Когато данните не могат да напускат системите ви, моделът работи на устройството.
Вижте повечеДесктоп и крос-платформени приложения
Приложения, които работят на самия компютър и имат достъп до файлове и хардуер, недостъпни за браузър. Продължават да работят и когато връзката прекъсне.
Вижте повече
// 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
Нашият продукт
Управляваме студиото със собствения си софтуер
TimerOS е multi-tenant платформа за време, екипи, проекти, клиенти и заплати. Всеки може да си направи акаунт на timeros.ai.
Къде отива денят
Продуктивно време, престой и почивки по отдели. Вие определяте след колко минути бездействие времето спира да се брои за работа.
От проекти към печалба
Часовете се отчитат по проект. Себестойността идва от заплатите, приходът — от ставката на клиента. Печалбата от всеки проект се вижда още в средата на месеца.
Целият екип
Смени, графици, цели, одобрения, заплати и органиграма. Всичко тръгва от едни и същи часове.
Портал за клиентите
Брандиран клиентски портал за проекти, промени, инциденти и фактури. Всеки клиент вижда само своето.
Как работим
От първата идея до пускането
Малък екип отделя по-малко време за съгласуване и повече за самата работа. Процесът минава през четири фази и всяка завършва с нещо, което можете да отворите.
01
Разбиране
Тръгваме от проблема и от ограниченията около него. Проучването е кратко и завършва с писмено описание на обхвата, което важи и за двете страни.
02
Дизайн
Още преди истинския код виждате работещи макети и модела на данните под тях. На този етап смяната на един екран отнема следобед.
03
Разработка
Итерациите са кратки и всяка завършва с работещ софтуер. Нищо не остава недовършено с месеци, докато ние правим друго.
04
Поддръжка
След пускането следим как се държи системата в реална работа и поправяме това, което изникне. Дали ще останем за това, или ще го поеме ваш екип, решавате вие.
Всяка фаза се вижда в клиентския ни портал — проекти, промени, инциденти и фактури на едно място. Вижте портала
Защо Vezoft
Какво решихме в началото
01
Малък екип, голям опит
Въпросите отиват директно при разработчика, който пише кода ви. Няма втори екип по средата и решенията не чакат среща.
02
AI там, където си заслужава
Повечето задания искат повече AI, отколкото задачата налага. Слагаме го там, където подобрява продукта, и го казваме, когато обикновена функция върши същата работа по-евтино.
03
Ползваме своя продукт
TimerOS не е демо за нас. През него минават собствените ни часове и фактури и всеки проблем в него стига до нас, преди да стигне до клиент.
04
Европейски по подразбиране
Всеки проект започва с две решения: какви данни ни трябват и къде в ЕС ще се съхраняват.
Разкажете ни за проекта си
Няколко изречения са достатъчни за начало. Отговаряме лично на всяка заявка, обикновено до един ден.
одобрявате офертата · всичко, което направим, е ваше
Проектите започват в клиентския ни портал. Регистрирате се и изпращате заявка за проект. Или просто пишете на hello@vezoft.com.