DEV Community: Brijesh Akbari

OpenAI Dots - What Always-On AI Agents Bring to the Table

Brijesh Akbari — Thu, 01 Oct 2026 11:18:19 +0000

For the last few years, most AI interactions have followed a very predictable pattern.

We open an AI assistant, explain what we need, provide some context, receive an answer, and move on.

Even as models have become significantly better at reasoning, coding, research, and tool use, there is still one thing humans usually have to do first:

Start the interaction.

That is what makes OpenAI Dots interesting.

Dots introduce the idea of always-on AI agents that can maintain context around an ongoing goal, work with connected applications, conduct research, and continue making progress beyond a single conversation.

This is less about another smarter chatbot and more about changing how we delegate work to AI.

From a Task to a Responsibility

Consider a simple example.

You could ask an AI:

Analyze our competitors and tell me what changed this week.

The AI researches the competitors, produces the analysis, and the task is complete.

But what if the instruction becomes:

Keep track of these competitors and surface meaningful changes that could affect our product positioning.

The difference looks small, but the underlying idea is quite different.

The first interaction gives AI a task.

The second gives AI an ongoing responsibility.

This is where persistent agents become interesting.

Most current AI workflows still depend heavily on humans to recognize when something needs to happen. We decide when research should start, provide the necessary context, review the result, and then determine the next action.

With persistent agents, AI can potentially remain connected to the objective instead of treating every interaction as an isolated request.

Why Context Matters More Than It Looks

Anyone using AI regularly for professional work has probably experienced the context problem.

You explain the company.

Then the product.

Then the target audience.

Then the project.

Then the objective.

Then the preferred way of working.

A few days later, another task appears and some of that context needs to be rebuilt.

Persistent agents could reduce that friction.

Think about working with someone who has been involved in your project for several months. You do not explain the entire project every morning before asking them to do something.

There is already shared context.

Bringing some version of that continuity into AI could be more valuable than simply making prompts increasingly sophisticated.

The useful AI systems of the future may therefore depend on more than model intelligence.

They will depend on how effectively intelligence, context, tools, permissions, memory, and persistence work together.

AI Is Also Moving Beyond the Chat Window

Another interesting aspect of Dots is the concept of a dedicated cloud computer.

This matters because actual work rarely happens inside one chat interface.

Developers work across repositories, documentation, terminals, issue trackers, browsers, cloud environments, and communication platforms. Marketing and business teams have their own collection of analytics platforms, documents, CRMs, dashboards, email, and project management systems.

If AI is going to become part of an ongoing workflow, it needs to operate closer to where that work happens.

The interaction then starts changing from:

Here's what you should do.

to something closer to:

Here's what changed, here's what I worked on, and here's where I need your decision.

That is a much more interesting model of human-AI collaboration.

More Autonomy Also Creates More Risk

There is an important catch.

Giving AI more responsibility also increases the consequences when something goes wrong.

An incorrect answer inside a chatbot can usually be reviewed and corrected.

An incorrect action performed inside a real workflow can have much larger consequences.

That means the future of AI agents cannot simply be about maximizing autonomy.

Permissions, boundaries, approval mechanisms, security, and human oversight become even more important.

The useful model is probably not AI doing everything independently.

It is controlled delegation.

Let AI handle appropriate research, monitoring, repetitive analysis, and execution while humans continue defining objectives, establishing boundaries, and making consequential decisions.

The Bigger Opportunity Might Be the Boring Work

The most valuable application of persistent agents may not be an AI independently building an entire application or operating an entire company.

It might be much simpler.

A large part of knowledge work consists of small repetitive loops.

We check whether something changed.

We prepare for meetings.

We research competitors.

We review project progress.

We search through documents.

We compare reports.

We summarize conversations.

We identify things that need attention.

None of these activities individually feels revolutionary.

Together, they consume a significant amount of time.

Persistent AI agents do not necessarily need to replace an entire job to create value. Removing dozens of these small coordination loops every week could be enough to meaningfully change how people work.

From AI Assistant to AI Collaborator

Generative AI started largely with generation.

Then models became better at reasoning.

Tool use allowed AI to interact with information and software outside the chat.

Agents started combining those capabilities into multi-step workflows.

Persistent agents introduce another important element:

Continuity.

Instead of only responding to whatever appears in the prompt box, AI can potentially remain involved with an objective.

That changes our role as well.

