Most "book a demo" buttons are a dead end — the prospect never sees the product. So MATE has an embeddable Agent Builder Wizard: a step-by-step widget you drop on your marketing site where a visitor builds, actually chats with, and then requests an AI agent. It provisions a real, live trial agent on the spot, then captures the visitor's details as a lead. No billing anywhere — it ends with a price estimate and a "we'll contact you," and you follow up to activate.

How it works

1. The visitor picks a tier and fills in a bit of config (e.g. their website URL).
2. MATE provisions an isolated trial project, builds the agent(s) from that tier's template, and issues a widget key.
3. The wizard embeds the standard chat widget right there, so the visitor tests their own agent immediately.
4. It captures name / email / company as a lead (with the tier, the shown price estimate, and which site they came from), and trial projects auto-clean-up after a TTL.

The tiers

• Tier 1 — Website Support: reads the prospect's own website (via the browser tool) and answers support questions about it. Live trial.
• Tier 2 — Support + Scheduling: everything in Tier 1 plus Google Calendar availability/booking. Live trial.
• Tier 3 — Sales: shows products, fills a cart, and places orders via an e-commerce integration. Trial runs on a built-in demo shop.
• Tier 4 — Custom: the visitor picks the MATE capabilities they care about and describes the need → forwarded as a structured lead.

The nice touches

• Site analysis — for website tiers, MATE crawls the prospect's site and runs an LLM to extract a short business summary + a list of services, then injects those into the trial agent. So the agent already "knows the business" before the prospect types a word.
• Per-partner pricing & origins — every site that embeds the wizard can be a "partner" with its own prices, currency, contact email, and allowed domains, all managed from Dashboard → Wizard Pricing with no code change or restart.
• One-line embed — <script src=".../wizard/mate-wizard.js" data-server="..." data-target="mate-wizard">, with data-* options for tier, language (en/sr), currency and partner. Auto-resizes.
• Leads dashboard — every captured lead, its tier, price snapshot and source partner, in one view.

Why I like it as a pattern

It flips lead-gen: instead of "trust us, it's good," the prospect experiences a working agent tailored to their business in ~2 minutes, and you get a warm lead that already knows what they're buying. Same platform, same templates, same widget you'd ship to the customer anyway.

Shipped a top-to-bottom visual refresh of the MATE dashboard. It's not just new paint - the whole UI now runs on a proper design-token system, so colors, surfaces, borders and shadows are consistent everywhere and theming is a single source of truth.

What changed

• Design tokens - one set of CSS variables drives the entire dashboard: --bg-page / --bg-surface, --text-primary/secondary/tertiary, --border / --border-strong, --accent (+ hover/soft), plus semantic --success / --warning / --danger families and a unified --shadow-card. Every template pulls from these instead of hardcoded hex values.
• Light & dark mode - the dashboard now follows your OS preference and supports an explicit theme toggle. Both themes are first-class, not an afterthought.
• Redesigned login - new login page with built-in theme toggling as the first thing you see.
• Reworked navigation - the base layout and sidebar were rebuilt for clearer structure and less visual noise.
• Cleaner Workroom - the chat + canvas workspace got a substantial layout pass: better proportions, tidier controls, easier to read long agent conversations.
• Refreshed overview, agents, and usage views - the landing dashboard, agent management, and token-usage analytics all adopted the new system.

Why it matters

If you build agents in MATE all day, the dashboard is the product. The token system means future features slot in looking native instead of bolting on one-off styles, and the light/dark support finally makes long sessions comfortable regardless of your setup.

https://preview.redd.it/r4oyrl4y52bh1.png?width=1600&format=png&auto=webp&s=9462959560d3ea5761fd22a83446a5a2ac92e533

https://preview.redd.it/kqv2eph262bh1.png?width=1600&format=png&auto=webp&s=ac5c6c7dd699e54eba095dfd7e81fe36bda78c79

https://preview.redd.it/02wvedp462bh1.png?width=1600&format=png&auto=webp&s=f86c28c05e1eeb11a647030114efe9e14ea632aa

We’ve just pushed a massive update to MATE that turns it into a full-fledged lead generation and agent distribution engine.

