One workspace for your team and your agents.
TeamShare brings projects, tasks, documents, and environment secrets under one roof — where people and AI agents plan, build, and ship side by side, bound by the same roles and permissions.
- Built-in RBAC
- AI build mode
- Orchestrator
- Encrypted secrets
The problem
Five tools, one project, zero visibility.
Small teams and individual builders juggle a task tracker, a document store, a chat app, and a secrets manager — and when an AI agent joins, there's nowhere safe for it to work. Context scatters; access control is inconsistent.
Your tools are scattered
Tasks live in one app, documents in another, and secrets in a chat thread nobody can find again.
Secrets get pasted into chat
API keys and credentials end up in messages and docs, where access control simply doesn't exist.
Agents have nowhere to plug in
You hire an AI teammate, but the work lives in five apps — so it can't read the context, act safely, or stay within your permissions.
Nobody owns permissions
Everyone can see everything, or no one can see anything. There's no in-between — and no safe way to let an agent act.
TeamShare removes the fragmentation — one place for the work, one place for the conversation, one place for the secrets, and one place where your agents can help.
What you get
Everything your project needs, built in.
No integrations to stitch together. Every capability ships inside one workspace, with one permission model.
Projects & tasks
Create projects for any work, track issues through their full lifecycle, and keep every deliverable attached to the work it belongs to.
Kanban boards
See work in motion — Open, In Progress, In Review, Resolved, Closed. Set priorities, due dates, assignees, and watchers.
Documents
Share links and uploads in a project library, with inline previews and comments next to the work they describe.
Secret vault
Environment variables per project and tier — dev, staging, prod — masked, encrypted at rest, and audited on every reveal.
Chat & mentions
One channel per project, threaded comments on every task, and @mentions that land as in-app and email notifications.
Roles & permissions
Company and project roles with clear boundaries — viewers read, secret managers guard, owners govern personal projects.
AI agents
Register agents that work from your own machine — assign, @mention, or run them with one click, and watch every action in the run history.
Search & analytics
Global search across every workspace, plus activity and workload analytics that respect your permissions.
Build mode
Mark tasks readyForDev — a project build agent works them in strict order, one at a time, fully completing each before moving on.
Orchestrator
AI-planned execution: a planner decomposes tasks into subtasks, lays out the order, and ships — human review at every gate.
Agent Hub tools
Live console, ask-human, agent chat, model controls, session continuation — everything an AI teammate needs to do real work.
Document assistant
Upload project docs and ask questions over them — the agent extracts, searches, and cites from your actual files.
AI agents
From assignment to done.
TeamShare is the coordination hub — your agents run on your own machine, with the same permissions as your members.
- 1
Assign or mention
Assign a task to your agent, or @mention it in a comment or chat. A wake event reaches it instantly.
- 2
Wakes on your machine
The bridge opens a session on your computer — your hardware, your keys, no cloud.
- 3
Works with real tools
The agent reads the task, project files, and thread — then works through MCP tools: create, update, comment, search.
- 4
Reports back
It posts a summary comment, moves the task forward, and every action lands in the run history.
- 5
You stay in control
Review the timeline, resume a session, or re-run — the same permissions that guard your members guard your agents.
- Secrets never reach an agent — env-var values are viewer-denied by default.
- Runs on your machine — TeamShare coordinates.
Build mode
Ship features with an AI build engineer.
Mark tasks ready for dev — your project's build agent picks them up, works through them in strict order, and ships. When it hits a wall, it asks a human and resumes on answer.
Build mode — ordered, one at a time
The build agent works the readyForDev queue in strict order — one task, fully completed, before it picks up the next. Start or stop it from the Build tab; every transition is audited.
- Tasks marked readyForDev enter a first-in-first-out queue
- One task at a time — no parallelism, no context bleed
- Failure skips the task with a comment + [question] ask-human
- Resume on answer — the agent picks up exactly where it left off
- Live queue with busy/queued/completed status pills
- Start and stop from the Build tab — human always in control
Orchestrator — AI-planned execution
The Orchestrator tab plans before it acts — an AI decomposes a task into subtasks, lays out the execution order, and works through them. Resolving the linked task completes the run.
- Per-task 'Run via orchestrator' button on every readyForDev row
- AI planner decomposes work into subtasks with dependencies
- Executes in dependency order — never re-decomposes existing plans
- Progress surfaces in the Orchestrator tab with live status
- Resolving the parent task completes the orchestrator run
The build agent runs on your machine through the bridge — your hardware, your keys, your repo. TeamShare orchestrates; the agent executes.
Read the build mode guideAgent Hub
Everything your agents need to ship.
The Agent Hub turns your machine into a development workstation your agents control — with tools built for real work, not just chat.
Live console
Watch every agent run live — token streaming, tool calls, and status changes in real time.
Ask-human
When an agent hits a blocker, it pauses and asks you a question. Answer from the dashboard and it resumes exactly where it left off.
Agent chat
Talk to your agents directly — ask questions, review their plan, or steer them mid-run. Streaming responses, full context.
Document assistant
Upload project docs and ask questions over them. The agent extracts, searches, and cites from your actual files.
Model controls
Curated provider/model catalog — pick the right model per agent. Temperature, max tokens, and cost tracking built in.
Session continuation
Resume a session exactly where it left off — same context, same tools, no lost state between runs.
Per-agent locks + subtasks
One agent at a time on a task — enforced by locks. Work is broken into subtasks, tracked individually, with full history.
Runs on your machine
The bridge runs a local CLI — your hardware, your keys, your repo. TeamShare coordinates; the agent executes on your terms.
The context engine
Stop paying your agent to forget.
Every run, a context-starved agent re-reads your repo, your docs, and your task history — and you pay for every token of it. TeamShare keeps your project's brain in one place: tasks carry decisions forward, documents live in one place, and briefs arrive scoped. Your agent starts warm, not cold.
Input tokens per agent task
Illustrative bottom-up estimate — thousands of input tokens per task, assuming no provider prompt caching. Briefs (~500–800 tokens) plus the project-context digest replace re-reading documents and task history; agents still read source code either way.
| Task | Context from scratch | With TeamShare |
|---|---|---|
| New feature | 84k tokens | 35k tokens |
| Bug-fix round | 57k tokens | 24k tokens |
| Docs sweep | 96k tokens | 27k tokens |
| Follow-up tweak | 64k tokens | 21k tokens |
60–75%
fewer input tokens per task
≈3×
fewer input tokens on repeat work
Indexed once, read forever
Plans, decisions, and specs live as documents your agents query on demand — not tokens you re-send.
History carries forward
Task threads keep every decision attached to the work, so follow-ups skip the recap tax.
Scoped briefs, smaller prompts
Agents receive a compact brief with exactly the context they need — nothing more to bill for.
Same model. Same tasks. A fraction of the bill.
Under the hood
Built for the way real teams work.
Four details we obsessed over — because they are where projects live or die.
Work flows from idea to done
A status state machine that matches how teams actually work: Open, In Progress, In Review, Resolved, Closed — with reopening when review finds a problem.
- Priorities, tags, assignees, watchers, and due dates
- List view for triage, Kanban board for flow
- Image attachments inline with the task
- Status changes tracked, never silent
Secrets stay secrets
Environment variables are encrypted with AES-256-GCM using a key per workspace. Values stay masked until you reveal them — and every reveal is audited.
- Tiered per project: dev, staging, prod
- Reveal-on-click with confirmation
- One-click .env export for local work
- Viewers never see the vault at all
Talk where the work is
A project chat channel for the team, threaded comments on every task, and @mentions that notify the right person — in-app and by email.
- Realtime delivery across the channel
- Threads keep detail work from flooding the room
- Attachments render inline, click to zoom
- Mention chips link straight to the member
Agents work beside you
Registered agents run on your own machine — woken by assignments and mentions, working through the same tools your team uses, with every action audited in the run history.
- Run from a terminal, auto-wake, or one click
- MCP tools — tasks, comments, documents, search
- Heartbeat status you can see at a glance
- Run history for every action — nothing silent
Who it's for
One product, many ways to work.
From a solo side-project to a company of hundreds — the same permission model scales with you.
Solo creators
A personal workspace for your own projects, API keys for side-projects, and a clean way to share one project with a client.
Startup founders
Create a company, invite co-founders with roles, organize teams, and see company-wide activity at a glance.
Engineering teams
Assign issues, enforce the status flow, and keep specs next to the tasks they relate to — no more digging through chat.
Ops & DevOps
Rotate variables across dev, staging, and prod — and audit every reveal, export, and change.
AI-forward teams
Wire agents into your workflow — assign, @mention, or run them with one click, and review their work from the same dashboard your team uses.
Platform builders
Build on the public API, MCP tools, and webhooks — automations and agents your way, on top of one permission model.
Security
Built so secrets stay secrets.
Encryption at rest, role-based access, and a complete audit trail — applied to every workspace, from day one.
Encrypted at rest
AES-256-GCM with a key per workspace, held in cloud KMS. The database stores ciphertext only.
Role-based access
Five company roles and four project roles — for people and agents alike — chosen at invite time and enforced on every request.
Audited every step
Reveals and exports of secrets are recorded — who, when, and where.
Never in plaintext
No secret value appears in logs, errors, or API responses — by design.
Pricing
Start free. Scale when you're ready.
Plans are monthly subscriptions charged via Paystack — individuals subscribe from Settings → Billing (no company needed), companies subscribe from Company Settings → Billing. Enterprise is company-only. Upgrade, cancel, or manage your plan anytime.
FAQ
Questions, answered.
Ready when you are
Start sharing in minutes.
Create an account, set up a workspace, and add your first project — all before your next coffee.