We move from specifying every individual action toward defining goals, context, permissions, boundaries, and success criteria.

AI handles more of the execution.

Humans remain responsible for direction and judgment.

And that may be the more important shift behind OpenAI Dots.

I explored the architecture, proactive research angle, cloud computer, connected apps, persistent context, autonomy risks, and what Dots could mean for real business workflows in more detail in the full article.

Continue reading the full article:
OpenAI Dots: What Always-On AI Agents Bring to the Table

AI for Startups: Building Scalable AI Solutions with AWS

Brijesh Akbari — Fri, 19 Dec 2025 11:26:00 +0000

Artificial Intelligence has shifted from being an experimental concept to a practical growth lever for startups. In 2025, the real challenge is no longer whether to use AI, but how to use it in a way that scales without adding unnecessary complexity.

For startups, AI should solve real problems, reduce friction, and accelerate decision-making. The goal is not to build the most advanced models, but to build systems that deliver measurable value.

What AI Really Means for Startups

AI for startups is not limited to chatbots or automation buzzwords. In practice, it often shows up as:

Smarter customer support with faster response times
Better insights from customer and product data
Personalized user experiences
Improved operational efficiency
Faster experimentation and iteration

The most successful startups treat AI as an enabler, not a separate initiative.

Why AWS Is a Strong Choice for Startup AI

AWS lowers the barrier to AI adoption by handling much of the infrastructure and operational complexity. This allows startups to focus on outcomes rather than setup.

Key reasons startups choose AWS for AI:
Pay-as-you-go pricing, which reduces upfront risk
Managed services, so teams don’t need large ML teams
Built-in security and compliance, important as startups scale
Flexibility, allowing startups to start small and grow gradually

This combination makes AWS especially suitable for early and growth-stage companies.

AWS AI Services Startups Commonly Use

Most startups begin with managed AI services that deliver quick wins.
Common starting points include:

Amazon Comprehend for text analysis and sentiment detection
Amazon Textract for extracting data from documents
Amazon Transcribe for speech-to-text use cases
Amazon Rekognition for image and video analysis

These services require minimal ML expertise and are often enough to unlock early value.

As needs grow, startups move toward:

Amazon SageMaker for building and deploying custom ML models
Amazon Bedrock for using generative AI and foundation models securely

The key is choosing services that align with the problem, not adopting everything at once.

A Practical Way to Start with AI

Startups that succeed with AI usually follow a simple pattern:
Start with a clear business problem, not a model
Use managed services before building custom solutions
Build a small AI-powered MVP
Measure impact early and iterate quickly
Scale only after the value is proven

This approach reduces risk and keeps AI aligned with business goals.

Common AI Mistakes Startups Should Avoid
Many AI initiatives fail due to avoidable mistakes, such as:

Chasing AI trends without a defined use case
Expecting AI to fix poor or unstructured data
Over-engineering solutions too early
Ignoring monitoring, governance, and cost control

Treating AI as a one-time project instead of a long-term capability
Avoiding these pitfalls often matters more than choosing the most advanced technology.

AI has become one of the most powerful tools available to startups, but only when used with intent and discipline. AWS provides the foundation to build AI solutions that are scalable, secure, and cost-effective, but success ultimately depends on making thoughtful choices at every stage.

If you want a deeper breakdown of how startups can adopt AI using AWS, including real-world use cases and practical guidance, you can explore the full article here:

https://signiance.com/ai-for-startups-how-to-build-scalable-ai-solutions-using-aws/

Why Most Startups Overpay for Cloud (and How to Fix It)

Brijesh Akbari — Wed, 02 Jul 2025 12:35:15 +0000

When you’re scaling fast and building with urgency, cloud spend often becomes an afterthought.

Startups move quickly, pushing features, shipping MVPs, and juggling priorities. However, without proper checks, that agility comes at a cost, one that grows silently month after month.

Cloud overspend doesn’t just affect your runway; it affects your engineering agility. When costs balloon, teams are forced into fire-fighting mode:

freezing features, delaying infrastructure improvements, or slashing key tools. And the worst part? Most of this cost is entirely avoidable.

Let’s break down exactly why most startups overpay for cloud and, more importantly, how you can fix it.

The Startup and Cloud Disconnect

When you’re building a startup, you’re juggling features, investor updates, hiring, and survival. Cloud optimization rarely makes it to the top of that list. Most founders and early engineers prioritize speed, not sustainability.

