Something

Your own AI coworker. Runs 24/7, knows your business, works with your team.

_{Get started  ·  Demo  ·  Team  ·  Integrations  ·  Deploy  ·  Architecture}

A coworker that knows your context: your tools, your customers, your goals.
You reach it on Telegram or a private web workspace, and it acts on your behalf, not just answers.

What they do

Everything you'd reach for to automate your work (markdown for context, skills for playbooks, MCP for tools), but off the terminal: a calm UI, always on, shared with your team.

Your coworkers:

• Have a name and a personality. Set once in the first-login wizard.
• Live on Telegram and the web. Pick one or both; same memory either way.
• Remember between sessions. Markdown notes, a knowledge graph, recent threads.
• Act on your tools. Pull Shopify orders, draft Gmail replies, schedule Instagram posts, query GA4, and ask before anything goes out.
• Reach out first. Restock alerts, weekly reports, deadlines; they schedule their own follow-ups.
• Write their own playbooks. A skill is a markdown file describing how to handle a recurring task, editable right from the UI.
• Keep the task list moving. Your Tasks.md becomes a list or board view with owner, priority, and deadline, kept current as work progresses.
• Work with your whole team. Turn on collaborative mode: everyone signs in with their own account and a private space beside the shared one, and your coworker routes routines, tasks, and messages to the right person.

Why it's different

• Built for the whole team, not just engineers. The power of a terminal AI agent, in a calm UI that non-technical people actually live in.
• It reasons, it doesn't just route. Not if-this-then-that automation. It reads the situation, pulls from your tools, decides what to do, then asks before anything goes out.
• Your server, your data, full source. Self-hosted on a box you control, one per business. You hand it your inbox, store, and ads, so everything it does with that access is public and auditable.

Get started

You'll need: a Linux server (from ~€4.50/mo), a domain, a Google account, and a paid Claude plan (Pro or Max). Run the installer from macOS or Linux (on Windows, use WSL2).

Then, from your own computer, run:

curl -fsSL https://raw.githubusercontent.com/stanislawherjan1/Something/main/install.sh | bash

Prefer to read it before running? Download, skim, then execute for the same result:

curl -fsSL https://raw.githubusercontent.com/stanislawherjan1/Something/main/install.sh -o install.sh
less install.sh    # review exactly what it does
bash install.sh

The installer is interactive: it asks for your Google sign-in app, server address, domain, and admin email, then deploys. Plan for 45-60 minutes end to end, most of it waiting on the server, DNS, and the first build.

First time renting a server or pointing a domain? Full step-by-step guide →

Not comfortable in the terminal? Open this repo in an AI coding tool (Claude Code, Cursor, or Codex) and ask it to run the installer, read back errors, and customize the project for you. You create the accounts (Google, server, domain); the agent does the rest.

Demo

demo.mp4

Talk to them anywhere

Your coworker is one mind you reach from a few places: the web workspace chat, a Telegram DM, and the team Telegram groups it's part of. Same name, same memory, same context, whichever you reach for.

• Web chat: a full workspace alongside your files, skills, and dashboards. Each conversation is its own thread, so a dozen lines of work can run in parallel without blurring together.
• Telegram: message them like any contact. Best for on-the-go asks and getting pinged wherever you are.
• Telegram groups: add it to a team group and it follows the conversation, chiming in when it's genuinely useful and staying quiet otherwise. It only takes part in groups a teammate brings it into — never barging in on its own.

It's all connected. What you said on Telegram is there when you open the web chat, and the other way round. Each thread stays its own conversation, but your coworker keeps cross-surface awareness: it knows what recently happened on the other channel and draws on it when it helps.

Proactive messages travel the same paths. When a job finishes or a reminder comes due, your coworker pings you on Telegram, in the web app, or both; a web ping is a notification you click straight into its thread.

One coworker, your whole team

Flip on collaborative mode and your coworker stops being only yours; it becomes the team's, while still knowing each of you as an individual. Everyone signs in with their own Google account, and an admin keeps the roster: invite people, set roles (admin or member), link their Telegram.

Now there's a shared workspace and a private one for each person, side by side:

• Shared: the files, the task board, and the team-wide memory everyone works from.
• Yours: your own files and your own memory cards, scoped to you. A teammate can't read them, and your coworker won't go digging through them on someone else's behalf.

The default is collaboration, not secrecy: ask "did Mara finish the report?" and it answers from the shared work. Private cards are the exception, and they stay private.

Because it knows the whole team, it routes work to the right person, and carries messages between you:

You: Remind Mara to send the review tomorrow morning.
Coworker: Done. I'll ping Mara at 9:00 tomorrow, in her workspace, and on Telegram since that's how she likes to be reached.

Routines and tasks can target one teammate or everyone, and a task's owner is a real face on the board. You can also talk through your coworker: it delivers your message into a colleague's workspace or Telegram, in their language, phrased like a person, not a forwarded memo.

Solo setups are untouched: team mode off means no roles, no split, no routing, just the clean single-user workspace. Full design in docs/TEAM_MODE.md.

A real editor, your coworker writes to it too

Everything your coworker knows is plain markdown: notes, skills, memory, reports. The web app opens it in a clean, Notion-style editor (headings, checklists, tables, slash commands), but saves byte-for-byte markdown on disk, so git diffs and the bot's own edits stay clean.

