Every employee gets their own AI agent. accd.dev is the layer that manages all of them: who can do what, how much they spend, which process they follow, and who signs off before anything real happens.
The question isn't whether AI can do the work. It's that once AI is running inside a company, nobody can answer these four questions.
Everyone has their own account. One big invoice arrives at month end. Nobody knows which team spent what, or which task was expensive. You can't cut what you can't see.
It emailed a client, edited a file, called an API. Then the trail ends. When something breaks, all you have is a screenshot.
A shared assistant loads every document into one place and answers everyone. Payroll, contracts, customer data. Human permissions disappear the moment the question goes through AI.
Your company has its own processes and rules. AI doesn't know any of them. It works fast, but it works its own way, not your way.
Those four questions become four layers. They share one department tree and one permission table, so they don't drift apart.
Every AI call goes through the platform. So every unit of spend has a name, a department and a task attached.
Each run records who ran it, which department, which task, and what it cost. View by day, week or month. View by person, team or project. Every number clicks down to the original task.
Set caps for the company, each department, each project and each person. Out of budget means the work stops and reports back. Going over requires approval.
Admins choose which models are available and to whom. Employees pick from that list. Changing vendors is a config change.
Per person and per team: how much got done, how much got sent back, cost per task. Every score clicks through to the evidence behind it.
A project holds the conversations, files, instructions and task list together. People and agents sit in the same task board.
A private project is one person's workspace. A shared project belongs to the team, and who gets in follows the permission table.
The assignee can be an employee or an agent. Agent tasks show a clear state: queued · running · waiting for review · failed.
When the agent finishes, the task isn't closed. The result goes into the owner's review queue. Click Accept, or Return with a reason.
Overdue work, silent projects, tasks nobody picked up. Visible on the board instead of asking around.
This is where leaks happen. The rule: filter by permission first, then search. Never search first and redact afterwards.
Upload → process → publish to a group → replace with a new version → archive. Old versions stay retrievable.
An employee's question only pulls from documents that person is allowed to see. Change teams or lose access, and the agent loses it too.
No source, no answer. Click the citation and you get the exact passage, page and document version.
Files sent into a conversation are kept, parsed and summarised. Sensitive data is masked, and every time someone unmasks it, that's logged.
This layer teaches agents how your company works. Without it, AI is fast but does things its own way. With it, an agent follows process like a trained employee.
A manager answers questions, the agent writes the process out. Already have documents? Drop them in — the agent reads them and only asks about the gaps. Anything unclear gets flagged for a human to decide.
The SOP doesn't sit in a folder. It's what the agent reads before working. Approving spend, sending a quote, handling a complaint — all follow the steps the company agreed on.
The system compares how people actually work against the written SOP. Where they differ, it says so. Two options: remind the team, or update the SOP because reality makes more sense.
Every important action records which process it followed, which version, who approved it and when. When you need to explain yourself, you have a file, not a memory.
This is the biggest difference from a chatbot. accd.dev splits work across multiple agents and gives each one only the access its part needs.
Say: "Close out payment round 3 for contractor B." The system splits it: read the contract, check the measured quantities, verify the invoices, draft the memo. Each piece becomes its own task.
The agents run in parallel, one part each. They report back to the main agent, which assembles the finished package.
Each one touches only what its part needs. There's no path for it to gain extra access. Most multi-agent setups leave this open.
Five agents run, but the cost lands on the one parent task. You see a single figure, not five scattered lines.
Weekly reports, receivables checks, stalled-order sweeps. Set it once and the agent runs it. Each run is still logged and still goes through approval.
The permission table is department × role. Four roles: employee, department manager, executive, platform admin.
Changing permissions shows a diff before saving. Every change is recorded.
Reading data, the agent does alone. Writing into a system requires a preview. Sending anything outside the company requires an approver.
Approvers are on a clock. Miss it and it escalates.
Nobody sees this part. It's the part that decides whether any of it can be trusted.
Before running, the agent gets a permit stating who it's acting for, which department, which tools it may use, how much it may spend, and when it expires. No passwords or API keys inside. When it expires, it's void.
The summary — who ran it, what task, what it cost — is visible to management. The content — the prompt and the result — belongs to the owner. A manager can read the content, but that read is logged and the employee sees it.
The approval screen shows the exact email that will be sent, the exact row that will be written. Not a vague description. Once approved, it's locked — if the agent changes its plan, it has to ask again.
Permission grants, budget changes, approvals, rejections, sensitive data being opened. One line each, exportable by date range.
Click to expand each example.
The common approach today is a licence per person and let people figure it out. It works, up to a point.
| Dimension | accd.dev | A licence per person |
|---|---|---|
| Cost | One ledger, by person and team | Many invoices, no link to actual work |
| Permissions | By department and role, preserved through AI | Anyone can paste in anything |
| Traceability | Full task ledger and audit log | Personal chat history, gone when they leave |
| Company process | Agents read the SOP first | AI does it its own way |
| Risky actions | Preview plus a human approver | The agent acts; you find out after |
| Big multi-step jobs | Several agents, access kept separate | One chat window, you do the stitching |
| When someone leaves | Access revoked, data stays with the company | Context walks out with the account |