So, they often spin up EC2 instances, S3 buckets, and RDS databases manually and forget about them as soon as the feature ships. What starts as agility quickly becomes sprawl. The result is a monthly bill with mysterious charges and a growing number of unused resources quietly draining your runway.

It’s not that you’re doing it wrong; it’s that you’re not revisiting what you built during the rush.
Where the Real Waste Lives

Here’s where most of the cost bloat hides:

Overprovisioned Compute
Many startups use large instance types as a precaution, or never re-evaluate them as workloads stabilize. A t3.medium might be sufficient for an m5. Large if you monitor correctly.
Zombie Resources
These include unattached EBS volumes, idle load balancers, or temporary environments that were left on after a demo. A single forgotten staging instance running for three months can burn thousands.
Poor Tagging
Without proper tagging, such as owner, environment, or project, you lose visibility. It becomes nearly impossible to know what can be deleted, downgraded, or consolidated.
Lack of Auto Scaling
If your application is always running at maximum capacity even during low traffic, you’re paying for resources you don’t need 90 percent of the time.
Skipped Savings Plans and Reserved Instances
Startups often avoid long-term commitments out of fear. But if you know you’ll need a baseline of compute, committing can save up to 72 percent.

What You Can Start Doing Today

Cloud cost optimization isn’t about cutting corners; it’s about engineering smarter. Here’s how to take control:

Get Visibility First
Start with AWS Cost Explorer. Break down costs by service, tag, and region. Enable hourly and resource-level granularity. Utilize tools like CloudWatch or third-party platforms, such as CloudZero, to identify anomalies.
Tag Everything
Enforce a tagging policy before you launch anything new. Every resource should have at least the following: Environment (dev or prod), Owner, Project, and Expiration Date (for temporary assets).
Right-Size and Schedule
Use AWS Compute Optimizer or Trusted Advisor to find underutilized instances. Downgrade where possible. Use Auto Scaling and schedule on- or off-hours for development and test environments.
Clean Up Forgotten Resources
Run a monthly cleanup. Look for unattached volumes, old snapshots, and idle services. Use AWS Config rules or build automation with Terraform to handle this efficiently.
Adopt Cost-Aware Engineering
Educate your team on sharing dashboards. Add cost checks to sprint reviews. Cloud cost isn’t just the DevOps team’s responsibility; every engineer plays a part.

A Cultural Shift Toward FinOps
You don’t need a full-blown FinOps team, but you do need a mindset shift. Make cost a shared responsibility, like security. Just as you wouldn’t ship code without a security review, you shouldn’t deploy infrastructure without considering the associated costs.

Startups that instill this early on don’t just save money, they build smarter, faster, and more resilient systems. And when it’s time to scale, their foundations won’t crack under the weight of hidden inefficiencies.

Cloud isn’t expensive. Unmanaged cloud is.
Startups don’t need to sacrifice performance to lower their AWS bill. With just a few innovative practices such as visibility, cleanup, right-sizing, and culture, you can reclaim 20 to 40 percent of your spend and extend your runway without writing a single new line of code.

Your cloud bill won’t shrink on its own. But with a little effort, you’ll be surprised how quickly it can become one less thing to stress about.

Follow Me On LinkedIn To Get More Amazing Content

Agentic AI Vs Traditional AI

Brijesh Akbari — Wed, 25 Jun 2025 12:06:15 +0000

As someone who's been building with AI tools over the past few years from training small language models to integrating APIs into automated pipelines, I’ve seen firsthand how fast the ecosystem is evolving. What once felt like the edge of innovation (like chatbots and image classifiers) now feels like table stakes.

Today, we’re moving beyond task-based intelligence into something far more powerful Agentic AI. If you’re a developer or engineer working with AI, the shift from traditional ML models to goal-driven autonomous agents isn’t just theoretical. It’s redefining how we build products, write code, and deploy intelligent systems.

This article breaks down what Agentic AI really is, how it compares to traditional approaches, and why you the builder need to understand the mechanics behind it.

Traditional AI:
Predictive, Static, and Task-Focused
Traditional AI systems have always been built to solve narrow problems. You provide input, the system runs a pre-trained model or set of rules, and you get an output. It’s deterministic, mostly stateless, and often limited to a single decision step.

Examples include:

Classification models (e.g., spam detection, fraud detection)
Image recognition (CNNs)
Sentiment analysis on customer reviews
Rule-based chatbots

Technical Characteristics:

