Mine Agent

Mine Agent lets a team go from "I need an agent" to a monitored, deployed, enterprise-grade agent in under 15 minutes, and lets them borrow a proven agent from a marketplace instead of starting cold.

Comment

Inspiration

Building a useful AI agent today means stitching together a model API, tool connectors, prompts, secrets, hosting, logging and evals. Teams that don't know agents in depth stall on that plumbing before they ever decide what the agent should do, and every team re-solves the same problems.

We wanted to make the plumbing reusable. Block-building games taught a whole generation to build complex things from simple pieces, so we asked: what if building an agent felt like that? Connections, models, guardrails and monitoring become blocks you snap together, and the metaphor actually teaches how agents work.

What it does

Mine Agent takes a non-expert team from "I need an agent" to a monitored, deployed, enterprise-grade agent in under 15 minutes. It has two modes:

  • Singleplayer is where you build your own agent. A four-step wizard (Brain, Job, Inventory, Rules) lets you pick a model (Claude, ChatGPT, GrokBot), write plain-language instructions with an "improve my prompt" assistant, click one-click connections (databases, Slack, docs), and set autonomy and guardrail levels. You test in a live chat with a step-by-step trace showing tool calls, tokens, cost and latency. Then you deploy to a shareable web chat link with monitoring on by default.
  • Multiplayer is a marketplace where every agent is a "server" you can inspect. You can Join (fork it into your workspace with a permissions diff), Chat with the author, or Learn to build this, which opens a tutorial that rebuilds the agent step by step in the real builder.

Every listing carries a Mine Score from 0 to 100, so you can trust an agent before you install it:

$$\text{MineScore} = 100 \times (0.30\,Q + 0.25\,R + 0.20\,S + 0.15\,U + 0.10\,M)$$

  • $Q$: build quality, reviewed by a Cursor cloud agent against a fixed rubric
  • $R$: reliability (eval pass rate and run success)
  • $S$: safety (prompt-injection tests, PII handling, permission footprint)
  • $U$: user satisfaction from verified installers
  • $M$: maintenance and author responsiveness

The game metaphor is functional, not decoration. Game mode is the autonomy level (Suggest, Approve, Autonomous). Difficulty is guardrail strictness. The Seed is a shareable, forkable config hash. The hotbar holds the nine tools the agent uses most, and the F3-style debug screen is the run trace. A Professional skin swaps the blocky look for a neutral one for companies with brand rules.

How we built it

  • Frontend: TypeScript, React, Next.js and Tailwind, with pixel-theme design tokens. The Professional skin swaps tokens, not components. The title screen is a lightweight three.js voxel panorama with a static fallback.
  • Backend: TypeScript services with Python workers for evals and retrieval. Postgres is the core store, with pgvector for retrieval. Run streams use server-sent events and author chat uses WebSockets.
  • Model gateway: one internal request format behind adapters, so switching an agent's brain is one click and triggers an automatic eval re-run. Agents are stored as declarative, model-agnostic specs that are versioned and diffable. The spec's hash is the Seed.
  • Grok, as more than a dropdown: xAI's API is compatible with OpenAI-style formats, so the adapter is thin. We expose Grok's server-side tools (web search, X search, code execution, Remote MCP) as one-click "GrokBot Powers" buttons next to the database and app connections.
  • Cursor, as the quality signal: on publish, we commit the agent's spec, prompts, permissions and eval cases to a managed repo, launch a Cursor cloud agent with a versioned rubric, poll for completion, and parse its structured verdict into the Mine Score's build-quality component.
  • Security from day one: credentials live only in a vault and are never sent to the model. Connectors are read-only by default, and writes are enabled per tool. Tool outputs are treated as untrusted data to defend against prompt injection. Installs show a permission diff.

Challenges we ran into

  • Making the theme teach. Fun on the surface can read as a toy to enterprise buyers. We held a rule that every themed element must explain a real concept, and we kept security, audit and permissions in plain language.
  • Using Cursor as a rating signal. Cursor's Cloud Agents API is a coding-agent API, not a ratings API, so we designed an asynchronous review job (launch, poll, fetch conversation, parse JSON) with a stored rubric version so scores stay reproducible and auditable.
  • Trusting third-party agents. A downloaded agent is someone else's instructions running on your data. That pushed us toward permission diffs, sandbox runs, secret and PII scans, and ratings only from verified installers.
  • Staying original. We built the look from scratch, with original pixel art and open-license fonts, and no official game assets, names or marks.

Accomplishments that we're proud of

  • A complete story in one demo: build, test, deploy and publish an agent, then borrow another from the marketplace.
  • A rating system that blends an automated Cursor code-and-config review with real usage, so a new agent can be trusted and a popular one can't coast.
  • Grok woven in as a real capability (live web and X search) rather than a logo on a page.
  • A guided "Learn to build this" path that turns every marketplace agent into a tutorial.
  • Enterprise features (SSO, RBAC, audit logs, a secrets vault, spend caps, tenant isolation) designed in from the start.

What we learned

  • Beginners don't need fewer features. They need defaults, such as read-only connections, three-step flows and monitoring on by default, with an Advanced drawer for experts.
  • Reusable connectors (via MCP) let one set of connections work across every model.
  • Trust in a marketplace is a design problem as much as a security one: the score, the permission card and the verified badges all do real work.
  • A good metaphor is a teaching tool. People already understand worlds, inventories and servers.

What's next for Mine Agent

  • Near term: versioning and one-click rollback, Dev/Staging/Prod environments, saved evals with pre-deploy gates, and the "Open in Cursor" code-level handoff.
  • Marketplace: natural-language search, private organization realms, author profiles with XP and levels, and update diffs for installed agents.
  • Later: multi-agent "parties," paid listings with author revenue share, paid consultations, and HIPAA-ready architecture for the healthcare sector.
  • Open items: confirm Cursor API access and terms, finalize the Muse model integration, and complete a legal review of the visual design.

Built With

Share this project:

Updates

Submission history