Building an AI Agent Platform for Enterprise Automation and Collaboration

abundly.ai · Tech · 2024 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.4 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Enterprise agent platform

Abundly.ai needed a production platform where enterprises could create, configure, govern, and improve AI agents as digital colleagues rather than one-off chatbots or brittle workflow scripts.

Constraints:

Agents need an operating environment, tool permissions, and lifecycle management.
Tool use can be dangerous or noisy without guardrails and user confirmation.
Enterprise agents must fit team ownership, authority, and accountability structures.
Non-technical users need to configure agents conversationally rather than by writing code.

Architecture

Abundly treats an agent as a colleague with a lifecycle: create the agent in a team account, discuss its job, grant credentials to tools such as Slack or GitHub, let it write and confirm its own instructions, run the task, receive feedback, update instructions, and optionally connect to other agents under explicit permission. The platform is framed as an operating system where agents live, work, and are managed with human oversight.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  team-account[Team Account] --> human-owner[Human Owner]
  human-owner --> agent-platform[Agent Platform]
  agent-platform --> agent[Agent]
  agent-platform --> tool-integrations[Tool Integrations]
  agent --> tool-integrations[Tool Integrations]
  agent-platform --> other-agents[Other Agents]
  agent --> other-agents[Other Agents]

Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component	Role	Interacts with
`Team Account`	Workspace containing humans and agents that share work and ownership.	`Human Owner`, `Agent Platform`
`Human Owner`	Person who creates, trains, grants access to, and gives feedback to the agent.	`Team Account`, `Agent Platform`, `Agent`
`Agent Platform`	Agent operating system for creation, onboarding, permissions, instructions, feedback, and agent-to-agent links.	`Team Account`, `Human Owner`, `Agent`, `Tool Integrations`, `Other Agents`
`Agent`	LLM-driven worker that receives a job, instructions, tools, and feedback.	`Human Owner`, `Agent Platform`, `Tool Integrations`, `Other Agents`
`Tool Integrations`	External systems such as Slack, email, GitHub, ticketing systems, or phone calls exposed to approved agents.	`Agent Platform`, `Agent`
`Other Agents`	Approved collaborator agents, such as a compliance expert, that the primary agent can contact when allowed.	`Agent Platform`, `Agent`

Data flow

A team member creates an agent, describes the job conversationally, grants needed tool credentials, confirms the agent's instruction manual, receives Slack/email outputs from the running agent, gives feedback when an output is not useful, and the platform updates the agent's instructions or connects it to approved collaborators.

“the way that works is you just log in and you click create agent Now you have one, you can start chatting with it. It doesn't have any job. It's just going to be like a chat. And then I tell it what I just said. Now your job is blah blah blah. You know, check my”transcript, stated

“the agent writes its own instruction manual for itself and says, "I wrote this for myself. Do is this correct?"”transcript, stated

Why this architecture

Abundly rejected a pure workflow metaphor because enterprise work is owned by people and teams. Its agent-as-intern architecture makes authority, permission, onboarding, feedback, and gradual responsibility explicit, which better matches how organizations manage risky complex work.

“to go to. Agents need their office, a place to live and a place where you go to configure them. uh so in a sense an operating system for agents since we make that then we want our agents to behave well. So the agentic capabilities of an of an LLM is what we are most”transcript, stated

“we need to we we need to model authority and mandates around agents to fit in a team. agency to fit with the decision agency of a manager otherwise you have no accountability then to get to then you get to the the longer term okay is that a smart agency”transcript, stated

Models used: GPT-4 · Claude

Scale

The SVT agent originally required several weeks of work and later could be made in a few hours on the platform.
“a lot of work. It was several weeks of work to make that agent and uh but now we could make an agent like that in like a few hours. >> Yeah. Because all of a sudden now we let's expand on the fundamental um theme. Uh we need a place where agents live or sit.”transcript, stated
The platform supports team accounts made of both humans and agents.
“when you create an account it's always a team account. So a team is basically a collection of humans and a collection of agents”transcript, stated

Alternatives considered (roads not taken)

Build bespoke agents by coding against APIs each time.

Rejected because: Even a simple GitHub security-watch agent could take weeks to build well without a platform.

“I could sit down and start writing code using you know these different APIs I could spend weeks making that work really well”transcript, stated

Treat the agent platform mainly as predefined workflows.

Rejected because: Abundly's metaphor is an intern/coworker who can be onboarded, coached, and given growing responsibility.