No memory or historical context
Operates within pre-defined feature space
No tool use or API orchestration
Performance = accuracy on known test sets

Limitations:

Poor generalization to unseen or multi-step tasks
High dependency on training data patterns
Limited real-world interactivity

Agentic AI: Goal-Seeking, Context-Aware, and Autonomous

Agentic AI goes a level deeper. These systems don’t just answer questions they pursue goals, plan steps, use tools, and adapt to feedback. Architecturally, they're built with components like memory, planners, retrievers, and tool executors.
Think of it like this: traditional AI is a calculator. Agentic AI is a junior engineer that can learn, ask for tools, and adapt based on what it's trying to achieve.

Real Examples:

Research agents that browse the web, extract key insights, and summarize reports
Coding agents like Devin AI that can write, test, and debug code independently
Task orchestration agents that handle complex workflows (e.g., onboarding flows, ticket resolution, report generation)

Core Components:

Foundation LLM (e.g., GPT-4, Claude) + planning module
Long- or short-term memory (vector stores or internal memory objects)
Tool execution layer (Python REPLs, APIs, CLI tools)
Feedback loop (reflection or human-in-the-loop)

Capabilities:

Autonomous decision-making
Stateful interaction with environments
Dynamic API/tool usage
Goal decomposition and re-planning

Key Differences: Traditional vs Agentic AI

Feature

Architecture
Autonomy
Reasoning
Memory
Tool Use
Interaction Style
Real-World Fit

Traditional AI

Stateless, single-output models
Low needs user input
Pattern-based inference
None
Not built-in
Input → Output
Static pipelines

Agentic AI

Stateful, modular, multi-step planning
High goal-driven and adaptive
Contextual reasoning and iterative planning
Persistent memory (short/long-term)
Integrated tool invocation (APIs, code, search)
Continuous loops (sense, think, act)

Dynamic environments and evolving contexts

Agentic systems resemble "software agents" from old AI papers but powered by massive pretrained LLMs and modern infra.

Why This Matters for Builders (Engineers, Not Just Execs)
If you’re writing prompts, building workflows with LangChain, or designing autonomous systems, this evolution isn’t optional it’s inevitable.

Here’s what you need to know:

The Way We Build Is Changing
Traditional ML workflows relied on training data → model → inference API.
With Agentic AI, you’re designing planners, memory stores, and tool wrappers.
You’re engineering orchestration layers, not just fine-tuning models.
Prompting Is Not Enough
You need to think about agent goals, tool design, retry policies, memory limits, and error handling.
LLM-as-agent is fragile unless you handle context length, hallucination traps, and token economy.
Tooling Ecosystem Is Still Young
Frameworks like LangChain, AutoGen, CrewAI, Semantic Kernel are evolving daily.
No one-size-fits-all. You need to test, debug, and log agent behavior like you would microservices.
Evaluation Metrics Are Different
Accuracy doesn't cut it. You now measure task success rate, goal achievement, token economy, etc.

Human-in-the-loop feedback becomes essential for reliability.

Challenges You’ll Face

Even the best builders run into edge cases and limitations:
Debugging Is Hard Agent loops, memory overwrite, or planner failures are often hard to trace. You’ll need structured logging and trace visualization.

Ethical & Safety Concerns
Autonomous systems can go rogue without boundaries. You’ll need guardrails, rate limits, and fallback flows.

Cost & Token Usage
Agents can easily become expensive if they don’t prune their memory or call too many APIs. Cost optimization is part of architecture now.

Final Thoughts:

We’re Not Building “Models” Anymore We’re Building Minds
Agentic AI isn’t a replacement for traditional AI it’s an evolution. It’s a step toward systems that reason, act, and improve with time. But with great flexibility comes greater engineering responsibility.

As a builder, understanding how to architect, test, and iterate on agentic systems is going to be one of the most valuable technical skills of the decade.

So here’s my question to you:
Are you still building with outputs in mind or with outcomes?
Let’s start thinking like system designers, not just prompt engineers.

You Can Follow Me On LinkedIn

The Proven AWS Cost Optimization Playbook Used by 100+ Teams to Save up to 30% Without Down time

Brijesh Akbari — Mon, 16 Jun 2025 21:05:58 +0000

A few months ago, I reviewed a client’s AWS bill $8,200 monthly for a workload that hadn’t changed much. Their infrastructure was stable, traffic predictable. So why the ballooning costs?