It's a shared surface. You and your coworker edit the same files: write a launch checklist and the bot ticks items off as it does the work; ask it to draft a report, then polish it yourself. When it changes a file you have open, the edit flashes in live, and file paths (in chat or in a note) are clickable: mention Products/pricing.md and it opens.

Skills

A Skill is a markdown file that tells your coworker how to handle one recurring task, like a job description for a single responsibility.

---
name: weekly-ads-review
description: Every Monday, pull the last 7 days of Meta + Google Ads and post a one-pager.
---

Compare ROAS to the previous week. Flag any campaign that dropped >20%.
Surface 2-3 budget moves. Save to Reports/.

Create, edit, and delete skills from the dashboard. Integration-specific skills auto-install when the matching integration is activated. See docs/SKILLS.md.

Routines

Tell your coworker what to keep an eye on, and it takes it from there — the standing things it handles for you without being asked: scan the inbox each hour, chase threads that have gone quiet, watch approaching deadlines, prep meeting materials the day before. Every morning it plans the day from these routines, together with your calendar, tasks, and open threads.

You: From now on, each morning check Shopify for orders stuck unfulfilled over 48h and flag them.
Coworker: Added to my routines. I'll check every morning and flag anything stuck.

Under the hood, routines run on reminders — a background scheduler that survives container restarts and fires on time (once, daily, weekly, or continuous), reaching you on Telegram, in the web app, or both. You rarely touch it directly: the coworker sets and prunes its own reminders as the routines demand.

Memory

Your coworker doesn't start from zero each conversation. A small markdown wiki under project/memory/ holds the basics (who you are, your team, your hard rules, what each integration can do) plus rolling snapshots of recent web and Telegram exchanges. It loads into the system prompt every turn, so you never re-explain context. In a team workspace it splits like the files do: shared cards everyone works from, private cards that are only yours.

Open AI Settings → Memory to see it as a graph: cards (facts), topic pages (long-form), and the rolling snapshots, all linked. Click a node to open the file, or search to highlight. The bot maintains it itself: writing new facts after each session, promoting overgrown sections to their own pages, and reminding itself of past mistakes before it repeats them.

Inspired by Karpathy's LLM-wiki pattern, and built in collaboration with @jandziew. Full design + operational guide in docs/MEMORY.md.

Integrations

One-click — sign in, no keys to paste. Two dozen provider-hosted MCP servers connect with a single popup: sign in, approve, done. No API keys, and nothing for whoever deploys the product to register — the workspace-api OAuth broker registers itself on the fly (Dynamic Client Registration) and completes the flow on the client's own domain.

Notion · Stripe · Linear · Airtable · Miro · monday.com · Todoist · Cal.com · Calendly · PayPal · Klaviyo · Mailchimp · Cloudflare · Atlassian (Jira/Confluence) · Sentry · Netlify · Neon · Supabase · Webflow · Canva · Zapier · Amplitude · Wix · Firecrawl · Parallel Search · Crypto.com

Bring your own credentials. The rest paste a key, token, or file once — encrypted at rest:

Shopify · Meta Ads · Google Ads · Google Analytics 4 · Google Workspace · Email (IMAP) · Trello · GitHub · Substack · X · Grok (xAI) · OpenAI (GPT) · Gemini · Gemini Image · Seedream · SignWell · Docs Comments

You activate each one from the Integrations dashboard, no redeploy, no .env editing. Credentials are encrypted at rest; removing an integration wipes the secret. Setup details in docs/INTEGRATIONS.md.

Self-hosted, end-to-end

Each client gets their own server. One per business, isolated by design: your data, your coworker, your tools, nobody else's. They live there 24/7 listening for Telegram messages; the web workspace runs at your own subdomain, gated by Google login and a team whitelist.

Every line of code is public. You give your coworker access to your inbox, your store, your ads, so you should be able to see exactly what they do with that access. Architecture in docs/ARCHITECTURE.md, threat model in docs/SECURITY.md.

Deploy your own

Requires a Hetzner VPS (from ~€4.50/mo), a domain, and a paid Claude plan. Nothing runs locally; deploy.sh SSHs into the VPS and builds there.

The easy way: the interactive installer (see Get started):

curl -fsSL https://raw.githubusercontent.com/stanislawherjan1/Something/main/install.sh | bash

The manual way: once a client dir exists, deploy is a one-liner:

cd clients/my-client && ./deploy.sh

Beginner walkthrough in docs/QUICK_START.md. End-to-end manual onboarding in docs/NEW_CLIENT.md. Operations reference in docs/DEPLOY.md.

Docs

Start here

• QUICK_START.md, first deployment, beginner-friendly: buy a server, point a domain, one command. Start here if it's your first time.
• NEW_CLIENT.md, the manual, click-by-click version of the same flow; also how an operator onboards additional deployments with full control over each step.

Reference

• INTEGRATIONS.md, the integration catalog, self-service activation, encrypted credentials
• SKILLS.md, reusable Claude playbooks + dashboard editor
• MEMORY.md, Karpathy-style LLM-wiki: cards, topics, rolling snapshots, reflect-bots
• TEAM_MODE.md, collaborative workspaces: roster & roles, Shared vs Personal files/memory, per-recipient reminders, task assignment, cross-surface relay
• ARCHITECTURE.md, system design and data flows (with a glossary up top)
• SECURITY.md, threat model, auth layers, vulnerability reporting
• DEPLOY.md, production deployment & day-2 operations reference
• CONTRIBUTING.md, conventions, PR vs direct push