The dashboard isn’t a UI - it’s a boundary.
One of the first lessons we learned building Anjin: once you give people access to powerful AI agents, you have to treat that access like a responsibility. Especially when it’s your internal team holding the keys.
This is how we’ve been shaping our admin dashboard - where security, transparency, and control come together to manage what agents can do, and who can do what.
Why We Built It Ourselves
There are tools out there that could’ve covered parts of what we needed. But we realised pretty quickly: no off-the-shelf dashboard understands what it means to deploy and govern AI agents across domains, users, plans, and tokens.
So we built our own - designed around three core ideas:
- Trust is earned through transparency
- Admin doesn’t mean “unlimited”
- Every action must be traceable
Security as First-Class UX
One of the earliest mistakes we inherited (shout out to Lovable again) was the assumption that admin tools don’t need full protection. At one point, credentials were stored in cookies - and yes, that meant early versions were publicly accessible with a bit of console digging.
We don’t do that anymore.
Now, every admin login goes through:
- 2FA with time-based verification
- Role-based access control (RBAC) down to page and function level
- Edge Function gating for every sensitive action (not just form guards)
Admin actions like credit grants, agent deployment, and plan updates can’t be spoofed or run client-side. They live behind hardened server logic with full logging and verification.
We don’t rely on front-end logic to enforce policy - because we’ve learned better.
What the Dashboard Actually Lets You Do
Without giving the whole map away, here’s a sense of what super-admins in Anjin can manage:
- View and modify user roles
- Grant credits or reset domain swaps
- Create or adjust pricing plans
- Add, edit, and deactivate agents
- Toggle internal flags and experimental features
- Monitor agent activity and domain health
And yes, every one of these goes through a secure pipeline. If you’re curious about how it’s wired, we’re always happy to chat - jump into the community.
Scale ≠ Chaos
We’ve been thinking hard about what happens when Anjin goes from 20 active agents to 2,000. When hundreds of users are running requests, deploying new agents, or chaining workflows.
This dashboard is our buffer. It keeps us sane.
And more importantly, it gives us visibility into edge cases before they become bugs - or worse, silent failures.
Because when you’re building something modular, dynamic, and open-ended, the platform needs to be smarter than the sum of its parts.
Looking Ahead
- We’re refining real-time logs for agent runs and failure cases.
- We’re working on admin-side flags that let us experiment with UX changes before rolling them out broadly.
- We’re exploring non-human users - what happens when other apps start managing agents via API? That’s going to need even tighter controls.
Final Thought: Governance Is Product Design
It’s easy to think of admin tools as an afterthought. But if you’re building AI products - especially modular ones - they have to be part of your core system design.
The dashboard isn’t an accessory. It’s the part of the product that makes the rest of it safe to use.
And since we’re shipping this on Sam’s birthday, let’s call it a gift to future-you: the kind of tool that saves you from a mess you didn’t know was coming.
Want to see what this looks like in practice?
Join the community and ask us anything. Or catch up on earlier posts in the series:
- Inside Anjin #01: From Lovable to Liveable
- Inside Anjin #02: Why We’re Listening to BigQuery
- Inside Anjin #03: Dinner with AI
