
Conti-Newty: A Shared AI Workspace with Cited Answers
How we built Conti-Newty, an AI workspace where agents cite their sources and humans approve every change, plus the deployment bug that fought back.
Building Conti-Newty: A Shared AI Workspace Where Answers Come With Sources and Humans Approve the Changes
An AI assistant dropped into a company's daily work doesn't know which document is current, which process was actually approved, or where a claim in its own answer came from. It answers confidently, and you have no easy way to check it.
We built Conti-Newty to close that gap. It's a workspace where an AI agent works from a team's own files, cites what it used, and can't change anything without a human approving it.
This post covers what works, what's partial, and what's still a plan. I'm keeping those separate on purpose.
The Problem
Company knowledge is scattered across documents, chat threads, tools, and people's heads. Plugging an AI assistant into that mess doesn't fix it. The assistant still can't tell you what's current, what's approved, or where an answer came from.
We wanted one product that combines things that don't usually show up together:
- Company-specific knowledge
- AI-assisted work
- Source citations
- Team collaboration
- Human approval
- Internal application generation
- Organizational memory
The goal was never another chatbot. We wanted a shared workspace where a team can give an AI agent real context, watch what it does, verify its answers against sources, and eventually turn the corrections humans make into knowledge the system keeps.
What We Built
Conti-Newty is a collaborative AI workspace. The backend is a modular monolith (one deployable app, split into internal modules rather than microservices) written in Node.js, Express and TypeScript. The frontend is React with Vite. Data lives in PostgreSQL through Prisma, and the whole thing runs on AWS ECS/Fargate behind an Application Load Balancer.
A team can:
- Give an AI agent access to workspace-scoped files and context
- Ask questions and get answers grounded in those files, with citations
- Approve or reject any file changes the agent proposes
- Collaborate in a shared workspace in real time
- Generate small internal applications from inside the workspace (a "Small Software Cloud" for lightweight internal tools)
- Capture organizational knowledge as structured "Tribal Memory"
Not all of this is fully built.
How It Works
When someone asks the AI a question, this is the path:
User enters question
→ React frontend sends POST request
→ Express task router authenticates the user
→ Workspace authorization checks membership and role
→ Backend creates an AgentTask
→ AgentRunner starts execution
→ BrainTools reads permitted workspace files
→ SourceTracker records which files were accessed
→ Context goes to the selected AI provider
→ AI generates an answer
→ Citations are extracted and validated
→ Agent events are stored
→ Task result returns to the frontend
→ Frontend displays the answer and citationsInside the agent runner, each task follows a fixed sequence:
- Receive the prompt and pick an agent configuration.
- Create or update an
AgentTaskand mark it running.
- Record a start event.
- Gather workspace context with the tools
list_directory,read_file,search_files,write_fileandcreate_file.
- Send that context plus the prompt to the AI provider.
- Track which source files were touched.
- Extract citations from the answer and strip any citation it can't verify.
- Store the response and events, mark the task completed or failed, and broadcast the update over Socket.IO.
File changes take a separate path. The backend reads the original file, receives the proposed content, computes a unified diff, and stores it as a
ProposedChange in a PENDING state. Only when an authorized reviewer approves does it apply the change, atomically.Technology Stack
Layer | Technology |
|---|---|
Frontend | React 19, TypeScript, Vite, React Router 7, Tailwind CSS 4, Motion, GSAP, Lucide React, Socket.IO client |
Backend | Node.js, TypeScript, Express 4, Socket.IO 4, JWT-based auth |
Database | PostgreSQL via Prisma ORM (SQLite in some local/test setups) |
AI providers | Anthropic/Claude, OpenAI, Google Gemini, Amazon Bedrock, behind a provider abstraction layer |
Validation | Zod |
Testing | Jest, Supertest |
Hosting | Docker (Node 20 Alpine base), AWS ECS/Fargate, Application Load Balancer |
Dev tools | Git, GitHub, npm, Docker, Prisma CLI, VS Code, AWS CLI |
The schema is fairly extensive. It models organizations, users, memberships, workspaces, threads, messages, agent tasks and events, tool executions, proposed changes, generated applications, deployments, credentials, connectors, Tribal Memory entries, and audit and usage logs.
Architecture

