Put the agent at the
center of your organization.
Greenhouse is an open-source, AI-native agent workbench you self-host in one command. One shared tool layer powers your team's chat, your app's own agent, and any external agent over MCP — add a capability by writing one file.
Pulled from project_query. Here's the status across active projects:
| Project | Owner | Status |
|---|---|---|
| LetPot v2 launch | Maya | On track |
| Supply chain | Ken | At risk |
| Q3 hiring | Aria | On track |
Post this summary to #leadership?
The idea
The agent is the product — not a feature bolted on the side.
Most AI tooling stops at personal productivity: great for one developer locally, but the moment it enters an organization the whole layer that matters is missing — unified management, data permissions, audit, collaboration. Greenhouse fills exactly that gap. It's not another clever agent; it's the manageable foundation an agent platform stands on.
If the agent is the center of the organization, then the center of the product should be a tool layer. The tools your team uses in chat are the same tools you expose to Claude or Cursor. Adding a capability is writing one file.
The tool layer
One definition. Three entry points.
Declare a tool once with defineTool and add one line to the registry. It appears everywhere — automatically. No three separate lists drifting apart.
export const myTool = defineTool({ meta: { id: 'my_tool', brief: 'one-line summary', category: 'team', surface: { proxy: 'read', // read | write | none mcp: true, // expose over MCP }, }, kind: 'static', create: (ctx) => tool({ /* … */ }), });
one tool = one file
The shared tool layer
Team chat
members, in-app
Agent API
/api/agent
MCP server
Claude · Cursor
Permissions only narrow, never widen — every surface is a subset of the user's own access.
Generative UI
Messages aren't just text.
When an answer carries a table, a chart, or an action to confirm, the chat upgrades it into a real component — sortable tables, charts, file cards, confirm buttons. The agent only ever speaks text; the interface decides how it's rendered.
And those buttons aren't just for show: a click feeds straight back into the step where the agent paused — weaving human approval into the agent's loop.
- Sortable, searchable data tables
- Charts — bar, line, pie, radar
- Confirm buttons that resume the agent
- File & preview cards (html, pdf, image)
Revenue by quarter
Trust boundary
Safe to point at your whole org.
Permissions live in one place — the tool layer — and they only ever subtract. That's the boundary that makes it safe to open your organization's capabilities to an outside agent.
Only narrow, never widen
An agent gets a subset of its user's permissions — it can never gain a capability the user doesn't have.
Writes need a human
Mutating actions are deny-by-default. Every write is confirm-gated and logged to an audit trail.
Fail-closed by design
No access password set? The server refuses to start. No "forgot to configure it, now everything's open."
Roles & isolation
Super · team · external, with per-user flags. Public windows touch only public data; internal stays internal.
Research Analyst
deep · web search
Project Lead
tasks · gantt
Fork & share
make it yours
Agent profiles
Distill best practices into virtual coworkers.
A profile is a face, a name, a system prompt, a chosen subset of tools, and a few quick actions — one person's way of doing a job, compressed into a reusable unit. Share it org-wide with one flag; anyone can fork it and ship a better version.
Pair it with automations — a cron schedule that runs a profile's prompt on its own — and the daily standup report or morning data sweep runs itself. The longer a team uses it, the stronger its bench of virtual coworkers gets. It compounds.
One platform
Everything shares the same tool layer.
Chat
Streaming agent, selectable profiles, tool-call traces, memory, image analysis & generation, shareable sessions.
Knowledge base
Team, personal & shared docs. Rich-text editor, Markdown-first, full-text search, version history, group sharing.
Projects
Projects & tasks with board, gantt, and tree views, members, comments, and an activity log.
Automations
Cron-scheduled agent runs — execute a prompt against a profile on a recurring schedule.
Memory
Persistent per-user facts extracted from conversations and reused as context.
Email optional
IMAP/SMTP connector — search, read, draft, and send from the agent, with injection-safe handling.
LLM gateway + BYOK
Members reach admin-managed models through a server-side relay — no personal key needed — or bring their own.
MCP server + proxy
Expose the workbench's tools to any external agent over standard MCP or the structured /api/agent proxy.
Global agent
The agent can drive the web UI — navigate and prefill — through client-declared actions.
Meta
A product for agents — built by agents.
The implementation is almost entirely agent-written; the top-level design is human-held. Every layer ships an AGENTS.md spelling out its conventions, boundaries, and domain rules — the harness for the agent that builds it. There's even an anti-entropy section: delete-and-cascade discipline, no duplicate implementations, declared capabilities must be real.
A product agents use should be a product agents can keep building. Those turn out to be the same capability.
Self-host
One command. Your infrastructure.
A single container serves the API and the SPA. Postgres, a one-shot migration, done. Members log in with accounts — there's no app to install.
# 1. configure secrets + your LLM endpoint cp .env.example .env && ./scripts/gen-secrets.sh # 2. bring it up — Postgres, migrate, API + SPA docker compose up -d --build # 3. create the first super-admin docker compose exec api pnpm admin:create → app at http://localhost:3000
Teams going AI-native
Use it as the foundation for an internal platform — open your tools and data top-down, hand members a day-one agent that solves real work.
Developers & builders
Read it as a reference implementation of how an agent platform fits together — tool layer, permissions, generative UI, MCP — then extend it your way.
Clone it. Write your first tool.
Greenhouse is an answer to what "the agent at the center of an organization" actually looks like — and an invitation.