You can now let visitors to your marketing site (or your partners' sites) build, configure, and instantly test custom AI agents tailored to their business.

Here is a breakdown of what’s new and how you can use it to scale your AI agent business:

🌐 1. Embeddable Agent Builder Wizard (No-Code Setup)

You can now embed a step-by-step agent creation wizard onto any website using a single line of HTML:

<div id="mate-wizard"></div><script src="https://your-mate-instance.com/wizard/mate-wizard.js" data-server="https://your-mate-instance.com" data-target="mate-wizard"></script>

The wizard handles the onboarding, asks for their website URL, automatically analyzes it, provisions a live trial agent, and lets them test it in a live chat widget right there on the page before capturing their details as a qualified lead.

https://preview.redd.it/o2gebjv4do9h1.png?width=1986&format=png&auto=webp&s=2c3f46ad846d2880ca53fa12ba168552aa22fa20

🤝 2. Multi-Tenant Partner Management & Custom Pricing

Want your agency partners to sell MATE agents on their own websites?

• Per-partner Configuration: You can configure partners directly in the Dashboard → Wizard Pricing editor.
• Allowed Origins: Lock down embeds to specific domains (enforced via origin validation).
• Custom Tiers & Currencies: Set specific price points and default currencies (EUR, USD, RSD, etc.) per partner.
• Lead Tracking: Leads are automatically tagged with the partner key they originated from.

https://preview.redd.it/zau59czjdo9h1.png?width=2620&format=png&auto=webp&s=21d5985747679fa01a7871c849821d9ae9d318e2

⚡ 3. Real-Time Trial Provisioning & Zero-Config Demo Modes

We’ve structured the trials into 4 Tiers that auto-provision isolated trial projects:

1. Tier 1 (Website Support): Crawls the prospect's site using the browser tool to answer support questions.
2. Tier 2 (Support + Scheduling): Adds Google Calendar booking. The cool part: Trials use a smart demo mode calendar (in-memory simulated schedule), allowing users to experience the full booking flow without you needing to configure Google API keys for trials.
3. Tier 3 (Sales): Connects to e-commerce. Trials spin up a built-in demo shop MCP (fake catalog + cart + order confirmation) via stdio so they can shop right in the trial chat.
4. Tier 4 (Custom): For complex needs, forwards details directly to your sales team.

https://preview.redd.it/2x3rr122eo9h1.png?width=1974&format=png&auto=webp&s=4305856f8b6dc87f9e994a189b339c5f918112fa

📱 4. Rich Interactive Cards in Chat

We added support for agents to output JSON-based cards inside the chat. This works for any widget-enabled agent by printing markers like [[CARD]] or [[APPOINTMENT]]:

• Product Cards: Display product images, descriptions, and dynamic buttons like "Add to Cart" (which posts messages back to the agent).
• Slots & Bookings: Renders available slots and confirmed bookings with an Add to Calendar (.ics) download button built client-side.
• Actions & Links: Call-to-action buttons that either open links or trigger agent intents.

https://preview.redd.it/h6zodboeeo9h1.png?width=722&format=png&auto=webp&s=317a77f5531bca1b092a6d28350e725b272e862a

💼 5. Admin Lead & Conversion Pipeline

In your MATE Admin Dashboard, you can now:

• See a bird's-eye view of all incoming leads.
• Jump into the trial chat: Test exactly how the prospect's trial agent behaved during their test.
• One-Click Promotion: Once the lead is qualified, promote their trial agent directly into a permanent agent in your main database without having to rebuild it from scratch.

🛠️ Under the Hood

• Rate limits are applied to trial token usage to prevent abuse.
• An optional pluggable Captcha hook (WIZARD_CAPTCHA_PROVIDER) is supported during provisioning.
• Daily cron job automatically cleans up expired trials, keeping your database clean.

We just pushed an update to the MATE (Multi-Agent Tree Engine) repository that makes local agent development and testing even more seamless.

Up until now, running agents on local LLMs was mainly configured through Ollama (ollama_chat/ prefix). If you wanted to use other engines like LM Studio or llama.cpp, you had to manually set them up as custom OpenAI endpoints with explicit URL overrides.

No more! We have added native routing and auto-configuration for the most popular local API servers.

🔌 New Model Prefixes

You can now set the model_name of your agents in the dashboard UI using these new prefixes:

• lm_studio/ (e.g., lm_studio/qwen2.5-7b-instruct) -> Auto-routes to LM Studio's default port (http://localhost:1234/v1)
• llamacpp/ or llama_cpp/ (e.g., llamacpp/llama-3-8b) -> Auto-routes to llama.cpp's default port (http://localhost:8080/v1)
• localai/ (e.g., localai/phi-3) -> Auto-routes to LocalAI's default port (http://localhost:8080/v1)
• llamafile/ (e.g., llamafile/mistral-7b) -> Auto-routes to Llamafile's default port (http://localhost:8080/v1)

🛠️ How It Works Under the Hood

These engines expose OpenAI-compatible endpoints (/v1/chat/completions). When you use one of the prefixes above, MATE will:

1. Extract the underlying model name.
2. Route it through LiteLLM's OpenAI compatibility layer.
3. Automatically supply a placeholder API key to prevent LiteLLM validation errors.
4. Fall back to the default local address and port for that server.

⚙️ Need a Custom Port or Host?

If you're running your local models on a separate server, inside a Docker container, or on non-standard ports, you can easily override the defaults by copying these variables into your .env file:

env# Custom local server URL overrides
LM_STUDIO_BASE_URL=http://192.168.1.50:1234/v1
LLAMACPP_BASE_URL=http://localhost:9000/v1
LOCALAI_BASE_URL=http://localhost:9090/v1
LLAMAFILE_BASE_URL=http://localhost:8000/v1

🎯 Zero-Code Model Swapping

With this update, you can build your full multi-agent tree, test it with Gemini/GPT-4o, and then swap specific sub-agents to LM Studio or llama.cpp on the fly directly from the Studio Visual Builder — all without writing a single line of code or restarting your server.

We are super excited to share a major update to MATE (Multi-Agent Tree Engine)! 🎉

We have officially released an OpenAI-Compatible API Bridge. This allows you to connect external coding agents and developer tools directly to your MATE agents—leveraging MATE's full agentic trees, memory blocks, local tools, etc. right from your workflow!

💡 How It Works

1. Model Discovery (GET /v1/models): External clients query this endpoint to populate their model list. MATE returns the active root agents that have the Expose as Model toggle enabled.
2. Chat Completions (POST /v1/chat/completions): Requests are automatically routed to the selected MATE agent. MATE creates or resumes a persistent session, executes the agent loop on the backend, and streams the responses using standard OpenAI-compatible SSE.

🔒 Security First: Personal Access Tokens (PATs)

To keep your integrations secure, all external requests are authenticated via Personal Access Tokens (PATs) (mate_pat_...).

• Generated tokens are only displayed once during creation.
• Only the SHA-256 hash is stored on the backend.
• Access is restricted using role-based controls (by default, only users with admin or developer roles can verify PATs and query the API).

🛠️ OpenCode Configuration Example

OpenCode is an open-source terminal-native coding agent. You can configure it to use MATE by setting the provider to openai and pointing to your MATE server in your .opencode.json:

>json{
"provider": {
"openai": {
"options": {
"baseURL": "http://localhost:8000/v1",
"apiKey": "mate_pat_your_generated_token"
}
}
},
"agent": {
"coder": {
"model": "openai/your-exposed-agent-name",
"tools": { "write": true, "bash": true }
}
}
}

https://preview.redd.it/vp0vitq22b7h1.png?width=1280&format=png&auto=webp&s=caaf262ad964047bd5b316f2834ee28ffeb1ad97

https://preview.redd.it/lxp2b1d42b7h1.png?width=1258&format=png&auto=webp&s=2e21df5a6d055c4d5de89eb4bda4b16ebd7946c1

👥 Powering Up with Multi-Agent Teams: The coding-agent Template

Alongside the API bridge, we've optimized a specialized multi-agent coding team template using Qwen 3.5 Coder (openrouter/qwen/qwen3-coder-next):

• Lead Coder (coding_root): Exposed via the OpenAI API to receive instructions and coordinate.
• Test Engineer (coding_tester): Automatically writes unit/integration tests and runs them in isolated sandboxes using the MATE code_executor tool.
• Security Auditor (coding_security): Scans code for OWASP Top 10 vulnerabilities and secret leaks.

By pointing your OpenCode configuration to coding_root, you are actually interacting with a fully functional dev team working in the background!

For full details, check out our setup guide: OPENAI_COMPATIBILITY.md.

https://preview.redd.it/7q56ug982b7h1.png?width=1280&format=png&auto=webp&s=d4f2b6562786473c30e64ec48551d6944e4cc239

https://preview.redd.it/56j6fcdb2b7h1.png?width=1280&format=png&auto=webp&s=35d2cc6481cedcd34ef99c09b2f4d850b27bf03e

We'd love to hear your feedback. Let us know how you're using MATE with OpenCode! 🚀

https://x.com/anthropicai/status/2065597531644743999?s=46

https://preview.redd.it/eo3rd45iw07h1.png?width=1200&format=png&auto=webp&s=ac5d3dbb7a57cc155067ce7671032faa92d6ed2a

Hey MATE developers! 👋

We’ve just rolled out a new feature that brings native web browsing capabilities directly to your MATE agents. Agents can now navigate websites, read page content, and capture screenshots to assist you with research and automation.

What’s New?

• Interactive Live Browser View: You can now open a live panel in the dashboard to see exactly what the agent's browser is doing.
• Secure Manual Login & SSO: Need to log in to LinkedIn, Reddit, or Facebook? You can use the Live Browser modal to type your credentials and solve MFA/SSO prompts manually. Once logged in, your agent will immediately inherit the authenticated session and browse securely.
• Isolated User Sessions: Cookies and session data are stored securely and isolated per user, meaning multiple users can run browser tasks simultaneously without session mix-ups.
• Inline Screenshots in Chat: When the agent takes a screenshot during browsing, the image is automatically rendered directly inside the chat bubble so you can visually confirm its actions.
• Easy Session Control: Quick actions in the address bar allow you to clear cookies for the current website or completely reset your browser profile with one click.

https://preview.redd.it/iitklg4fcp5h1.png?width=1294&format=png&auto=webp&s=48b4ffaef5f8d08ab993ba3d0e75ce4d08975066

How to use it:

1. Select an agent with browser tools enabled (or import the Browser Research Assistant template).
2. Click the Live Browser button in the chat header.
3. Navigate to a site, log in, and close the modal.
4. Prompt the agent (e.g., "Open Reddit and find the latest news"). The agent will browse autonomously using your active logged-in session!

We have some exciting news! MATE (Multi-Agent Tree Engine) is now fully compatible with the new Google ADK 2.x (v2.1.0+) release.

To achieve this, we have cleaned up deprecated runtime code and completely replaced the legacy sequential and parallel flow types with ADK's new graph-based Workflow Engine!

Here is a quick summary of what’s new:

1. Graph-based Workflow Runtime (type: graph)

Instead of simple linear chains or rigid parallel structures, you can now define arbitrary, complex graph configurations using the ADK Workflow runtime:

• Custom Edges: Route tasks dynamically between sub-agents via the edges configuration in planner_config.
• JoinNode (Fan-in): Coordinate parallel paths to execute concurrently and aggregate their outputs through join nodes before proceeding.
• Sequential Fallback: If you transition an agent to graph but don't configure custom edges, it automatically falls back to a sequential execution chain to keep your existing agents running without extra setup.

2. Visual Builder Upgrade

The drag-and-drop React Flow visual builder (/dashboard/agents/visual) has been fully updated:

• Legacy nodes have been replaced with the new Graph Node type featuring a sleek purple styling.
• Properties panel and agent forms now support creating and managing graph agents.

3. Under the Hood & Schema Safety

• Cleaned up all SequentialAgent and ParallelAgent deprecation warnings.
• Input and output JSON schemas are fully compiled into Pydantic models at runtime for graph agents to ensure strict API contract validation.
• Optimized concurrency callbacks within the Graph workflow to prevent asyncio TaskGroup errors.

The full unit test suite (175 tests) is green against ADK 2.1.0. 

Hey r/mate_agents! 👋

I’m excited to share that I've just published a dedicated page on my website explaining MATE in full detail!

If you’ve been following our recent updates—like the massive dashboard reorganization, Native Google/GitHub SSO, and the autonomous Trigger Engine—this new page brings everything together. It shows exactly how MATE acts as your ultimate "Command Center" to stop the messy "redeploy-to-tweak" loop for production AI agents.

You can check out the full deep-dive here: https://antonijevic.rs/mate/ (There is also a brief high-level overview right on the homepage: https://antonijevic.rs/)

On the site, you'll find a breakdown of how MATE transitions raw Google ADK scripts into a structured enterprise platform via our four core zones:

• 🛠️ The Studio: Our Visual Builder for drag-and-drop agent hierarchies and inline tool toggling.
• 🖥️ The Control Room: Enterprise governance featuring built-in RBAC, multi-tenant project isolation, and deep 4-type token analytics.
• 💬 The Workroom: The clean end-user chat interface with real-time event tracing and capability badges.
• 🧪 The Lab: Automated Regression Testing using LLM-as-a-Judge to ensure your prompt changes never break existing logic.

Take a look and let me know what you think of the new presentation! Does this structure make it easier to explain MATE's value to your non-technical teams or clients? Let's discuss in the comments!

Hey everyone,

We've added a new feature to MATE (Multi-Agent Tree Engine): The Canvas Panel.

The Canvas panel provides an integrated workspace next to the chat window to view, edit, and run code in real time.

Here is a breakdown of how it works and what it supports:

🧼 Dedicated Workspace

Whenever an agent responds with a code block (HTML, CSS, JS, SVG, or Python), MATE extracts the code from the message stream and displays it in the Canvas Panel on the right side of the chat. The raw code is replaced in the chat thread with a small pill badge, keeping the conversation history clean and readable.

📝 Integrated Ace Editor

The Canvas panel features a syntax-highlighted Ace Editor supporting HTML, JS, CSS, SVG, and Python. You can:

• Modify the generated code directly.
• Copy the contents to your clipboard.
• Download the file locally (.html, .py, .js, etc.).

https://preview.redd.it/iddc92zlb52h1.png?width=3024&format=png&auto=webp&s=ca9f0d24132072e3058e2186e814f792c7a71003

⚡ Sandboxed Execution & Live Previews

You can run and test code directly in your browser without setting up local servers:

• Web Languages (HTML, JS, CSS, SVG): Execute instantly inside a secure, sandboxed iframe. You can switch between code and preview tabs, refresh the runner, or open the preview in a new tab.
• Python Scripts: Run completely in the browser via Pyodide (WebAssembly), offering a safe local sandbox to test scripts, data processing, or general logic.

https://preview.redd.it/rjxmifmnb52h1.png?width=3014&format=png&auto=webp&s=cff2cdfd6ddbad66c9a6550b22f58f89f42dba58

🔄 Bidirectional Context (Canvas-to-Prompt Injection)

If you make manual edits inside the Canvas editor, those changes are automatically included as context in your next chat message (indicated by the ⌨ lang · canvas badge in the input area). This allows you to ask the agent to refine, extend, or debug your modified code without manual copy-pasting.

📐 Layout & Workflow

• Resizable Panel: Adjust the width of the chat and canvas panels by dragging the divider.
• Session Reset: Starting a new chat session automatically resets the canvas to avoid carrying over old code.

🚀 Getting Started

The Canvas panel is integrated directly into the dashboard's Work Room route.

1. Pull the latest main branch: git pull origin main
2. Start the auth server: python auth_server.py
3. Open http://localhost:8000/dashboard/workroom and ask a root agent to build a simple interactive element or run a Python calculation.

Let us know if you have any feedback or suggestions for additional execution environments!

GitHub Repository: github.com/antiv/mate

Most open-source AI dashboards rely on a single admin password (HTTP Basic Auth).

This is great for local testing but is an absolute dealbreaker for enterprise rollouts where teams need strict access control and automatic user provisioning.

We just upgraded MATE with Native Single Sign-On (SSO). You can now configure Google (OIDC) or GitHub (OAuth 2.0) logins. When a team member logs in, MATE auto-provisions their account, assigns a default role (via `OAUTH_DEFAULT_ROLE`), and secures their session with an encrypted `HttpOnly` cookie.

Combine this with our per-agent Role-Based Access Control (RBAC), and you finally have an orchestration engine your IT team will actually approve. Most open-source AI dashboards rely on a single admin password (HTTP Basic Auth). This is great for local testing but is an absolute dealbreaker for enterprise rollouts where teams need strict access control and automatic user provisioning.

Pozdrav. Primetio sam da se ovde često polemiše o m-banking aplikacijama i plaćanju računa. Svi volimo "IPS skeniraj" opciju jer štedi vreme, ali problem nastaje kada dobijemo račun koji nema QR kod, fakturu na mail ili vizitku, pa moramo peške da kucamo žiro račun, iznos i onaj predugački poziv na broj (gde se lako i pogreši).

Pošto se bavim programiranjem, odlučio sam da rešim ovaj problem i napravio sam Android aplikaciju Invoice2IPS.

Kako radi? Samo uslikate račun (ili ubacite sliku). Aplikacija koristi AI da automatski pročita podatke sa papira (iznos, račun, poziv na broj) i od toga u sekundi generiše standardni NBS IPS QR kod. Vi onda samo otvorite aplikaciju vaše banke, skenirate taj kod i potvrdite plaćanje.

Nema ručnog kucanja, nema grešaka. Aplikacija NE vrši obradu transakcija, samo generiše kod koji vaša banka prepoznaje.

Evo i kratkog videa od par sekundi kako to izgleda u praksi:https://youtube.com/shorts/z7D_D3rCKks

Link do Google Play prodavnice:https://play.google.com/store/apps/details?id=rs.antonijevic.invoice2ips

Aplikacija je besplatna i namenjena isključivo našem tržištu. Voleo bih da čujem vaše mišljenje, kritike i predloge za unapređenje! Ako nađete neki bag, pišite. Nadam se da će vam uštedeti vreme.

When an API goes down, prices spike, or a model gets deprecated, hardcoded agents break.
Switching providers usually means rewriting code across your entire ecosystem.

MATE abstracts the LLM layer completely. We support 50+ providers out of the box via OpenRouter and Gemini. Want to switch a sub-agent from GPT to a local, private models?
Just open the Command Center dashboard and change the `model_name` prefix to `ollama_chat/gemma4`. Zero code changes. Zero redeployments.

Are you running any of your agents fully locally on Ollama?

By default, AI agents are reactive—they sit and wait for a human prompt. If you want an agent to scrape news every morning or summarize your emails, you usually have to write messy external cron scripts to "wake them up".

We built the Trigger Engine into MATE to make agents truly autonomous. You can now schedule any agent to run in the background using standard Cron expressions, or trigger them via external Webhooks. Once the agent finishes its task, MATE automatically routes the output to a Persistent Memory Block, an external HTTP API, or straight to your email.

You built the perfect agent hierarchy, but your client or marketing team doesn't know how to install Docker or manage Python environments. Sharing your work shouldn't be a blocker.

With MATE, you don't have to host anything if you don't want to. You can export your entire agent hierarchy and use our build_standalone_agent.py to package it into a click-to-run desktop application (.exe or .app) that runs completely locally. Alternatively, drop a <script> tag to embed your agent directly onto any website as a chat widget.

Stop telling users how to open the terminal. Just send them the app.

As MATE moves toward enterprise-scale orchestration, we’ve reorganized the dashboard to separate End-User, Developer, and Administrator workflows. The new "Command Center" is now divided into three core sections: The Work Room, The Studio, and The Control Room.

🛠️ 1. The Work Room (End-User Experience)

This is the primary interface for interacting with your deployed AI agents.

- Featured Root Agents: No more searching through long lists of sub-agents. Your primary "Root Agents" (e.g., Finance Bot, Research Assistant) are now showcased as cards for instant access.

- Central Chat Hub: A clean, focused multi-agent chat interface with real-time event tracing for tool calls and agent "thoughts".

🧪 2. The Studio (Developer Experience)

The central hub for building, testing, and refining your agent hierarchies.

- Visual Builder 2.0: Our drag-and-drop React Flow canvas has been upgraded for better parent-to-child connection drawing and inline tool toggling.

- The Eval Lab: The home of the new MATE Eval Framework. Run automated test suites using LLM-as-a-Judge and track Regression Testing to ensure prompt changes don't break existing logic.

- Knowledge Connectors: Manage database-backed memory blocks, RAG configurations, and the Template Library for one-click deployment of common agent structures.

🖥️ 3. The Control Room (Ops & Admin Experience)

This is the "eye in the sky" for system administrators to manage global governance.

- Service Health Grid: A centralized metric table monitoring all 17+ micro-components, including the ADK server, database, and MCP integration status.

- Usage & Cost Analytics: Consolidates MATE’s unique 4-type token tracking (Prompt, Response, Thought, and Tool-use) to provide deep insights into API costs and performance.

- RBAC & SSO: Manage user permissions, project-level isolation, and native Google/GitHub OAuth configurations directly from the UI.

Check out the new UI on GitHub: 🔗 antiv/mate