The deployment path is Docker image → Amazon ECR → ECS/Fargate → Application Load Balancer → the Node.js/Express container. Supporting services are an ECS task role with IAM permissions, Bedrock model invocation, S3 for archives, Secrets Manager for secrets, and CloudWatch for logs. The container listens on port 3000, and the load balancer health check hits
/api/health . A separate Prisma migration task also runs on ECS/Fargate.Implementation
The backend layout:
src/
├── api/ auth, workspaces, files, threads, tasks, changes, apps, orgs
├── modules/ brain, storage, auth, changes, app-generator
├── realtime/
├── middleware/
├── db/
└── server.tsAsking a question hits
POST /api/workspaces/:workspaceId/tasks :{
"title": "Refund policy review",
"prompt": "What is the current enterprise refund policy?"
}The backend authenticates the user, checks workspace membership and role, creates an
AgentTask , and starts the runner. Along the way it writes AgentEvent and ToolExecution records, so there's a trail of what the agent did.Proposing a change hits
POST /api/workspaces/:workspaceId/changes , which produces the PENDING diff described above.Provider abstraction. The original design centered on Claude directly. We added provider abstraction and routing afterward so the same agent logic could run against Bedrock, OpenAI or Gemini depending on configuration.
AgentRunner , BrainTools and AIClient sit on top of provider-specific implementations, source tracking and citation validation. A credential resolver handles workspace-, user- and deployment-level provider credentials. The AWS demo deployment uses Bedrock as its production provider.What Fought Back
The most frustrating problem was a deployment bug where the live root URL served the wrong frontend.
The backend was healthy.
/api/health on the deployed service returned:{ "status": "ok", "provider": "bedrock", "archiveStorage": "s3" }The load balancer was responding and the container was alive. But the browser, at the root URL, showed an old static landing page instead of the React app. The HTML carried the legacy page's title,
Conti-Newty Workbench — The Multiplayer Company Brain & Knowledge OS , rather than the Vite entry point I expected:<div id="root"></div>
<script type="module" src="/src/main.tsx"></script>The first guess was that the Docker image wasn't copying the frontend build, or that the load balancer was routing to the wrong target. Neither was true. The frontend build existed in the image.
The actual cause was that the repo had two frontend entry points,
public/index.html and apps/web/index.html , and Express was serving static files from both at the root:app.use(express.static(clientDistDir));
app.use(express.static(publicDir));Two static directories mounted at
/ means the legacy page can answer requests meant for the new app. The legacy public/index.html was the one being served.The fix was to make
dist/client the only frontend at the root and move the legacy files under their own path:app.use('/public', express.static(publicDir));The SPA fallback (the catch-all route that serves the React app for client-side URLs) now returns
dist/client/index.html . API, Socket.IO and generated-application routes are explicitly excluded from it so it doesn't swallow them.We verified this locally against the built server:
ROOT=200
ROOT_HAS_REACT=True
ROOT_HAS_LEGACY=False
HEALTH=200The fix is not live yet. The public URL still needs the corrected image pushed to ECR, a new ECS task definition revision, and a rollout behind the load balancer.
What Changed During the Build
The scope grew much faster than I expected. It started as a Company Brain and AI workspace idea. By the end it had picked up authentication, organizations, agents, source grounding, realtime collaboration, change governance, Tribal Memory, connectors, generated applications, an AWS deployment pipeline, and a new product direction called Live Agent Learning.
The build went through roughly these phases:
- Core backend: Node.js/TypeScript/Express, authentication, org lifecycle, Prisma layer, basic authorization
- AI Brain and app generation: agent runner, brain tools, source grounding, citations, multi-provider support, app generator, connector foundations
- Realtime collaboration: Socket.IO, presence, cursors, file-viewing status, typing state, task rooms, live task events
- Frontend workspace: the React/Vite app, landing page, and the Brain, Ask, Work, Agents, Software, Members, Activity, Security, Settings and Archives surfaces
- Multiplayer AI enhancements: better task collaboration and realtime agent activity
- AWS workflow: Bedrock integration, S3 archive support, Docker, ECS task definitions, migration workflow, Secrets Manager
- Live Agent Learning direction: defining Live Sessions, Driver/Observer control, human redirects, Skill Entries, skill review and confirmed skill reuse
That growth showed me the project needed a much sharper line between what's implemented and what's planned, which is why this post is so explicit about status.
Results
Here is where each feature stands today, not where it's headed.
Feature | Status |
|---|---|
Company Brain (workspace files, brain tools, Tribal Memory) | Partially working |
Source-grounded answers and citations | Partially working |
Multiplayer collaboration | Realtime foundation working; full collaborative agent workflow planned |
Human-reviewed file changes | Early implementation working; full governed workflow planned |
Internal app generation (Small Software Cloud) | Partially working |
Tribal Memory | Partially working |
Secure workspace governance | Partially working |
Live Agent Learning (Sessions, Driver/Observer, redirects, Skill Entries) | Planned, not implemented |
Workspace and agent access. Workspace-scoped file storage, directory listing, file read/write/search, read-only paths, path traversal protection and brain tools are in place.
Citations. The agent runner gathers context, tracks sources, extracts citations and removes any it can't verify, using a format like
[source: path/to/file.md:14-22] . Retrieval reliability, citation presentation, freshness tracking and conflict handling between documents still need work.Realtime. Socket.IO rooms, presence, cursors, typing indicators and live task events are built and working. Live Sessions, Driver/Observer roles, session-specific authorization, redirects and replay are not.
Change review. Proposing changes, generating diffs, and requiring approval before an atomic apply all work. It isn't yet connected to sessions or to the loop that turns corrections into reusable knowledge.
App generation. The system can generate, deploy and sandbox-run small internal apps. Production-grade isolation, lifecycle management, versioning and resource limits are open work.
Deployment. The backend is live and healthy on ECS/Fargate behind the load balancer. The frontend routing fix is verified locally but not yet live.
I haven't captured formal metrics such as latency, answer accuracy or citation precision, so this section sticks to what I can observe working.
Limitations
- The frontend fix isn't deployed to the live environment yet.
- Source grounding works but lacks stronger retrieval, ranking, and conflict and freshness handling.
- Only the realtime infrastructure exists. The full multiplayer AI experience (Live Sessions, Driver/Observer, redirects) doesn't.
- Approved changes aren't linked to sessions or to any mechanism that turns corrections into reusable knowledge.
- App generation lacks production-grade sandboxing, versioning and lifecycle management.
- Governance has a solid base (auth, roles, audit logs, credential encryption) but isn't enterprise-grade. There's no SSO/SCIM and no formal retention or compliance controls.
- The production database service (RDS, Aurora or other) is unconfirmed.
- The deployed Bedrock model version and the locked Tailwind version should be checked against the live configuration and the lockfile, not assumed from the README or
package.jsonrange.
What We Learned
The strongest part of this project isn't the landing page. It's that Conti-Newty turned out to be more than a prompt interface. It connects workspace knowledge, agent execution, citations, human review, collaboration and app generation into one loop, with workspace boundaries, permission checks, path validation and audit records underneath. None of that shows up in a screenshot, but it matters for anything that touches a real company's data.
An AI product isn't about connecting a model to a prompt. The hard parts are supplying the right context, keeping it inside real permission boundaries, showing evidence for claims, handling wrong output gracefully, letting humans review changes, and recording what happened. The loop that matters isn't:
Prompt → AnswerIt's:
Context → Agent work → Human review → Correction → Reusable knowledgeIf I rebuilt this, I'd do three things differently:
- Pick the core abstraction earlier. The system is organized around
AgentTask, but the direction I want is organized aroundLiveSession: participants, a driver, an observer, agent state, redirects, evidence, replay and applied skills.
- Split the legacy static frontend from the React frontend on day one. Having both
public/index.htmlandapps/web/index.htmlin one repo is exactly what made the deployment bug possible.
- Pin down the production database and migration workflow sooner. Local and production configurations need to stay aligned as the schema changes.
What's Next
None of this is implemented. It's the plan.
Live Agent Learning is the direction I'm building toward:
Workspace → LiveSession → Participants → AgentTask
→ Session Events → Redirect → Skill Proposal
→ Human Review → Confirmed Skill → Future Skill ReuseThat means Live Sessions with real participants, Driver and Observer roles, and human redirects mid-session. The system would generate a Skill Proposal from what happened in a session, a human would confirm it before it becomes a real skill, and confirmed skills would be reused in later sessions.
The immediate next step is finishing the deployment loop: rebuild and push the corrected image, then roll it out to ECS so the public URL reflects the frontend fix.
Final Takeaway
Conti-Newty is a working foundation, not a finished product. It has a real backend, a real agent loop, real source grounding and a real AWS pipeline, and the collaboration and learning pieces are still to be built. Keeping the line between what runs and what's planned clear mattered more to this project than any single feature.
Links
- GitHub: D1SH4NT121/Conti-Newty
- Live deployment: Conti-Newty (still serves the pre-fix frontend until the new image is deployed)
- Health endpoint: /api/health
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article