Inspiration

Every time I used a general AI assistant like ChatGPT or Claude, I noticed the same limitation: they can process data you hand them, but they have no concept of permission or scope when it comes to actually operating inside a business's real systems. Paste a spreadsheet into a chat and it'll clean it up — but it never asks "should I be touching this?" That gap between "AI that can chat" and "AI that can safely act inside a company" is what pushed me to build Aritenis.

What it does

Aritenis Master takes a natural language request — e.g., "I need a worker to summarize today's sales and send it to the team" — and:

1. Uses a local LLM to interpret the request: identifying the target data source, the intended action, and the appropriate access scope
2. Displays a clear permission request before touching anything or sending anything externally
3. Only on explicit approval does it spawn a scoped worker limited to exactly that task
4. The worker reads the daily sales data, generates a clean summary, and delivers it automatically via WhatsApp and email using Twilio
5. Every permission grant, denial, and worker action is logged to an append-only audit trail

This closes the loop from "AI understands the task" to "AI safely delivers the result to the people who need it" — with permission and scope enforced at every step, not just promised in a prompt.

How we built it

I built the CLI in Python, using Codex to scaffold and refine the architecture: a Master class that interprets requests via a local LLM and manages the permission flow, a scoped Worker class that enforces its access boundary at runtime, and an append-only PermissionLog for auditability. I then extended the worker to integrate Twilio's API for WhatsApp messaging and email delivery, so a completed report doesn't just sit in a terminal — it actually reaches the people who need it, the same way a real assistant would.

Challenges we ran into

Codex usage limits were the biggest constraint — I hit my quota partway through, which forced me to be precise and plan full features before writing each prompt rather than iterating loosely. Integrating Twilio also meant handling real external delivery carefully: making sure the worker's permission scope genuinely gated whether a message could be sent, not just logging that it happened after the fact.

Accomplishments that we're proud of

Getting the full loop working end-to-end — natural language request, LLM-driven understanding, explicit permission approval, scoped execution, and real delivery via WhatsApp/email — feels like a genuine, complete demonstration of the core idea, not just a proof of concept. Seeing an actual summary land in WhatsApp after approving a permission prompt in the terminal was the moment it stopped feeling like a script and started feeling like a real assistant.

What we learned

Trustworthy AI inside a business isn't really a model-capability problem — it's an access-control and delivery-accountability problem. The smartest model in the world isn't useful to a company if it can't prove what it touched, who approved it, and where the output actually went. Building the permission-and-audit layer taught me more about what makes AI genuinely deployable than the model integration itself did.

What's next for Aritenis — Permissioned AI Worker Agents

Next is expanding beyond daily sales summaries to handle multi-step tasks that chain several workers together, adding real integrations with live tools (Google Sheets/Excel Online APIs instead of local files), and building enterprise-grade permission policies — role-based scopes, expiring grants, and approval chains for higher-risk actions like external messaging.

Built With

• codex
• ollama
• python
• twilio