As the founder of a cloud-native DevOps services company, this wasn’t new. I’ve seen the same story play out over 100+ AWS accounts from startups to large SaaS companies.

Cloud bills creeping up. Performance untouched. Visibility lost.
So we built a playbook.

It’s simple, actionable, and gets results. No fluff. No fancy dashboards. Just what works.
Here’s how we’ve helped teams consistently reduce cloud spend by up to 30% without sacrificing performance.

Visibility First, Cost Explorer + Tagging Audit
We started with AWS Cost Explorer:
Enabled hourly + resource-level granularity
Filtered by service and linked accounts
Identified top 3 cost drivers (e.g., EC2, S3, Data Transfer)

Then we enforced tagging standards across all resources:
• Project
• Owner
• Environment (dev/stage/prod)
• Cost Centre

“Tag Before You Launch” Rule: No resource gets created without owner/environment tags. Shadow IT? Gone.

Bonus Tip:
Use AWS Resource Groups to group untagged assets for cleanup.

Lesson: Untagged = invisible = unaccountable. You can’t optimize what you can’t see.

Right-Size Compute – EC2, RDS & Kubernetes
Using AWS Compute Optimizer and performance metrics, we identified underutilized instances:
EC2 instances with <20% CPU/Memory over 14–30 days
Dev RDS instances that could auto-pause
ECS services idling with no traffic
Kubernetes workloads stuck in overprovisioned node pools

We optimized by:
• Downgrading EC2 families (e.g., m5 → t3)
• Migrating to Graviton (ARM-based = 20–40% savings)
• Shifting workloads to Spot Instances and Fargate

One client saved $3,700/mo in compute alone no performance drop.

Embrace Serverless & Auto-Scaling
We migrated microservices to AWS Lambda and containerized stateless workloads on Fargate.

Idle-time costs? Eliminated.
Auto-scaling ensures we’re only paying when something runs.

It wasn’t an overnight move but modularizing and breaking the monolith helped ease adoption.

Kill Zombie Infra
You’d be surprised how much cost hides in the shadows:
Orphaned EBS volumes
Idle Load Balancers
Elastic IPs without attachment
3-year-old log buckets on S3
Old RDS snapshots never cleaned

Use AWS Config + Trusted Advisor to surface these.

Pro Tip:
Enforce auto-termination policies on dev resources after X days of inactivity.

These don’t show up in dashboards but quietly bleed budget.

Storage Optimization with Lifecycle Policies
We implemented S3 lifecycle rules:
Archive logs to Glacier after 30 days
Auto-delete test artifacts after 90 days
Enable versioning cleanup

For EBS:
• Auto-delete snapshots beyond retention
• Clean up unused volumes post-instance termination

Small tweaks here = compounding savings over time.

Culture of Cost Awareness via Dashboards
We integrated CloudWatch and Grafana to visualize cost trends and infra performance.

Engineers could see:
• Which environments were spending the most
• Which services caused recent spikes
• Who “owned” each tag

Insight:
Visibility changed behavior. Engineers became budget-aware. Optimization became cultural.

Governance with FinOps Discipline
We enforced:
Budget alerts for all environments
Anomaly detection (via Cost Anomaly Detection + SNS alerts)
Weekly cloud cost reviews in sprint planning
Auto-cleanup of idle non-prod infra
Tagging enforcement policies

FinOps isn’t a tool it’s a mindset. And it starts with accountability and cadence. Results We’ve Consistently Delivered
• Up to 30% AWS bill reduction in 4–6 weeks
• Zero performance regression
• CI/CD pipelines accelerated
• Infra ownership across the team
• Predictable monthly billing

Tools We Used
• AWS Cost Explorer
• AWS Compute Optimizer
• AWS Config + Trusted Advisor
• CloudWatch
• Terraform (Infra as Code)
• AWS Lambda & Fargate
• S3 Lifecycle Rules
• Cost Anomaly Detection
• Budget Alerts + Tagging Policies

Final Thoughts for Founders & DevOps Leads

The truth is simple:
Cloud is powerful, But without visibility, you’re overpaying.
Cost optimization isn’t a one-time event it’s a continuous, cultural discipline. If you're not auditing your infra monthly, you're burning budget silently.

Want to find out how optimized your AWS bill really is?
We’re offering a 30-minute AWS Cost Audit, free.

DM me “audit” or schedule your session here:

Don’t just run on cloud. Run smart.

Check Out For More