“>> So some agent platforms focus very much on the concept of a workflow >> and inside the workflow there's a number of different steps. um our metaphor is more the intern.”transcript, stated

Let agents freely use every available tool.

Rejected because: Early models overused tools and needed prompting, guardrails, and permission checks.

“platform had to be very much like you can send emails but don't unless you really should >> and maybe you know ask the user first. So there's a lot of prompting and guard rails around that. But now what's happened is the models are getting so”transcript, stated

Patterns

`tool-use-orchestration` (agent-platform)

The platform gives agents explicit tool lists and permissions for actions such as email, Slack, GitHub, and phone calls.

“we offer then the large language model a list of tools it can do. For example, sending an email or checking Slack or going to GitHub.”transcript, stated

`human-in-the-loop-gate` (governance)

Users approve credentials, confirm the job description, give feedback, and decide whether agents can talk to other agents.

“Because we can't let agents just they need to we need to give them permission to access things, right?”transcript, stated

`agent-memory` (agent-platform)

The agent writes and updates its own instruction manual based on user feedback, creating persistent behavioral guidance.

“And then it says, "Okay, shall I update my instructions?" "Yes, please."”transcript, stated

`multi-agent-orchestration` (agent-platform)

The platform allows one agent to ask another approved expert agent questions, with explicit links rather than random agent conversation.

“I draw a line between them say you can talk to each other.”transcript, stated

`safety-policy-enforcement` (governance)

Abundly models authority, mandates, and accountability so agents fit team decision structures.

“if your mandate and decision structure looks in a certain way in an organization and and this is connected to budgets”transcript, implied

Tradeoffs

Platform abstraction

Chose Reusable agent operating system over Bespoke coded agents per use case.

Rationale: The platform reduced weeks of work to hours for an SVT-style agent by centralizing lifecycle and integrations.

“several weeks of work to make that agent and uh but now we could make an agent like that in like a few hours.”transcript, stated

Agent metaphor

Chose Intern/coworker lifecycle over Pure workflow automation.

Rationale: The team believed enterprise agents need onboarding, feedback, authority, and gradual trust, not just process steps.

“start by giving them a simple task. See if they can do it well. as they build trust, you can give them more responsibility.”transcript, stated

Agent collaboration

Chose Explicit permitted agent-to-agent links over Free-form conversations among agents.

Rationale: Enterprise agents can collaborate only when the owner grants the relationship.

“I draw a line between them say you can talk to each other.”transcript, stated

Gotchas (what bit them)

Chat-tuned models may overuse tools.

Root cause: Early tool-wrapped chat models treated available actions as exciting opportunities rather than governed responsibilities.

Resolution: Constrain tool behavior with prompting, guardrails, common-sense model improvements, and user approval.

“I can send emails. That's so cool. I got to find an excuse to send an email at every turn cuz I can do this.”transcript, stated

A platform metaphor changes the product surface.

Root cause: Workflow-first and coworker-first views imply different lifecycle, ownership, and permission requirements.

Resolution: Choose the intern/coworker metaphor and build onboarding, feedback, ownership, and team-account mechanics around it.

“depending on how you enter philosophically or how you frame what an agent is and and how it's set up”transcript, stated

Agents without accountability can collide with organizational authority.

Root cause: An optimal process agent may not map to who owns decisions, budgets, or responsibility in the company.

Resolution: Model authority and mandates around agents so they fit existing teams before expanding responsibility.

“the perfect flow doesn't equate with the organizational decision mandates, you are creating a lot of trouble.”transcript, stated

Evaluation

The transcript frames evaluation operationally: create agents for real client cases, onboard them into tools, observe whether they perform useful work, and improve instructions through feedback from the human owner.

Metrics: Time to create an agent · Usefulness of agent notifications · Need for instruction updates · Tool permission correctness · Human trust and responsibility expansion

“Agent says, "Hey, you put up a PR. It has this dumb security problem. Henriken, you should do something about it."”transcript, stated

“The thing you wrote yesterday was not terribly useful." And it says, "Oh, why not?"”transcript, stated

Outcomes

Abundly turned several-week bespoke agent builds into a platform workflow that could create similar agents in hours.
The platform supports agent onboarding, credentials, instruction updates, feedback, and agent-to-agent permissions.
The team-account model frames agents and humans as shared members of an organization.

The transcript cites one SVT agent moving from several weeks of work to a few hours and describes team accounts as collections of humans and agents.

“the way that works is you just log in and you click create agent”transcript, stated

“a team is basically a collection of humans and a collection of agents and then you basically decide how do we split this work.”transcript, stated